diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 4c1098741..86b45fff6 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -23,9 +23,8 @@ repos: - id: flake8 - repo: local hooks: - - id: check-substrait-extensions - name: Check Substrait extensions - entry: pytest tests/test_extensions.py::test_read_substrait_extensions + - id: check-substrait-extensions_coverage + name: Check Substrait extensions and test coverage + entry: pytest tests/test_extensions.py::test_substrait_extension_coverage language: python pass_filenames: false - diff --git a/grammar/FuncTestCaseLexer.g4 b/grammar/FuncTestCaseLexer.g4 index 7777e1e8f..5727df5eb 100644 --- a/grammar/FuncTestCaseLexer.g4 +++ b/grammar/FuncTestCaseLexer.g4 @@ -10,6 +10,7 @@ Whitespace : [ \t\n\r]+ -> channel(HIDDEN) ; TripleHash: '###'; SubstraitScalarTest: 'SUBSTRAIT_SCALAR_TEST'; +SubstraitAggregateTest: 'SUBSTRAIT_AGGREGATE_TEST'; SubstraitInclude: 'SUBSTRAIT_INCLUDE'; FormatVersion @@ -20,6 +21,7 @@ DescriptionLine : '# ' ~[\r\n]* '\r'? '\n' ; +Define: 'DEFINE'; ErrorResult: ''; UndefineResult: ''; Overflow: 'OVERFLOW'; @@ -102,3 +104,7 @@ NullLiteral: 'null'; StringLiteral : '\'' ('\\' . | '\'\'' | ~['\\])* '\'' ; + +ColumnName + : 'COL' Int + ; diff --git a/grammar/FuncTestCaseParser.g4 b/grammar/FuncTestCaseParser.g4 index 979d582d9..8765b6378 100644 --- a/grammar/FuncTestCaseParser.g4 +++ b/grammar/FuncTestCaseParser.g4 @@ -15,7 +15,7 @@ header ; version - : TripleHash SubstraitScalarTest Colon FormatVersion + : TripleHash (SubstraitScalarTest | SubstraitAggregateTest) Colon FormatVersion ; include @@ -31,7 +31,8 @@ testCase ; testGroup - : testGroupDescription (testCase)+ + : testGroupDescription (testCase)+ #scalarFuncTestGroup + | testGroupDescription (aggFuncTestCase)+ #aggregateFuncTestGroup ; arguments @@ -58,6 +59,63 @@ argument | intervalDayArg ; +aggFuncTestCase + : aggFuncCall ( OBracket func_options CBracket )? Eq result + ; + +aggFuncCall + : tableData funcName=Identifier OParen qualifiedAggregateFuncArgs CParen #multiArgAggregateFuncCall + | tableRows functName=Identifier OParen aggregateFuncArgs CParen #compactAggregateFuncCall + | functName=Identifier OParen dataColumn CParen #singleArgAggregateFuncCall + ; + +tableData + : Define tableName=Identifier OParen dataType (Comma dataType)* CParen Eq tableRows + ; + +tableRows + : OParen (literalValueList (Comma literalValueList)*)? CParen + ; + +dataColumn + : literalValueList DoubleColon dataType + ; + +literalValueList + : OParen (literal (Comma literal)*)? CParen + ; + +literal + : NullLiteral + | numericLiteral + | BooleanLiteral + | StringLiteral + | DateLiteral + | TimeLiteral + | TimestampLiteral + | TimestampTzLiteral + | IntervalYearLiteral + | IntervalDayLiteral + ; + +qualifiedAggregateFuncArgs + : qualifiedAggregateFuncArg (Comma qualifiedAggregateFuncArg)* + ; + +aggregateFuncArgs + : aggregateFuncArg (Comma aggregateFuncArg)* + ; + +qualifiedAggregateFuncArg + : tableName=Identifier Dot ColumnName + | argument + ; + +aggregateFuncArg + : ColumnName DoubleColon dataType + | argument + ; + numericLiteral : DecimalLiteral | IntegerLiteral | floatLiteral ; @@ -66,7 +124,7 @@ floatLiteral : FloatLiteral | NaN ; -nullArg: NullLiteral DoubleColon datatype; +nullArg: NullLiteral DoubleColon dataType; intArg: IntegerLiteral DoubleColon (I8 | I16 | I32 | I64); @@ -77,11 +135,11 @@ decimalArg ; booleanArg - : BooleanLiteral DoubleColon Bool + : BooleanLiteral DoubleColon (Bool | Boolean) ; stringArg - : StringLiteral DoubleColon Str + : StringLiteral DoubleColon (Str | String) ; dateArg @@ -93,19 +151,19 @@ timeArg ; timestampArg - : TimestampLiteral DoubleColon Ts + : TimestampLiteral DoubleColon (Ts | Timestamp) ; timestampTzArg - : TimestampTzLiteral DoubleColon TsTZ + : TimestampTzLiteral DoubleColon (TsTZ | Timestamp_TZ) ; intervalYearArg - : IntervalYearLiteral DoubleColon IYear + : IntervalYearLiteral DoubleColon (IYear | Interval_Year) ; intervalDayArg - : IntervalDayLiteral DoubleColon IDay + : IntervalDayLiteral DoubleColon (IDay | Interval_Day) ; intervalYearLiteral @@ -126,53 +184,56 @@ timeInterval | fractionalSeconds=IntegerLiteral FractionalSecondSuffix ; -datatype +dataType : scalarType | parameterizedType ; scalarType - : Bool #Boolean - | I8 #i8 - | I16 #i16 - | I32 #i32 - | I64 #i64 - | FP32 #fp32 - | FP64 #fp64 - | Str #string - | Binary #binary - | Ts #timestamp - | TsTZ #timestampTz - | Date #date - | Time #time - | IDay #intervalDay - | IYear #intervalYear - | UUID #uuid - | UserDefined Identifier #userDefined + : (Bool | Boolean) #boolean + | I8 #i8 + | I16 #i16 + | I32 #i32 + | I64 #i64 + | FP32 #fp32 + | FP64 #fp64 + | (Str | String) #string + | (Binary | VBin) #binary + | (Ts | Timestamp) #timestamp + | (TsTZ | Timestamp_TZ) #timestampTz + | Date #date + | Time #time + | (IDay | Interval_Year) #intervalDay + | (IYear | Interval_Day) #intervalYear + | UUID #uuid + | UserDefined Identifier #userDefined ; fixedCharType - : FChar isnull=QMark? OAngleBracket len=numericParameter CAngleBracket #fixedChar + : (FChar | FixedChar) isnull=QMark? OAngleBracket len=numericParameter CAngleBracket #fixedChar ; varCharType - : VChar isnull=QMark? OAngleBracket len=numericParameter CAngleBracket #varChar + : (VChar | VarChar) isnull=QMark? OAngleBracket len=numericParameter CAngleBracket #varChar ; fixedBinaryType - : FBin isnull=QMark? OAngleBracket len=numericParameter CAngleBracket #fixedBinary + : (FBin | FixedBinary) isnull=QMark? OAngleBracket len=numericParameter CAngleBracket #fixedBinary ; decimalType - : Dec isnull=QMark? (OAngleBracket precision=numericParameter Comma scale=numericParameter CAngleBracket)? #decimal + : (Dec | Decimal) isnull=QMark? + (OAngleBracket precision=numericParameter Comma scale=numericParameter CAngleBracket)? #decimal ; precisionTimestampType - : PTs isnull=QMark? OAngleBracket precision=numericParameter CAngleBracket #precisionTimestamp + : (PTs | Precision_Timestamp) isnull=QMark? + OAngleBracket precision=numericParameter CAngleBracket #precisionTimestamp ; precisionTimestampTZType - : PTsTZ isnull=QMark? OAngleBracket precision=numericParameter CAngleBracket #precisionTimestampTZ + : (PTsTZ | Precision_Timestamp_TZ) isnull=QMark? + OAngleBracket precision=numericParameter CAngleBracket #precisionTimestampTZ ; parameterizedType diff --git a/tests/cases/arithmetic/max.test b/tests/cases/arithmetic/max.test new file mode 100644 index 000000000..b52959b61 --- /dev/null +++ b/tests/cases/arithmetic/max.test @@ -0,0 +1,18 @@ +### SUBSTRAIT_AGGREGATE_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/functions_arithmetic.yaml' + +# basic: Basic examples without any special cases +max((20, -3, 1, -10, 0, 5)::i8) = 20::i8 +max((-32768, 32767, 20000, -30000)::i16) = 32767::i16 +max((-214748648, 214748647, 21470048, 4000000)::i32) = 214748647::i32 +max((2000000000, -3217908979, 629000000, -100000000, 0, 987654321)::i64) = 2000000000::i64 +max((2.5, 0, 5.0, -2.5, -7.5)::fp32) = 5.0::fp32 +max((1.5e+308, 1.5e+10, -1.5e+8, -1.5e+7, -1.5e+70)::fp64) = 1.5e+308::fp64 + +# null_handling: Examples with null as input or output +max((Null, Null, Null)::i16) = Null::i16 +max(()::i16) = Null::i16 +max((2000000000, Null, 629000000, -100000000, Null, 987654321)::i64) = 2000000000::i64 +max((Null, inf)::fp64) = inf::fp64 +max((Null, -inf, -1.5e+8, -1.5e+7, -1.5e+70)::fp64) = -1.5e+7::fp64 +max((1.5e+308, 1.5e+10, Null, -1.5e+7, Null)::fp64) = 1.5e+308::fp64 diff --git a/tests/coverage/antlr_parser/FuncTestCaseLexer.py b/tests/coverage/antlr_parser/FuncTestCaseLexer.py index 244921049..16c69188e 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseLexer.py +++ b/tests/coverage/antlr_parser/FuncTestCaseLexer.py @@ -14,8 +14,8 @@ def serializedATN(): return [ 4, 0, - 112, - 1093, + 115, + 1137, 6, -1, 2, @@ -490,18 +490,30 @@ def serializedATN(): 117, 7, 117, + 2, + 118, + 7, + 118, + 2, + 119, + 7, + 119, + 2, + 120, + 7, + 120, 1, 0, 4, 0, - 239, + 245, 8, 0, 11, 0, 12, 0, - 240, + 246, 1, 0, 1, @@ -595,68 +607,87 @@ def serializedATN(): 1, 3, 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 1, 4, 1, 4, + 1, 4, + 1, 4, - 291, - 8, + 1, 4, - 11, + 1, 4, - 12, + 1, 4, - 292, 1, 4, 1, 4, + 1, 4, + 1, 4, - 297, - 8, + 1, 4, - 11, + 1, 4, - 12, + 1, 4, - 298, - 3, + 1, 4, - 301, - 8, + 1, 4, 1, - 5, + 4, 1, - 5, + 4, 1, 5, 1, 5, + 4, 5, - 5, - 307, + 322, 8, 5, - 10, + 11, 5, 12, 5, - 310, - 9, + 323, + 1, 5, 1, 5, - 3, + 4, 5, - 313, + 328, 8, 5, - 1, + 11, 5, - 1, + 12, + 5, + 329, + 3, + 5, + 332, + 8, 5, 1, 6, @@ -666,28 +697,29 @@ def serializedATN(): 6, 1, 6, - 1, + 5, 6, - 1, + 338, + 8, 6, - 1, + 10, 6, - 1, + 12, 6, - 1, + 341, + 9, 6, 1, - 7, - 1, - 7, - 1, - 7, - 1, - 7, + 6, + 3, + 6, + 344, + 8, + 6, 1, - 7, + 6, 1, - 7, + 6, 1, 7, 1, @@ -739,6 +771,14 @@ def serializedATN(): 1, 9, 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, 10, 1, 10, @@ -751,7 +791,11 @@ def serializedATN(): 1, 10, 1, - 11, + 10, + 1, + 10, + 1, + 10, 1, 11, 1, @@ -769,7 +813,7 @@ def serializedATN(): 1, 11, 1, - 12, + 11, 1, 12, 1, @@ -801,11 +845,11 @@ def serializedATN(): 1, 13, 1, - 13, + 14, 1, - 13, + 14, 1, - 13, + 14, 1, 14, 1, @@ -816,10 +860,23 @@ def serializedATN(): 14, 1, 15, - 3, + 1, 15, - 396, - 8, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, 15, 1, 15, @@ -827,157 +884,138 @@ def serializedATN(): 15, 1, 16, - 3, + 1, 16, - 401, - 8, + 1, 16, 1, 16, + 1, + 17, + 3, + 17, + 434, + 8, + 17, + 1, + 17, + 1, + 17, + 1, + 18, + 3, + 18, + 439, + 8, + 18, + 1, + 18, 4, - 16, - 404, + 18, + 442, 8, - 16, + 18, 11, - 16, + 18, 12, - 16, - 405, + 18, + 443, 1, - 16, + 18, 1, - 16, + 18, 4, - 16, - 410, + 18, + 448, 8, - 16, + 18, 11, - 16, + 18, 12, - 16, - 411, + 18, + 449, 3, - 16, - 414, + 18, + 452, 8, - 16, + 18, 1, - 17, + 19, 3, - 17, - 417, + 19, + 455, 8, - 17, + 19, 1, - 17, + 19, 4, - 17, - 420, + 19, + 458, 8, - 17, + 19, 11, - 17, + 19, 12, - 17, - 421, + 19, + 459, 1, - 17, + 19, 1, - 17, + 19, 5, - 17, - 426, + 19, + 464, 8, - 17, + 19, 10, - 17, + 19, 12, - 17, - 429, + 19, + 467, 9, - 17, + 19, 3, - 17, - 431, + 19, + 469, 8, - 17, + 19, 1, - 17, + 19, 1, - 17, + 19, 3, - 17, - 435, + 19, + 473, 8, - 17, + 19, 1, - 17, + 19, 4, - 17, - 438, + 19, + 476, 8, - 17, + 19, 11, - 17, + 19, 12, - 17, - 439, - 3, - 17, - 442, - 8, - 17, - 1, - 17, + 19, + 477, 3, - 17, - 445, + 19, + 480, 8, - 17, - 1, - 17, - 1, - 17, - 1, - 17, - 1, - 17, - 1, - 17, - 1, - 17, + 19, 1, - 17, + 19, 3, - 17, - 454, + 19, + 483, 8, - 17, - 1, - 18, - 1, - 18, - 1, - 18, - 1, - 18, - 1, - 18, - 1, - 18, - 1, - 18, + 19, 1, - 18, + 19, 1, - 18, - 3, - 18, - 465, - 8, - 18, + 19, 1, 19, 1, @@ -988,6 +1026,11 @@ def serializedATN(): 19, 1, 19, + 3, + 19, + 492, + 8, + 19, 1, 20, 1, @@ -995,50 +1038,22 @@ def serializedATN(): 1, 20, 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, + 20, 1, - 21, + 20, 1, - 21, + 20, 1, - 21, + 20, 1, - 21, + 20, 1, - 21, - 4, - 21, - 489, - 8, - 21, - 11, - 21, - 12, - 21, - 490, + 20, 3, - 21, - 493, + 20, + 503, 8, - 21, - 1, - 21, + 20, 1, 21, 1, @@ -1056,46 +1071,17 @@ def serializedATN(): 1, 22, 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, + 23, 1, - 22, + 23, 1, - 22, + 23, 1, - 22, - 4, - 22, - 515, - 8, - 22, - 11, - 22, - 12, - 22, - 516, - 3, - 22, - 519, - 8, - 22, + 23, 1, - 22, + 23, 1, - 22, + 23, 1, 23, 1, @@ -1114,17 +1100,17 @@ def serializedATN(): 23, 4, 23, - 531, + 527, 8, 23, 11, 23, 12, 23, - 532, + 528, 3, 23, - 535, + 531, 8, 23, 1, @@ -1132,9 +1118,13 @@ def serializedATN(): 1, 23, 1, - 24, + 23, 1, - 24, + 23, + 1, + 23, + 1, + 23, 1, 24, 1, @@ -1148,125 +1138,135 @@ def serializedATN(): 1, 24, 1, - 25, + 24, 1, - 25, + 24, 1, - 26, + 24, 1, - 26, + 24, 1, - 27, + 24, 1, - 27, + 24, 1, - 28, + 24, 1, - 28, + 24, + 4, + 24, + 553, + 8, + 24, + 11, + 24, + 12, + 24, + 554, + 3, + 24, + 557, + 8, + 24, 1, - 29, + 24, 1, - 29, + 24, 1, - 30, + 25, 1, - 30, + 25, 1, - 31, + 25, 1, - 31, + 25, 1, - 32, + 25, 1, - 32, + 25, 1, - 33, + 25, 1, - 33, + 25, + 4, + 25, + 569, + 8, + 25, + 11, + 25, + 12, + 25, + 570, + 3, + 25, + 573, + 8, + 25, 1, - 34, + 25, 1, - 34, + 25, 1, - 35, + 26, 1, - 35, + 26, 1, - 35, + 26, 1, - 35, + 26, 1, - 35, + 26, 1, - 35, + 26, 1, - 35, - 3, - 35, - 574, - 8, - 35, + 26, 1, - 35, + 26, 1, - 35, + 27, 1, - 35, + 27, 1, - 35, + 28, 1, - 35, + 28, 1, - 35, + 29, 1, - 35, + 29, 1, - 35, - 3, - 35, - 584, - 8, - 35, + 30, 1, - 36, + 30, 1, - 36, + 31, 1, - 36, + 31, 1, - 36, + 32, 1, - 36, + 32, 1, - 36, + 33, 1, - 36, - 3, - 36, - 593, - 8, - 36, + 33, 1, - 36, + 34, 1, - 36, + 34, 1, - 36, + 35, 1, - 36, + 35, 1, 36, 1, 36, 1, - 36, + 37, 1, - 36, - 3, - 36, - 603, - 8, - 36, + 37, 1, 37, 1, @@ -1279,7 +1279,7 @@ def serializedATN(): 37, 3, 37, - 610, + 612, 8, 37, 1, @@ -1288,10 +1288,9 @@ def serializedATN(): 37, 1, 37, - 3, + 1, 37, - 615, - 8, + 1, 37, 1, 37, @@ -1301,119 +1300,144 @@ def serializedATN(): 37, 3, 37, - 620, + 622, 8, 37, 1, - 37, + 38, 1, - 37, + 38, 1, - 37, + 38, 1, - 37, + 38, 1, - 37, + 38, + 1, + 38, + 1, + 38, 3, - 37, - 627, + 38, + 631, 8, - 37, + 38, 1, - 37, + 38, 1, - 37, + 38, 1, - 37, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, 3, - 37, - 632, + 38, + 641, 8, - 37, + 38, 1, - 37, + 39, 1, - 37, + 39, 1, - 37, + 39, 1, - 37, + 39, 1, - 37, + 39, 3, - 37, - 639, + 39, + 648, 8, - 37, + 39, 1, - 37, + 39, 1, - 37, + 39, 1, - 37, + 39, 3, - 37, - 644, + 39, + 653, 8, - 37, + 39, 1, - 38, + 39, 1, - 38, + 39, 1, - 38, + 39, + 3, + 39, + 658, + 8, + 39, 1, - 38, + 39, 1, - 38, + 39, 1, 39, 1, 39, 1, 39, + 3, + 39, + 665, + 8, + 39, + 1, + 39, + 1, + 39, 1, 39, + 3, + 39, + 670, + 8, + 39, 1, 39, 1, 39, - 5, + 1, 39, - 657, - 8, + 1, 39, - 10, + 1, 39, - 12, + 3, 39, - 660, - 9, + 677, + 8, 39, 1, 39, 1, 39, 1, - 40, + 39, + 3, + 39, + 682, + 8, + 39, 1, 40, 1, 40, 1, 40, - 5, - 40, - 668, - 8, - 40, - 10, - 40, - 12, - 40, - 671, - 9, - 40, 1, 40, 1, @@ -1428,35 +1452,18 @@ def serializedATN(): 41, 1, 41, - 4, - 41, - 680, - 8, - 41, - 11, - 41, - 12, - 41, - 681, - 1, - 41, - 3, - 41, - 685, - 8, - 41, 1, 41, 5, 41, - 688, + 695, 8, 41, 10, 41, 12, 41, - 691, + 698, 9, 41, 1, @@ -1464,16 +1471,36 @@ def serializedATN(): 1, 41, 1, - 41, + 42, 1, - 41, + 42, 1, - 41, + 42, 1, 42, 1, 42, 1, + 42, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 5, + 43, + 712, + 8, + 43, + 10, + 43, + 12, + 43, + 715, + 9, 43, 1, 43, @@ -1489,24 +1516,51 @@ def serializedATN(): 44, 1, 44, + 4, + 44, + 724, + 8, + 44, + 11, + 44, + 12, + 44, + 725, 1, - 45, + 44, + 3, + 44, + 729, + 8, + 44, 1, - 45, + 44, + 5, + 44, + 732, + 8, + 44, + 10, + 44, + 12, + 44, + 735, + 9, + 44, 1, - 45, + 44, 1, - 45, + 44, 1, - 45, + 44, 1, - 46, + 44, 1, - 46, + 44, 1, - 46, + 45, 1, - 46, + 45, 1, 46, 1, @@ -1514,7 +1568,9 @@ def serializedATN(): 1, 46, 1, - 46, + 47, + 1, + 47, 1, 47, 1, @@ -1530,6 +1586,8 @@ def serializedATN(): 1, 48, 1, + 48, + 1, 49, 1, 49, @@ -1538,15 +1596,19 @@ def serializedATN(): 1, 49, 1, - 50, + 49, 1, - 50, + 49, + 1, + 49, + 1, + 49, 1, 50, 1, 50, 1, - 51, + 50, 1, 51, 1, @@ -1564,14 +1626,6 @@ def serializedATN(): 1, 52, 1, - 52, - 1, - 53, - 1, - 53, - 1, - 53, - 1, 53, 1, 53, @@ -1590,20 +1644,6 @@ def serializedATN(): 1, 54, 1, - 54, - 1, - 54, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, 55, 1, 55, @@ -1628,17 +1668,9 @@ def serializedATN(): 1, 56, 1, - 56, - 1, - 56, - 1, - 56, - 1, - 56, - 1, - 56, + 57, 1, - 56, + 57, 1, 57, 1, @@ -1660,15 +1692,15 @@ def serializedATN(): 1, 58, 1, - 59, + 58, 1, - 59, + 58, 1, - 59, + 58, 1, - 59, + 58, 1, - 59, + 58, 1, 59, 1, @@ -1688,21 +1720,13 @@ def serializedATN(): 1, 59, 1, - 60, - 1, - 60, - 1, - 60, - 1, - 60, - 1, - 60, + 59, 1, - 60, + 59, 1, - 60, + 59, 1, - 60, + 59, 1, 60, 1, @@ -1740,31 +1764,17 @@ def serializedATN(): 1, 62, 1, - 63, - 1, - 63, - 1, - 63, - 1, - 63, - 1, - 63, - 1, - 63, - 1, - 63, - 1, - 63, + 62, 1, - 63, + 62, 1, - 63, + 62, 1, - 63, + 62, 1, - 63, + 62, 1, - 63, + 62, 1, 63, 1, @@ -1780,41 +1790,17 @@ def serializedATN(): 1, 63, 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, + 63, 1, - 64, + 63, 1, - 64, + 63, 1, - 64, + 63, 1, - 64, + 63, 1, - 64, + 63, 1, 64, 1, @@ -1842,9 +1828,29 @@ def serializedATN(): 1, 65, 1, - 65, + 66, 1, - 65, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, 1, 66, 1, @@ -1886,6 +1892,34 @@ def serializedATN(): 1, 67, 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 68, + 1, + 68, + 1, + 68, + 1, 68, 1, 68, @@ -1926,6 +1960,26 @@ def serializedATN(): 1, 70, 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 71, + 1, + 71, + 1, + 71, + 1, 71, 1, 71, @@ -1940,6 +1994,16 @@ def serializedATN(): 1, 72, 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, 73, 1, 73, @@ -1964,9 +2028,7 @@ def serializedATN(): 1, 75, 1, - 75, - 1, - 75, + 76, 1, 76, 1, @@ -1974,7 +2036,7 @@ def serializedATN(): 1, 76, 1, - 77, + 76, 1, 77, 1, @@ -1994,17 +2056,13 @@ def serializedATN(): 1, 78, 1, - 78, - 1, - 79, - 1, 79, 1, 79, 1, 79, 1, - 79, + 80, 1, 80, 1, @@ -2022,9 +2080,9 @@ def serializedATN(): 1, 81, 1, - 82, + 81, 1, - 82, + 81, 1, 82, 1, @@ -2034,9 +2092,7 @@ def serializedATN(): 1, 82, 1, - 83, - 1, - 83, + 82, 1, 83, 1, @@ -2054,9 +2110,7 @@ def serializedATN(): 1, 84, 1, - 84, - 1, - 84, + 85, 1, 85, 1, @@ -2076,6 +2130,16 @@ def serializedATN(): 1, 86, 1, + 86, + 1, + 86, + 1, + 87, + 1, + 87, + 1, + 87, + 1, 87, 1, 87, @@ -2088,6 +2152,14 @@ def serializedATN(): 1, 88, 1, + 88, + 1, + 88, + 1, + 89, + 1, + 89, + 1, 89, 1, 89, @@ -2096,6 +2168,10 @@ def serializedATN(): 1, 90, 1, + 90, + 1, + 91, + 1, 91, 1, 91, @@ -2116,10 +2192,6 @@ def serializedATN(): 1, 95, 1, - 95, - 1, - 96, - 1, 96, 1, 96, @@ -2128,7 +2200,7 @@ def serializedATN(): 1, 97, 1, - 97, + 98, 1, 98, 1, @@ -2138,6 +2210,10 @@ def serializedATN(): 1, 99, 1, + 99, + 1, + 100, + 1, 100, 1, 100, @@ -2182,12 +2258,6 @@ def serializedATN(): 1, 110, 1, - 110, - 1, - 110, - 1, - 111, - 1, 111, 1, 111, @@ -2196,82 +2266,100 @@ def serializedATN(): 1, 112, 1, - 112, - 1, 113, 1, 113, - 5, - 113, - 1064, - 8, - 113, - 10, - 113, - 12, - 113, - 1067, - 9, - 113, 1, 113, - 3, - 113, - 1070, - 8, + 1, 113, 1, 114, 1, 114, 1, - 115, - 3, - 115, - 1075, - 8, - 115, + 114, 1, 115, 1, 115, 1, - 116, + 115, 1, 116, 1, 116, 5, 116, - 1082, + 1108, 8, 116, 10, 116, 12, 116, - 1085, + 1111, 9, 116, 1, + 116, + 3, + 116, + 1114, + 8, + 116, + 1, 117, 1, 117, + 1, + 118, 3, - 117, - 1089, + 118, + 1119, 8, - 117, + 118, 1, - 117, + 118, + 1, + 118, + 1, + 119, + 1, + 119, + 1, + 119, + 5, + 119, + 1126, + 8, + 119, + 10, + 119, + 12, + 119, + 1129, + 9, + 119, + 1, + 120, + 1, + 120, 3, - 117, - 1092, + 120, + 1133, 8, - 117, + 120, + 1, + 120, + 3, + 120, + 1136, + 8, + 120, 0, 0, - 118, + 121, 1, 1, 3, @@ -2311,13 +2399,13 @@ def serializedATN(): 37, 19, 39, - 0, + 20, 41, - 0, + 21, 43, - 20, + 0, 45, - 21, + 0, 47, 22, 49, @@ -2347,23 +2435,23 @@ def serializedATN(): 73, 35, 75, - 0, - 77, 36, - 79, + 77, 37, + 79, + 0, 81, 38, 83, 39, 85, - 0, - 87, 40, - 89, + 87, 41, - 91, + 89, 42, + 91, + 0, 93, 43, 95, @@ -2499,15 +2587,21 @@ def serializedATN(): 225, 109, 227, - 0, + 110, 229, - 0, + 111, 231, - 110, + 112, 233, - 111, + 0, 235, - 112, + 0, + 237, + 113, + 239, + 114, + 241, + 115, 1, 0, 31, @@ -2581,6 +2675,12 @@ def serializedATN(): 101, 2, 0, + 71, + 71, + 103, + 103, + 2, + 0, 78, 78, 110, @@ -2605,30 +2705,24 @@ def serializedATN(): 13, 2, 0, - 79, - 79, - 111, - 111, - 2, - 0, 70, 70, 102, 102, 2, 0, + 79, + 79, + 111, + 111, + 2, + 0, 87, 87, 119, 119, 2, 0, - 71, - 71, - 103, - 103, - 2, - 0, 43, 43, 45, @@ -2699,7 +2793,7 @@ def serializedATN(): 95, 97, 122, - 1141, + 1185, 0, 1, 1, @@ -2815,13 +2909,13 @@ def serializedATN(): 0, 0, 0, - 43, + 39, 1, 0, 0, 0, 0, - 45, + 41, 1, 0, 0, @@ -2911,13 +3005,13 @@ def serializedATN(): 0, 0, 0, - 77, + 75, 1, 0, 0, 0, 0, - 79, + 77, 1, 0, 0, @@ -2935,19 +3029,19 @@ def serializedATN(): 0, 0, 0, - 87, + 85, 1, 0, 0, 0, 0, - 89, + 87, 1, 0, 0, 0, 0, - 91, + 89, 1, 0, 0, @@ -3355,163 +3449,181 @@ def serializedATN(): 0, 0, 0, + 227, + 1, + 0, + 0, + 0, + 0, + 229, + 1, + 0, + 0, + 0, + 0, 231, 1, 0, 0, 0, 0, - 233, + 237, 1, 0, 0, 0, 0, - 235, + 239, + 1, + 0, + 0, + 0, + 0, + 241, 1, 0, 0, 0, 1, - 238, + 244, 1, 0, 0, 0, 3, - 244, + 250, 1, 0, 0, 0, 5, - 248, + 254, 1, 0, 0, 0, 7, - 270, + 276, 1, 0, 0, 0, 9, - 288, + 301, 1, 0, 0, 0, 11, - 302, + 319, 1, 0, 0, 0, 13, - 316, + 333, 1, 0, 0, 0, 15, - 325, + 347, 1, 0, 0, 0, 17, - 338, + 354, 1, 0, 0, 0, 19, - 347, + 363, 1, 0, 0, 0, 21, - 356, + 376, 1, 0, 0, 0, 23, - 362, + 385, 1, 0, 0, 0, 25, - 371, + 394, 1, 0, 0, 0, 27, - 378, + 400, 1, 0, 0, 0, 29, - 390, + 409, 1, 0, 0, 0, 31, - 395, + 416, 1, 0, 0, 0, 33, - 400, + 428, 1, 0, 0, 0, 35, - 453, + 433, 1, 0, 0, 0, 37, - 464, + 438, 1, 0, 0, 0, 39, - 466, + 491, 1, 0, 0, 0, 41, - 471, + 502, 1, 0, 0, 0, 43, - 474, + 504, 1, 0, 0, 0, 45, - 500, + 509, 1, 0, 0, 0, 47, - 522, + 512, 1, 0, 0, @@ -3523,67 +3635,67 @@ def serializedATN(): 0, 0, 51, - 546, + 560, 1, 0, 0, 0, 53, - 548, + 576, 1, 0, 0, 0, 55, - 550, + 584, 1, 0, 0, 0, 57, - 552, + 586, 1, 0, 0, 0, 59, - 554, + 588, 1, 0, 0, 0, 61, - 556, + 590, 1, 0, 0, 0, 63, - 558, + 592, 1, 0, 0, 0, 65, - 560, + 594, 1, 0, 0, 0, 67, - 562, + 596, 1, 0, 0, 0, 69, - 564, + 598, 1, 0, 0, 0, 71, - 583, + 600, 1, 0, 0, @@ -3595,6010 +3707,6256 @@ def serializedATN(): 0, 0, 75, - 643, + 621, 1, 0, 0, 0, 77, - 645, + 640, 1, 0, 0, 0, 79, - 650, + 681, 1, 0, 0, 0, 81, - 663, + 683, 1, 0, 0, 0, 83, - 674, + 688, 1, 0, 0, 0, 85, - 697, + 701, 1, 0, 0, 0, 87, - 699, + 707, 1, 0, 0, 0, 89, - 702, + 718, 1, 0, 0, 0, 91, - 707, + 741, 1, 0, 0, 0, 93, - 712, + 743, 1, 0, 0, 0, 95, - 720, + 746, 1, 0, 0, 0, 97, - 723, + 751, 1, 0, 0, 0, 99, - 727, + 756, 1, 0, 0, 0, 101, - 731, + 764, 1, 0, 0, 0, 103, - 735, + 767, 1, 0, 0, 0, 105, - 740, + 771, 1, 0, 0, 0, 107, - 745, + 775, 1, 0, 0, 0, 109, - 752, + 779, 1, 0, 0, 0, 111, - 759, + 784, 1, 0, 0, 0, 113, - 769, + 789, 1, 0, 0, 0, 115, - 782, + 796, 1, 0, 0, 0, 117, - 787, + 803, 1, 0, 0, 0, 119, - 792, + 813, 1, 0, 0, 0, 121, - 806, + 826, 1, 0, 0, 0, 123, - 819, + 831, 1, 0, 0, 0, 125, - 824, + 836, 1, 0, 0, 0, 127, - 832, + 850, 1, 0, 0, 0, 129, - 852, + 863, 1, 0, 0, 0, 131, - 875, + 868, 1, 0, 0, 0, 133, - 885, + 876, 1, 0, 0, 0, 135, - 893, + 896, 1, 0, 0, 0, 137, - 905, + 919, 1, 0, 0, 0, 139, - 912, + 929, 1, 0, 0, 0, 141, - 920, + 937, 1, 0, 0, 0, 143, - 925, + 949, 1, 0, 0, 0, 145, - 929, + 956, 1, 0, 0, 0, 147, - 932, + 964, 1, 0, 0, 0, 149, - 937, + 969, 1, 0, 0, 0, 151, - 941, + 973, 1, 0, 0, 0, 153, - 946, + 976, 1, 0, 0, 0, 155, - 949, + 981, 1, 0, 0, 0, 157, - 954, + 985, 1, 0, 0, 0, 159, - 960, + 990, 1, 0, 0, 0, 161, - 965, + 993, 1, 0, 0, 0, 163, - 969, + 998, 1, 0, 0, 0, 165, - 973, + 1004, 1, 0, 0, 0, 167, - 979, + 1009, 1, 0, 0, 0, 169, - 985, + 1013, 1, 0, 0, 0, 171, - 991, + 1017, 1, 0, 0, 0, 173, - 996, + 1023, 1, 0, 0, 0, 175, - 1000, + 1029, 1, 0, 0, 0, 177, - 1003, + 1035, 1, 0, 0, 0, 179, - 1006, + 1040, 1, 0, 0, 0, 181, - 1008, + 1044, 1, 0, 0, 0, 183, - 1010, + 1047, 1, 0, 0, 0, 185, - 1012, + 1050, 1, 0, 0, 0, 187, - 1014, + 1052, 1, 0, 0, 0, 189, - 1016, + 1054, 1, 0, 0, 0, 191, - 1018, + 1056, 1, 0, 0, 0, 193, - 1021, + 1058, 1, 0, 0, 0, 195, - 1024, + 1060, 1, 0, 0, 0, 197, - 1027, + 1062, 1, 0, 0, 0, 199, - 1029, + 1065, 1, 0, 0, 0, 201, - 1031, + 1068, 1, 0, 0, 0, 203, - 1033, + 1071, 1, 0, 0, 0, 205, - 1035, + 1073, 1, 0, 0, 0, 207, - 1037, + 1075, 1, 0, 0, 0, 209, - 1039, + 1077, 1, 0, 0, 0, 211, - 1041, + 1079, 1, 0, 0, 0, 213, - 1043, + 1081, 1, 0, 0, 0, 215, - 1045, + 1083, 1, 0, 0, 0, 217, - 1047, + 1085, 1, 0, 0, 0, 219, - 1049, + 1087, 1, 0, 0, 0, 221, - 1051, + 1089, 1, 0, 0, 0, 223, - 1055, + 1091, 1, 0, 0, 0, 225, - 1058, + 1093, 1, 0, 0, 0, 227, - 1069, + 1095, 1, 0, 0, 0, 229, - 1071, + 1099, 1, 0, 0, 0, 231, - 1074, + 1102, 1, 0, 0, 0, 233, - 1078, + 1113, 1, 0, 0, 0, 235, - 1091, + 1115, 1, 0, 0, 0, 237, + 1118, + 1, + 0, + 0, + 0, 239, + 1122, + 1, + 0, + 0, + 0, + 241, + 1135, + 1, + 0, + 0, + 0, + 243, + 245, 7, 0, 0, 0, - 238, - 237, + 244, + 243, 1, 0, 0, 0, - 239, - 240, + 245, + 246, 1, 0, 0, 0, - 240, - 238, + 246, + 244, 1, 0, 0, 0, - 240, - 241, + 246, + 247, 1, 0, 0, 0, - 241, - 242, + 247, + 248, 1, 0, 0, 0, - 242, - 243, + 248, + 249, 6, 0, 0, 0, - 243, + 249, 2, 1, 0, 0, 0, - 244, - 245, + 250, + 251, 5, 35, 0, 0, - 245, - 246, + 251, + 252, 5, 35, 0, 0, - 246, - 247, + 252, + 253, 5, 35, 0, 0, - 247, + 253, 4, 1, 0, 0, 0, - 248, - 249, + 254, + 255, 7, 1, 0, 0, - 249, - 250, + 255, + 256, 7, 2, 0, 0, - 250, - 251, + 256, + 257, 7, 3, 0, 0, - 251, - 252, + 257, + 258, 7, 1, 0, 0, - 252, - 253, + 258, + 259, 7, 4, 0, 0, - 253, - 254, + 259, + 260, + 7, + 5, + 0, + 0, + 260, + 261, + 7, + 6, + 0, + 0, + 261, + 262, + 7, + 7, + 0, + 0, + 262, + 263, + 7, + 4, + 0, + 0, + 263, + 264, + 5, + 95, + 0, + 0, + 264, + 265, + 7, + 1, + 0, + 0, + 265, + 266, + 7, + 8, + 0, + 0, + 266, + 267, + 7, + 6, + 0, + 0, + 267, + 268, + 7, + 9, + 0, + 0, + 268, + 269, + 7, + 6, + 0, + 0, + 269, + 270, + 7, + 5, + 0, + 0, + 270, + 271, + 5, + 95, + 0, + 0, + 271, + 272, + 7, + 4, + 0, + 0, + 272, + 273, + 7, + 10, + 0, + 0, + 273, + 274, + 7, + 1, + 0, + 0, + 274, + 275, + 7, + 4, + 0, + 0, + 275, + 6, + 1, + 0, + 0, + 0, + 276, + 277, + 7, + 1, + 0, + 0, + 277, + 278, + 7, + 2, + 0, + 0, + 278, + 279, + 7, + 3, + 0, + 0, + 279, + 280, + 7, + 1, + 0, + 0, + 280, + 281, + 7, + 4, + 0, + 0, + 281, + 282, 7, 5, 0, 0, - 254, - 255, + 282, + 283, 7, 6, 0, 0, - 255, - 256, + 283, + 284, 7, 7, 0, 0, - 256, - 257, + 284, + 285, 7, 4, 0, 0, - 257, - 258, + 285, + 286, 5, 95, 0, 0, - 258, - 259, + 286, + 287, 7, - 1, + 6, 0, 0, - 259, - 260, + 287, + 288, 7, - 8, + 11, 0, 0, - 260, - 261, + 288, + 289, 7, - 6, + 11, 0, 0, - 261, - 262, + 289, + 290, 7, - 9, + 5, 0, 0, - 262, - 263, + 290, + 291, + 7, + 10, + 0, + 0, + 291, + 292, + 7, + 11, + 0, + 0, + 292, + 293, 7, 6, 0, 0, - 263, - 264, + 293, + 294, 7, - 5, + 4, 0, 0, - 264, - 265, + 294, + 295, + 7, + 10, + 0, + 0, + 295, + 296, 5, 95, 0, 0, - 265, - 266, + 296, + 297, 7, 4, 0, 0, - 266, - 267, + 297, + 298, 7, 10, 0, 0, - 267, - 268, + 298, + 299, 7, 1, 0, 0, - 268, - 269, + 299, + 300, 7, 4, 0, 0, - 269, - 6, + 300, + 8, 1, 0, 0, 0, - 270, - 271, + 301, + 302, 7, 1, 0, 0, - 271, - 272, + 302, + 303, 7, 2, 0, 0, - 272, - 273, + 303, + 304, 7, 3, 0, 0, - 273, - 274, + 304, + 305, 7, 1, 0, 0, - 274, - 275, + 305, + 306, 7, 4, 0, 0, - 275, - 276, + 306, + 307, 7, 5, 0, 0, - 276, - 277, + 307, + 308, 7, 6, 0, 0, - 277, - 278, + 308, + 309, 7, 7, 0, 0, - 278, - 279, + 309, + 310, 7, 4, 0, 0, - 279, - 280, + 310, + 311, 5, 95, 0, 0, - 280, - 281, + 311, + 312, 7, 7, 0, 0, - 281, - 282, + 312, + 313, 7, - 11, + 12, 0, 0, - 282, - 283, + 313, + 314, 7, 8, 0, 0, - 283, - 284, + 314, + 315, 7, 9, 0, 0, - 284, - 285, + 315, + 316, 7, 2, 0, 0, - 285, - 286, + 316, + 317, 7, - 12, + 13, 0, 0, - 286, - 287, + 317, + 318, 7, 10, 0, 0, - 287, - 8, + 318, + 10, 1, 0, 0, 0, - 288, - 290, + 319, + 321, 7, - 13, + 14, 0, 0, - 289, - 291, + 320, + 322, 3, - 85, - 42, + 91, + 45, 0, - 290, - 289, + 321, + 320, 1, 0, 0, 0, - 291, - 292, + 322, + 323, 1, 0, 0, 0, - 292, - 290, + 323, + 321, 1, 0, 0, 0, - 292, - 293, + 323, + 324, 1, 0, 0, 0, - 293, - 300, + 324, + 331, 1, 0, 0, 0, - 294, - 296, + 325, + 327, 5, 46, 0, 0, - 295, - 297, + 326, + 328, 3, - 85, - 42, + 91, + 45, 0, - 296, - 295, + 327, + 326, 1, 0, 0, 0, - 297, - 298, + 328, + 329, 1, 0, 0, 0, - 298, - 296, + 329, + 327, 1, 0, 0, 0, - 298, - 299, + 329, + 330, 1, 0, 0, 0, - 299, - 301, + 330, + 332, 1, 0, 0, 0, - 300, - 294, + 331, + 325, 1, 0, 0, 0, - 300, - 301, + 331, + 332, 1, 0, 0, 0, - 301, - 10, + 332, + 12, 1, 0, 0, 0, - 302, - 303, + 333, + 334, 5, 35, 0, - 0, - 303, - 304, + 0, + 334, + 335, 5, 32, 0, 0, - 304, - 308, + 335, + 339, 1, 0, 0, 0, - 305, - 307, + 336, + 338, 8, - 14, + 15, 0, 0, - 306, - 305, + 337, + 336, 1, 0, 0, 0, - 307, - 310, + 338, + 341, 1, 0, 0, 0, - 308, - 306, + 339, + 337, 1, 0, 0, 0, - 308, - 309, + 339, + 340, 1, 0, 0, 0, - 309, - 312, + 340, + 343, 1, 0, 0, 0, - 310, - 308, + 341, + 339, 1, 0, 0, 0, - 311, - 313, + 342, + 344, 5, 13, 0, 0, - 312, - 311, + 343, + 342, 1, 0, 0, 0, - 312, - 313, + 343, + 344, 1, 0, 0, 0, - 313, - 314, + 344, + 345, 1, 0, 0, 0, - 314, - 315, + 345, + 346, 5, 10, 0, 0, - 315, + 346, + 14, + 1, + 0, + 0, + 0, + 347, + 348, + 7, + 13, + 0, + 0, + 348, + 349, + 7, + 10, + 0, + 0, + 349, + 350, + 7, + 16, + 0, + 0, + 350, + 351, + 7, + 7, + 0, + 0, + 351, + 352, + 7, 12, + 0, + 0, + 352, + 353, + 7, + 10, + 0, + 0, + 353, + 16, 1, 0, 0, 0, - 316, - 317, + 354, + 355, 5, 60, 0, 0, - 317, - 318, + 355, + 356, 5, 33, 0, 0, - 318, - 319, + 356, + 357, 7, 10, 0, 0, - 319, - 320, + 357, + 358, 7, 5, 0, 0, - 320, - 321, + 358, + 359, 7, 5, 0, 0, - 321, - 322, + 359, + 360, 7, - 15, + 17, 0, 0, - 322, - 323, + 360, + 361, 7, 5, 0, 0, - 323, - 324, + 361, + 362, 5, 62, 0, 0, - 324, - 14, + 362, + 18, 1, 0, 0, 0, - 325, - 326, + 363, + 364, 5, 60, 0, 0, - 326, - 327, + 364, + 365, 5, 33, 0, 0, - 327, - 328, + 365, + 366, 7, 2, 0, 0, - 328, - 329, + 366, + 367, 7, - 11, + 12, 0, 0, - 329, - 330, + 367, + 368, 7, - 12, + 13, 0, 0, - 330, - 331, + 368, + 369, 7, 10, 0, 0, - 331, - 332, + 369, + 370, 7, 16, 0, 0, - 332, - 333, + 370, + 371, 7, 7, 0, 0, - 333, - 334, + 371, + 372, 7, - 11, + 12, 0, 0, - 334, - 335, + 372, + 373, 7, 10, 0, 0, - 335, - 336, + 373, + 374, 7, - 12, + 13, 0, 0, - 336, - 337, + 374, + 375, 5, 62, 0, 0, - 337, - 16, + 375, + 20, 1, 0, 0, 0, - 338, - 339, + 376, + 377, 7, - 15, + 17, 0, 0, - 339, - 340, + 377, + 378, 7, - 13, + 14, 0, 0, - 340, - 341, + 378, + 379, 7, 10, 0, 0, - 341, - 342, + 379, + 380, 7, 5, 0, 0, - 342, - 343, + 380, + 381, 7, 16, 0, 0, - 343, - 344, + 381, + 382, 7, 9, 0, 0, - 344, - 345, + 382, + 383, 7, - 15, + 17, 0, 0, - 345, - 346, + 383, + 384, 7, - 17, + 18, 0, 0, - 346, - 18, + 384, + 22, 1, 0, 0, 0, - 347, - 348, + 385, + 386, 7, 5, 0, 0, - 348, - 349, + 386, + 387, 7, - 15, - 0, + 17, 0, - 349, - 350, + 0, + 387, + 388, 7, 2, 0, 0, - 350, - 351, + 388, + 389, 7, - 11, + 12, 0, 0, - 351, - 352, + 389, + 390, 7, - 12, + 13, 0, 0, - 352, - 353, + 390, + 391, 7, 7, 0, 0, - 353, - 354, + 391, + 392, 7, - 11, + 12, 0, 0, - 354, - 355, + 392, + 393, 7, - 18, + 11, 0, 0, - 355, - 20, + 393, + 24, 1, 0, 0, 0, - 356, - 357, + 394, + 395, 7, 10, 0, 0, - 357, - 358, + 395, + 396, 7, 5, 0, 0, - 358, - 359, + 396, + 397, 7, 5, 0, 0, - 359, - 360, + 397, + 398, 7, - 15, + 17, 0, 0, - 360, - 361, + 398, + 399, 7, 5, 0, 0, - 361, - 22, + 399, + 26, 1, 0, 0, 0, - 362, - 363, + 400, + 401, 7, 1, 0, 0, - 363, - 364, + 401, + 402, 7, 6, 0, 0, - 364, - 365, + 402, + 403, 7, 4, 0, 0, - 365, - 366, + 403, + 404, 7, 2, 0, 0, - 366, - 367, + 404, + 405, 7, 5, 0, 0, - 367, - 368, + 405, + 406, 7, 6, 0, 0, - 368, - 369, + 406, + 407, 7, 4, 0, 0, - 369, - 370, + 407, + 408, 7, 10, 0, 0, - 370, - 24, + 408, + 28, 1, 0, 0, 0, - 371, - 372, + 409, + 410, 7, 1, 0, 0, - 372, - 373, + 410, + 411, 7, 7, 0, 0, - 373, - 374, + 411, + 412, 7, 9, 0, 0, - 374, - 375, + 412, + 413, 7, 10, 0, 0, - 375, - 376, + 413, + 414, 7, - 11, + 12, 0, 0, - 376, - 377, + 414, + 415, 7, 4, 0, 0, - 377, - 26, + 415, + 30, 1, 0, 0, 0, - 378, - 379, + 416, + 417, 7, 4, 0, 0, - 379, - 380, + 417, + 418, 7, 7, 0, 0, - 380, - 381, + 418, + 419, 7, 10, 0, 0, - 381, - 382, + 419, + 420, 5, 95, 0, 0, - 382, - 383, + 420, + 421, 7, 4, 0, 0, - 383, - 384, + 421, + 422, 7, - 15, + 17, 0, 0, - 384, - 385, + 422, + 423, 5, 95, 0, 0, - 385, - 386, + 423, + 424, 7, 10, 0, 0, - 386, - 387, + 424, + 425, 7, - 13, + 14, 0, 0, - 387, - 388, + 425, + 426, 7, 10, 0, 0, - 388, - 389, + 426, + 427, 7, - 11, + 12, 0, 0, - 389, - 28, + 427, + 32, 1, 0, 0, 0, - 390, - 391, + 428, + 429, 7, - 11, + 12, 0, 0, - 391, - 392, + 429, + 430, 7, 6, 0, 0, - 392, - 393, + 430, + 431, 7, - 11, + 12, 0, 0, - 393, - 30, + 431, + 34, 1, 0, 0, 0, - 394, - 396, + 432, + 434, 7, 19, 0, 0, - 395, - 394, + 433, + 432, 1, 0, 0, 0, - 395, - 396, + 433, + 434, 1, 0, 0, 0, - 396, - 397, + 434, + 435, 1, 0, 0, 0, - 397, - 398, + 435, + 436, 3, - 227, - 113, + 233, + 116, 0, - 398, - 32, + 436, + 36, 1, 0, 0, 0, - 399, - 401, + 437, + 439, 7, 19, 0, 0, - 400, - 399, + 438, + 437, 1, 0, 0, 0, - 400, - 401, + 438, + 439, 1, 0, 0, 0, - 401, - 403, + 439, + 441, 1, 0, 0, 0, - 402, - 404, + 440, + 442, 7, 20, 0, 0, - 403, - 402, + 441, + 440, 1, 0, 0, - 0, - 404, - 405, + 0, + 442, + 443, 1, 0, 0, 0, - 405, - 403, + 443, + 441, 1, 0, 0, 0, - 405, - 406, + 443, + 444, 1, 0, 0, 0, - 406, - 413, + 444, + 451, 1, 0, 0, 0, - 407, - 409, + 445, + 447, 5, 46, 0, 0, - 408, - 410, + 446, + 448, 7, 20, 0, 0, - 409, - 408, + 447, + 446, 1, 0, 0, 0, - 410, - 411, + 448, + 449, 1, 0, 0, 0, - 411, - 409, + 449, + 447, 1, 0, 0, 0, - 411, - 412, + 449, + 450, 1, 0, 0, 0, - 412, - 414, + 450, + 452, 1, 0, 0, 0, - 413, - 407, + 451, + 445, 1, 0, 0, 0, - 413, - 414, + 451, + 452, 1, 0, 0, 0, - 414, - 34, + 452, + 38, 1, 0, 0, 0, - 415, - 417, + 453, + 455, 7, 19, 0, 0, - 416, - 415, + 454, + 453, 1, 0, 0, 0, - 416, - 417, + 454, + 455, 1, 0, 0, 0, - 417, - 419, + 455, + 457, 1, 0, 0, 0, - 418, - 420, + 456, + 458, 7, 20, 0, 0, - 419, - 418, + 457, + 456, 1, 0, 0, 0, - 420, - 421, + 458, + 459, 1, 0, 0, 0, - 421, - 419, + 459, + 457, 1, 0, 0, 0, - 421, - 422, + 459, + 460, 1, 0, 0, 0, - 422, - 430, + 460, + 468, 1, 0, 0, 0, - 423, - 427, + 461, + 465, 5, 46, 0, 0, - 424, - 426, + 462, + 464, 7, 20, 0, 0, - 425, - 424, + 463, + 462, 1, 0, 0, 0, - 426, - 429, + 464, + 467, 1, 0, 0, 0, - 427, - 425, + 465, + 463, 1, 0, 0, 0, - 427, - 428, + 465, + 466, 1, 0, 0, 0, - 428, - 431, + 466, + 469, 1, 0, 0, 0, - 429, - 427, + 467, + 465, 1, 0, 0, 0, - 430, - 423, + 468, + 461, 1, 0, 0, 0, - 430, - 431, + 468, + 469, 1, 0, 0, 0, - 431, - 441, + 469, + 479, 1, 0, 0, 0, - 432, - 434, + 470, + 472, 7, 10, 0, 0, - 433, - 435, + 471, + 473, 7, 19, 0, 0, - 434, - 433, + 472, + 471, 1, 0, 0, 0, - 434, - 435, + 472, + 473, 1, 0, 0, 0, - 435, - 437, + 473, + 475, 1, 0, 0, 0, - 436, - 438, + 474, + 476, 7, 20, 0, 0, - 437, - 436, + 475, + 474, 1, 0, 0, 0, - 438, - 439, + 476, + 477, 1, 0, 0, 0, - 439, - 437, + 477, + 475, 1, 0, 0, 0, - 439, - 440, + 477, + 478, 1, 0, 0, 0, - 440, - 442, + 478, + 480, 1, 0, 0, 0, - 441, - 432, + 479, + 470, 1, 0, 0, 0, - 441, - 442, + 479, + 480, 1, 0, 0, 0, - 442, - 454, + 480, + 492, 1, 0, 0, 0, - 443, - 445, + 481, + 483, 7, 19, 0, 0, - 444, - 443, + 482, + 481, 1, 0, 0, 0, - 444, - 445, + 482, + 483, 1, 0, 0, 0, - 445, - 446, + 483, + 484, 1, 0, 0, 0, - 446, - 447, + 484, + 485, 7, 7, 0, 0, - 447, - 448, + 485, + 486, 7, - 11, + 12, 0, 0, - 448, - 454, + 486, + 492, 7, 16, 0, 0, - 449, - 450, + 487, + 488, 7, 1, 0, 0, - 450, - 451, + 488, + 489, 7, - 11, + 12, 0, 0, - 451, - 452, + 489, + 490, 7, 6, 0, 0, - 452, - 454, + 490, + 492, 7, - 11, + 12, 0, 0, - 453, - 416, + 491, + 454, 1, 0, 0, 0, - 453, - 444, + 491, + 482, 1, 0, 0, 0, - 453, - 449, + 491, + 487, 1, 0, 0, 0, - 454, - 36, + 492, + 40, 1, 0, 0, 0, - 455, - 456, + 493, + 494, 7, 4, 0, 0, - 456, - 457, + 494, + 495, 7, 5, 0, 0, - 457, - 458, + 495, + 496, 7, 2, 0, 0, - 458, - 465, + 496, + 503, 7, 10, 0, 0, - 459, - 460, + 497, + 498, 7, 16, 0, 0, - 460, - 461, + 498, + 499, 7, 6, 0, 0, - 461, - 462, + 499, + 500, 7, 9, 0, 0, - 462, - 463, + 500, + 501, 7, 1, 0, 0, - 463, - 465, + 501, + 503, 7, 10, 0, 0, - 464, - 455, + 502, + 493, 1, 0, 0, 0, - 464, - 459, + 502, + 497, 1, 0, 0, 0, - 465, - 38, + 503, + 42, 1, 0, 0, 0, - 466, - 467, + 504, + 505, 7, 20, 0, 0, - 467, - 468, + 505, + 506, 7, 20, 0, 0, - 468, - 469, + 506, + 507, 7, 20, 0, 0, - 469, - 470, + 507, + 508, 7, 20, 0, 0, - 470, - 40, + 508, + 44, 1, 0, 0, 0, - 471, - 472, + 509, + 510, 7, 20, 0, 0, - 472, - 473, + 510, + 511, 7, 20, 0, 0, - 473, - 42, + 511, + 46, 1, 0, 0, 0, - 474, - 475, + 512, + 513, 5, 39, 0, 0, - 475, - 476, + 513, + 514, 3, - 39, - 19, + 43, + 21, 0, - 476, - 477, + 514, + 515, 5, 45, 0, 0, - 477, - 478, + 515, + 516, 3, - 41, - 20, + 45, + 22, 0, - 478, - 479, + 516, + 517, 5, 45, 0, 0, - 479, - 480, + 517, + 518, 3, - 41, - 20, + 45, + 22, 0, - 480, - 481, + 518, + 519, 7, 4, 0, 0, - 481, - 482, + 519, + 520, 3, - 41, - 20, + 45, + 22, 0, - 482, - 483, + 520, + 521, 5, 58, 0, 0, - 483, - 484, + 521, + 522, 3, - 41, - 20, + 45, + 22, 0, - 484, - 485, + 522, + 523, 5, 58, 0, 0, - 485, - 492, + 523, + 530, 3, - 41, - 20, + 45, + 22, 0, - 486, - 488, + 524, + 526, 5, 46, 0, 0, - 487, - 489, + 525, + 527, 7, 20, 0, 0, - 488, - 487, + 526, + 525, 1, 0, 0, 0, - 489, - 490, + 527, + 528, 1, 0, 0, 0, - 490, - 488, + 528, + 526, 1, 0, 0, 0, - 490, - 491, + 528, + 529, 1, 0, 0, 0, - 491, - 493, + 529, + 531, 1, 0, 0, 0, - 492, - 486, + 530, + 524, 1, 0, 0, 0, - 492, - 493, + 530, + 531, 1, 0, 0, 0, - 493, - 494, + 531, + 532, 1, 0, 0, 0, - 494, - 495, + 532, + 533, 7, 19, 0, 0, - 495, - 496, + 533, + 534, 3, - 41, - 20, + 45, + 22, 0, - 496, - 497, + 534, + 535, 5, 58, 0, 0, - 497, - 498, + 535, + 536, 3, - 41, - 20, + 45, + 22, 0, - 498, - 499, + 536, + 537, 5, 39, 0, 0, - 499, - 44, + 537, + 48, 1, 0, 0, 0, - 500, - 501, + 538, + 539, 5, 39, 0, 0, - 501, - 502, + 539, + 540, 3, - 39, - 19, + 43, + 21, 0, - 502, - 503, + 540, + 541, 5, 45, 0, 0, - 503, - 504, + 541, + 542, 3, - 41, - 20, + 45, + 22, 0, - 504, - 505, + 542, + 543, 5, 45, 0, 0, - 505, - 506, + 543, + 544, 3, - 41, - 20, + 45, + 22, 0, - 506, - 507, + 544, + 545, 7, 4, 0, 0, - 507, - 508, + 545, + 546, 3, - 41, - 20, + 45, + 22, 0, - 508, - 509, + 546, + 547, 5, 58, 0, 0, - 509, - 510, + 547, + 548, 3, - 41, - 20, + 45, + 22, 0, - 510, - 511, + 548, + 549, 5, 58, 0, 0, - 511, - 518, + 549, + 556, 3, - 41, - 20, + 45, + 22, 0, - 512, - 514, + 550, + 552, 5, 46, 0, 0, - 513, - 515, + 551, + 553, 7, 20, 0, 0, - 514, - 513, + 552, + 551, 1, 0, 0, 0, - 515, - 516, + 553, + 554, 1, 0, 0, 0, - 516, - 514, + 554, + 552, 1, 0, 0, 0, - 516, - 517, + 554, + 555, 1, 0, 0, 0, - 517, - 519, + 555, + 557, 1, 0, 0, 0, - 518, - 512, + 556, + 550, 1, 0, 0, 0, - 518, - 519, + 556, + 557, 1, 0, 0, 0, - 519, - 520, + 557, + 558, 1, 0, 0, 0, - 520, - 521, + 558, + 559, 5, 39, 0, 0, - 521, - 46, + 559, + 50, 1, 0, 0, 0, - 522, - 523, + 560, + 561, 5, 39, 0, 0, - 523, - 524, + 561, + 562, 3, - 41, - 20, + 45, + 22, 0, - 524, - 525, + 562, + 563, 5, 58, 0, 0, - 525, - 526, + 563, + 564, 3, - 41, - 20, + 45, + 22, 0, - 526, - 527, + 564, + 565, 5, 58, 0, 0, - 527, - 534, + 565, + 572, 3, - 41, - 20, + 45, + 22, 0, - 528, - 530, + 566, + 568, 5, 46, 0, 0, - 529, - 531, + 567, + 569, 7, 20, 0, 0, - 530, - 529, + 568, + 567, 1, 0, 0, 0, - 531, - 532, + 569, + 570, 1, 0, 0, 0, - 532, - 530, + 570, + 568, 1, 0, 0, 0, - 532, - 533, + 570, + 571, 1, 0, 0, 0, - 533, - 535, + 571, + 573, 1, 0, 0, 0, - 534, - 528, + 572, + 566, 1, 0, 0, 0, - 534, - 535, + 572, + 573, 1, 0, 0, 0, - 535, - 536, + 573, + 574, 1, 0, 0, 0, - 536, - 537, + 574, + 575, 5, 39, 0, 0, - 537, - 48, + 575, + 52, 1, 0, 0, 0, - 538, - 539, + 576, + 577, 5, 39, 0, 0, - 539, - 540, + 577, + 578, 3, - 39, - 19, + 43, + 21, 0, - 540, - 541, + 578, + 579, 5, 45, 0, 0, - 541, - 542, + 579, + 580, 3, - 41, - 20, + 45, + 22, 0, - 542, - 543, + 580, + 581, 5, 45, 0, 0, - 543, - 544, + 581, + 582, 3, - 41, - 20, + 45, + 22, 0, - 544, - 545, + 582, + 583, 5, 39, 0, 0, - 545, - 50, + 583, + 54, 1, 0, 0, 0, - 546, - 547, + 584, + 585, 7, 21, 0, 0, - 547, - 52, + 585, + 56, 1, 0, 0, 0, - 548, - 549, + 586, + 587, 7, 4, 0, 0, - 549, - 54, + 587, + 58, 1, 0, 0, 0, - 550, - 551, + 588, + 589, 7, 22, 0, 0, - 551, - 56, + 589, + 60, 1, 0, 0, 0, - 552, - 553, + 590, + 591, 7, 23, 0, 0, - 553, - 58, + 591, + 62, 1, 0, 0, - 0, - 554, - 555, + 0, + 592, + 593, 7, - 12, + 13, 0, 0, - 555, - 60, + 593, + 64, 1, 0, 0, 0, - 556, - 557, + 594, + 595, 7, 24, 0, 0, - 557, - 62, + 595, + 66, 1, 0, 0, 0, - 558, - 559, + 596, + 597, 7, 1, 0, 0, - 559, - 64, + 597, + 68, 1, 0, 0, 0, - 560, - 561, + 598, + 599, 7, 16, 0, 0, - 561, - 66, + 599, + 70, 1, 0, 0, 0, - 562, - 563, + 600, + 601, 3, - 199, - 99, + 205, + 102, 0, - 563, - 68, + 601, + 72, 1, 0, 0, 0, - 564, - 565, + 602, + 603, 3, - 197, - 98, + 203, + 101, 0, - 565, - 70, + 603, + 74, 1, 0, 0, 0, - 566, - 567, + 604, + 605, 5, 39, 0, 0, - 567, - 568, + 605, + 606, 3, - 51, - 25, + 55, + 27, 0, - 568, - 569, + 606, + 607, 3, - 31, - 15, + 35, + 17, 0, - 569, - 573, + 607, + 611, 3, - 55, - 27, + 59, + 29, 0, - 570, - 571, + 608, + 609, 3, - 31, - 15, + 35, + 17, 0, - 571, - 572, + 609, + 610, 3, - 57, - 28, + 61, + 30, 0, - 572, - 574, + 610, + 612, 1, 0, 0, 0, - 573, - 570, + 611, + 608, 1, 0, 0, 0, - 573, - 574, + 611, + 612, 1, 0, 0, 0, - 574, - 575, + 612, + 613, 1, 0, 0, 0, - 575, - 576, + 613, + 614, 5, 39, 0, 0, - 576, - 584, + 614, + 622, 1, 0, 0, 0, - 577, - 578, + 615, + 616, 5, 39, 0, 0, - 578, - 579, + 616, + 617, 3, - 51, - 25, + 55, + 27, 0, - 579, - 580, + 617, + 618, 3, - 31, - 15, + 35, + 17, 0, - 580, - 581, + 618, + 619, 3, - 57, - 28, + 61, + 30, 0, - 581, - 582, + 619, + 620, 5, 39, 0, 0, - 582, - 584, + 620, + 622, 1, 0, 0, 0, - 583, - 566, + 621, + 604, 1, 0, 0, 0, - 583, - 577, + 621, + 615, 1, 0, 0, 0, - 584, - 72, + 622, + 76, 1, 0, 0, 0, - 585, - 586, + 623, + 624, 5, 39, 0, 0, - 586, - 587, + 624, + 625, 3, - 51, - 25, + 55, + 27, 0, - 587, - 588, + 625, + 626, 3, - 31, - 15, + 35, + 17, 0, - 588, - 592, + 626, + 630, 3, - 59, - 29, + 63, + 31, 0, - 589, - 590, + 627, + 628, 3, - 53, - 26, + 57, + 28, 0, - 590, - 591, + 628, + 629, 3, - 75, - 37, + 79, + 39, 0, - 591, - 593, + 629, + 631, 1, 0, 0, 0, - 592, - 589, + 630, + 627, 1, 0, 0, 0, - 592, - 593, + 630, + 631, 1, 0, 0, 0, - 593, - 594, + 631, + 632, 1, 0, 0, 0, - 594, - 595, + 632, + 633, 5, 39, 0, 0, - 595, - 603, + 633, + 641, 1, 0, 0, 0, - 596, - 597, + 634, + 635, 5, 39, 0, 0, - 597, - 598, + 635, + 636, 3, - 51, - 25, + 55, + 27, 0, - 598, - 599, + 636, + 637, 3, - 53, - 26, + 57, + 28, 0, - 599, - 600, + 637, + 638, 3, - 75, - 37, + 79, + 39, 0, - 600, - 601, + 638, + 639, 5, 39, 0, 0, - 601, - 603, + 639, + 641, 1, 0, 0, 0, - 602, - 585, + 640, + 623, 1, 0, 0, 0, - 602, - 596, + 640, + 634, 1, 0, 0, 0, - 603, - 74, + 641, + 78, 1, 0, 0, 0, - 604, - 605, + 642, + 643, 3, - 31, - 15, + 35, + 17, 0, - 605, - 609, + 643, + 647, 3, - 61, - 30, + 65, + 32, 0, - 606, - 607, + 644, + 645, 3, - 31, - 15, + 35, + 17, 0, - 607, - 608, + 645, + 646, 3, - 57, - 28, + 61, + 30, 0, - 608, - 610, + 646, + 648, 1, 0, 0, 0, - 609, - 606, + 647, + 644, 1, 0, 0, 0, - 609, - 610, + 647, + 648, 1, 0, 0, 0, - 610, - 614, + 648, + 652, 1, 0, 0, 0, - 611, - 612, + 649, + 650, 3, - 31, - 15, + 35, + 17, 0, - 612, - 613, + 650, + 651, 3, - 63, - 31, + 67, + 33, 0, - 613, - 615, + 651, + 653, 1, 0, 0, 0, - 614, - 611, + 652, + 649, 1, 0, 0, 0, - 614, - 615, + 652, + 653, 1, 0, 0, 0, - 615, - 619, + 653, + 657, 1, 0, 0, 0, - 616, - 617, + 654, + 655, 3, - 31, - 15, + 35, + 17, 0, - 617, - 618, + 655, + 656, 3, - 65, - 32, + 69, + 34, 0, - 618, - 620, + 656, + 658, 1, 0, 0, 0, - 619, - 616, + 657, + 654, 1, 0, 0, 0, - 619, - 620, + 657, + 658, 1, 0, 0, 0, - 620, - 644, + 658, + 682, 1, 0, 0, 0, - 621, - 622, + 659, + 660, 3, - 31, - 15, + 35, + 17, 0, - 622, - 626, + 660, + 664, 3, - 57, - 28, + 61, + 30, 0, - 623, - 624, + 661, + 662, 3, - 31, - 15, + 35, + 17, 0, - 624, - 625, + 662, + 663, 3, - 63, - 31, + 67, + 33, 0, - 625, - 627, + 663, + 665, 1, 0, 0, 0, - 626, - 623, + 664, + 661, 1, 0, 0, 0, - 626, - 627, + 664, + 665, 1, 0, 0, 0, - 627, - 631, + 665, + 669, 1, 0, 0, 0, - 628, - 629, + 666, + 667, 3, - 31, - 15, + 35, + 17, 0, - 629, - 630, + 667, + 668, 3, - 65, - 32, + 69, + 34, 0, - 630, - 632, + 668, + 670, 1, 0, 0, 0, - 631, - 628, + 669, + 666, 1, 0, 0, 0, - 631, - 632, + 669, + 670, 1, 0, 0, 0, - 632, - 644, + 670, + 682, 1, 0, 0, 0, - 633, - 634, + 671, + 672, 3, - 31, - 15, + 35, + 17, 0, - 634, - 638, + 672, + 676, 3, - 63, - 31, + 67, + 33, 0, - 635, - 636, + 673, + 674, 3, - 31, - 15, + 35, + 17, 0, - 636, - 637, - 3, - 65, - 32, + 674, + 675, + 3, + 69, + 34, 0, - 637, - 639, + 675, + 677, 1, 0, 0, 0, - 638, - 635, + 676, + 673, 1, 0, 0, 0, - 638, - 639, + 676, + 677, 1, 0, 0, 0, - 639, - 644, + 677, + 682, 1, 0, 0, 0, - 640, - 641, + 678, + 679, 3, - 31, - 15, + 35, + 17, 0, - 641, - 642, + 679, + 680, 3, - 65, - 32, + 69, + 34, 0, - 642, - 644, + 680, + 682, 1, 0, 0, 0, - 643, - 604, + 681, + 642, 1, 0, 0, 0, - 643, - 621, + 681, + 659, 1, 0, 0, 0, - 643, - 633, + 681, + 671, 1, 0, 0, 0, - 643, - 640, + 681, + 678, 1, 0, 0, 0, - 644, - 76, + 682, + 80, 1, 0, 0, 0, - 645, - 646, + 683, + 684, 7, - 11, + 12, 0, 0, - 646, - 647, + 684, + 685, 7, 2, 0, 0, - 647, - 648, + 685, + 686, 7, 9, 0, 0, - 648, - 649, + 686, + 687, 7, 9, 0, 0, - 649, - 78, + 687, + 82, 1, 0, 0, 0, - 650, - 658, + 688, + 696, 5, 39, 0, 0, - 651, - 652, + 689, + 690, 5, 92, 0, 0, - 652, - 657, + 690, + 695, 9, 0, 0, 0, - 653, - 654, + 691, + 692, 5, 39, 0, 0, - 654, - 657, + 692, + 695, 5, 39, 0, 0, - 655, - 657, + 693, + 695, 8, 25, 0, 0, - 656, - 651, + 694, + 689, 1, 0, 0, 0, - 656, - 653, + 694, + 691, 1, 0, 0, 0, - 656, - 655, + 694, + 693, 1, 0, 0, 0, - 657, - 660, + 695, + 698, 1, 0, 0, 0, - 658, - 656, + 696, + 694, 1, 0, 0, 0, - 658, - 659, + 696, + 697, 1, 0, 0, 0, - 659, - 661, + 697, + 699, 1, 0, 0, 0, - 660, - 658, + 698, + 696, 1, 0, 0, 0, - 661, - 662, + 699, + 700, 5, 39, 0, 0, - 662, - 80, + 700, + 84, 1, 0, 0, 0, - 663, - 664, + 701, + 702, + 7, + 8, + 0, + 0, + 702, + 703, + 7, + 17, + 0, + 0, + 703, + 704, + 7, + 9, + 0, + 0, + 704, + 705, + 1, + 0, + 0, + 0, + 705, + 706, + 3, + 233, + 116, + 0, + 706, + 86, + 1, + 0, + 0, + 0, + 707, + 708, 5, 47, 0, 0, - 664, - 665, + 708, + 709, 5, 47, 0, 0, - 665, - 669, + 709, + 713, 1, 0, 0, 0, - 666, - 668, + 710, + 712, 8, - 14, + 15, 0, 0, - 667, - 666, + 711, + 710, 1, 0, 0, 0, - 668, - 671, + 712, + 715, 1, 0, 0, 0, - 669, - 667, + 713, + 711, 1, 0, 0, 0, - 669, - 670, + 713, + 714, 1, 0, 0, 0, - 670, - 672, + 714, + 716, 1, 0, 0, 0, - 671, - 669, + 715, + 713, 1, 0, 0, 0, - 672, - 673, + 716, + 717, 6, - 40, + 43, 0, 0, - 673, - 82, + 717, + 88, 1, 0, 0, 0, - 674, - 675, + 718, + 719, 5, 47, 0, 0, - 675, - 676, + 719, + 720, 5, 42, 0, 0, - 676, - 684, + 720, + 728, 1, 0, 0, 0, - 677, - 685, + 721, + 729, 8, 26, 0, 0, - 678, - 680, + 722, + 724, 5, 42, 0, - 0, - 679, - 678, + 0, + 723, + 722, 1, 0, 0, 0, - 680, - 681, + 724, + 725, 1, 0, 0, 0, - 681, - 679, + 725, + 723, 1, 0, 0, 0, - 681, - 682, + 725, + 726, 1, 0, 0, 0, - 682, - 683, + 726, + 727, 1, 0, 0, 0, - 683, - 685, + 727, + 729, 8, 27, 0, 0, - 684, - 677, + 728, + 721, 1, 0, 0, 0, - 684, - 679, + 728, + 723, 1, 0, 0, 0, - 685, - 689, + 729, + 733, 1, 0, 0, 0, - 686, - 688, + 730, + 732, 5, 42, 0, 0, - 687, - 686, + 731, + 730, 1, 0, 0, 0, - 688, - 691, + 732, + 735, 1, 0, 0, 0, - 689, - 687, + 733, + 731, 1, 0, 0, 0, - 689, - 690, + 733, + 734, 1, 0, 0, 0, - 690, - 692, + 734, + 736, 1, 0, 0, 0, - 691, - 689, + 735, + 733, 1, 0, 0, 0, - 692, - 693, + 736, + 737, 5, 42, 0, 0, - 693, - 694, + 737, + 738, 5, 47, 0, 0, - 694, - 695, + 738, + 739, 1, 0, 0, 0, - 695, - 696, + 739, + 740, 6, - 41, + 44, 0, 0, - 696, - 84, + 740, + 90, 1, 0, 0, 0, - 697, - 698, + 741, + 742, 7, 20, 0, 0, - 698, - 86, + 742, + 92, 1, 0, 0, 0, - 699, - 700, + 743, + 744, 7, 7, 0, 0, - 700, - 701, + 744, + 745, 7, 16, 0, 0, - 701, - 88, + 745, + 94, 1, 0, 0, 0, - 702, - 703, + 746, + 747, 7, 4, 0, 0, - 703, - 704, + 747, + 748, 7, 24, 0, 0, - 704, - 705, + 748, + 749, 7, 10, 0, 0, - 705, - 706, + 749, + 750, 7, - 11, + 12, 0, 0, - 706, - 90, + 750, + 96, 1, 0, 0, 0, - 707, - 708, + 751, + 752, 7, 10, 0, 0, - 708, - 709, + 752, + 753, 7, 9, 0, 0, - 709, - 710, + 753, + 754, 7, 1, 0, 0, - 710, - 711, + 754, + 755, 7, 10, 0, 0, - 711, - 92, + 755, + 98, 1, 0, 0, 0, - 712, - 713, + 756, + 757, 7, 3, 0, 0, - 713, - 714, + 757, + 758, 7, - 15, + 17, 0, 0, - 714, - 715, + 758, + 759, 7, - 15, + 17, 0, 0, - 715, - 716, + 759, + 760, 7, 9, 0, 0, - 716, - 717, + 760, + 761, 7, 10, 0, 0, - 717, - 718, + 761, + 762, 7, 6, 0, 0, - 718, - 719, + 762, + 763, 7, - 11, + 12, 0, 0, - 719, - 94, + 763, + 100, 1, 0, 0, 0, - 720, - 721, + 764, + 765, 7, 7, 0, 0, - 721, - 722, + 765, + 766, 5, 56, 0, 0, - 722, - 96, + 766, + 102, 1, 0, 0, 0, - 723, - 724, + 767, + 768, 7, 7, 0, 0, - 724, - 725, + 768, + 769, 5, 49, 0, 0, - 725, - 726, + 769, + 770, 5, 54, 0, 0, - 726, - 98, + 770, + 104, 1, 0, 0, 0, - 727, - 728, + 771, + 772, 7, 7, 0, 0, - 728, - 729, + 772, + 773, 5, 51, 0, 0, - 729, - 730, + 773, + 774, 5, 50, 0, 0, - 730, - 100, + 774, + 106, 1, 0, 0, 0, - 731, - 732, + 775, + 776, 7, 7, 0, 0, - 732, - 733, + 776, + 777, 5, 54, 0, 0, - 733, - 734, + 777, + 778, 5, 52, 0, 0, - 734, - 102, + 778, + 108, 1, 0, 0, 0, - 735, - 736, + 779, + 780, 7, 16, 0, 0, - 736, - 737, + 780, + 781, 7, 21, 0, 0, - 737, - 738, + 781, + 782, 5, 51, 0, 0, - 738, - 739, + 782, + 783, 5, 50, 0, 0, - 739, - 104, + 783, + 110, 1, 0, 0, 0, - 740, - 741, + 784, + 785, 7, 16, 0, 0, - 741, - 742, + 785, + 786, 7, 21, 0, 0, - 742, - 743, + 786, + 787, 5, 54, 0, 0, - 743, - 744, + 787, + 788, 5, 52, 0, 0, - 744, - 106, + 788, + 112, 1, 0, 0, 0, - 745, - 746, + 789, + 790, 7, 1, 0, 0, - 746, - 747, + 790, + 791, 7, 4, 0, 0, - 747, - 748, + 791, + 792, 7, 5, 0, 0, - 748, - 749, + 792, + 793, 7, 7, 0, 0, - 749, - 750, + 793, + 794, 7, - 11, + 12, 0, 0, - 750, - 751, + 794, + 795, 7, - 18, + 11, 0, 0, - 751, - 108, + 795, + 114, 1, 0, 0, 0, - 752, - 753, + 796, + 797, 7, 3, 0, 0, - 753, - 754, + 797, + 798, 7, 7, 0, 0, - 754, - 755, + 798, + 799, 7, - 11, + 12, 0, 0, - 755, - 756, + 799, + 800, 7, 6, 0, 0, - 756, - 757, + 800, + 801, 7, 5, 0, 0, - 757, - 758, + 801, + 802, 7, 22, 0, 0, - 758, - 110, + 802, + 116, 1, 0, 0, 0, - 759, - 760, + 803, + 804, 7, 4, 0, 0, - 760, - 761, + 804, + 805, 7, 7, 0, 0, - 761, - 762, + 805, + 806, 7, 23, 0, 0, - 762, - 763, + 806, + 807, 7, 10, 0, 0, - 763, - 764, + 807, + 808, 7, 1, 0, 0, - 764, - 765, + 808, + 809, 7, 4, 0, 0, - 765, - 766, + 809, + 810, 7, 6, 0, 0, - 766, - 767, + 810, + 811, 7, 23, 0, 0, - 767, - 768, + 811, + 812, 7, 21, 0, 0, - 768, - 112, + 812, + 118, 1, 0, 0, 0, - 769, - 770, + 813, + 814, 7, 4, 0, 0, - 770, - 771, + 814, + 815, 7, 7, 0, 0, - 771, - 772, + 815, + 816, 7, 23, 0, 0, - 772, - 773, + 816, + 817, 7, 10, 0, 0, - 773, - 774, + 817, + 818, 7, 1, 0, 0, - 774, - 775, + 818, + 819, 7, 4, 0, 0, - 775, - 776, + 819, + 820, 7, 6, 0, 0, - 776, - 777, + 820, + 821, 7, 23, 0, 0, - 777, - 778, + 821, + 822, 7, 21, 0, 0, - 778, - 779, + 822, + 823, 5, 95, 0, 0, - 779, - 780, + 823, + 824, 7, 4, 0, 0, - 780, - 781, + 824, + 825, 7, 28, 0, 0, - 781, - 114, + 825, + 120, 1, 0, 0, 0, - 782, - 783, + 826, + 827, 7, - 12, + 13, 0, 0, - 783, - 784, + 827, + 828, 7, 6, 0, 0, - 784, - 785, + 828, + 829, 7, 4, 0, 0, - 785, - 786, + 829, + 830, 7, 10, 0, 0, - 786, - 116, + 830, + 122, 1, 0, 0, 0, - 787, - 788, + 831, + 832, 7, 4, 0, 0, - 788, - 789, + 832, + 833, 7, 7, 0, 0, - 789, - 790, + 833, + 834, 7, 23, 0, 0, - 790, - 791, + 834, + 835, 7, 10, 0, 0, - 791, - 118, + 835, + 124, 1, 0, 0, 0, - 792, - 793, + 836, + 837, 7, 7, 0, 0, - 793, - 794, + 837, + 838, 7, - 11, + 12, 0, 0, - 794, - 795, + 838, + 839, 7, 4, 0, 0, - 795, - 796, + 839, + 840, 7, 10, 0, 0, - 796, - 797, + 840, + 841, 7, 5, 0, 0, - 797, - 798, + 841, + 842, 7, - 13, - 0, + 14, 0, - 798, - 799, + 0, + 842, + 843, 7, 6, 0, 0, - 799, - 800, + 843, + 844, 7, 9, 0, 0, - 800, - 801, + 844, + 845, 5, 95, 0, 0, - 801, - 802, + 845, + 846, 7, 22, 0, 0, - 802, - 803, + 846, + 847, 7, 10, 0, 0, - 803, - 804, + 847, + 848, 7, 6, 0, 0, - 804, - 805, + 848, + 849, 7, 5, 0, 0, - 805, - 120, + 849, + 126, 1, 0, 0, 0, - 806, - 807, + 850, + 851, 7, 7, 0, 0, - 807, - 808, + 851, + 852, 7, - 11, + 12, 0, 0, - 808, - 809, + 852, + 853, 7, 4, 0, 0, - 809, - 810, + 853, + 854, 7, 10, 0, 0, - 810, - 811, + 854, + 855, 7, 5, 0, 0, - 811, - 812, + 855, + 856, 7, - 13, + 14, 0, 0, - 812, - 813, + 856, + 857, 7, 6, 0, 0, - 813, - 814, + 857, + 858, 7, 9, 0, 0, - 814, - 815, + 858, + 859, 5, 95, 0, 0, - 815, - 816, + 859, + 860, 7, - 12, + 13, 0, 0, - 816, - 817, + 860, + 861, 7, 6, 0, 0, - 817, - 818, + 861, + 862, 7, 22, 0, 0, - 818, - 122, + 862, + 128, 1, 0, 0, 0, - 819, - 820, + 863, + 864, 7, 2, 0, 0, - 820, - 821, + 864, + 865, 7, 2, 0, 0, - 821, - 822, + 865, + 866, 7, 7, 0, 0, - 822, - 823, + 866, + 867, 7, - 12, + 13, 0, 0, - 823, - 124, + 867, + 130, 1, 0, 0, 0, - 824, - 825, + 868, + 869, 7, - 12, + 13, 0, 0, - 825, - 826, + 869, + 870, 7, 10, 0, 0, - 826, - 827, + 870, + 871, 7, 8, 0, 0, - 827, - 828, + 871, + 872, 7, 7, 0, 0, - 828, - 829, + 872, + 873, 7, 23, 0, 0, - 829, - 830, + 873, + 874, 7, 6, 0, 0, - 830, - 831, + 874, + 875, 7, 9, 0, 0, - 831, - 126, + 875, + 132, 1, 0, 0, 0, - 832, - 833, + 876, + 877, 7, 21, 0, 0, - 833, - 834, + 877, + 878, 7, 5, 0, 0, - 834, - 835, + 878, + 879, 7, 10, 0, 0, - 835, - 836, + 879, + 880, 7, 8, 0, 0, - 836, - 837, + 880, + 881, 7, 7, 0, 0, - 837, - 838, + 881, + 882, 7, 1, 0, 0, - 838, - 839, + 882, + 883, 7, 7, 0, 0, - 839, - 840, + 883, + 884, 7, - 15, + 17, 0, 0, - 840, - 841, + 884, + 885, 7, - 11, + 12, 0, 0, - 841, - 842, + 885, + 886, 5, 95, 0, 0, - 842, - 843, + 886, + 887, 7, 4, 0, 0, - 843, - 844, + 887, + 888, 7, 7, 0, 0, - 844, - 845, + 888, + 889, 7, 23, 0, 0, - 845, - 846, + 889, + 890, 7, 10, 0, 0, - 846, - 847, + 890, + 891, 7, 1, 0, 0, - 847, - 848, + 891, + 892, 7, 4, 0, 0, - 848, - 849, + 892, + 893, 7, 6, 0, 0, - 849, - 850, + 893, + 894, 7, 23, 0, 0, - 850, - 851, + 894, + 895, 7, 21, 0, 0, - 851, - 128, + 895, + 134, 1, 0, 0, 0, - 852, - 853, + 896, + 897, 7, 21, 0, 0, - 853, - 854, + 897, + 898, 7, 5, 0, 0, - 854, - 855, + 898, + 899, 7, 10, 0, 0, - 855, - 856, + 899, + 900, 7, 8, 0, 0, - 856, - 857, + 900, + 901, 7, 7, 0, 0, - 857, - 858, + 901, + 902, 7, 1, 0, - 0, - 858, - 859, + 0, + 902, + 903, 7, 7, 0, 0, - 859, - 860, + 903, + 904, 7, - 15, + 17, 0, 0, - 860, - 861, + 904, + 905, 7, - 11, + 12, 0, 0, - 861, - 862, + 905, + 906, 5, 95, 0, 0, - 862, - 863, + 906, + 907, 7, 4, 0, 0, - 863, - 864, + 907, + 908, 7, 7, 0, 0, - 864, - 865, + 908, + 909, 7, 23, 0, 0, - 865, - 866, + 909, + 910, 7, 10, 0, 0, - 866, - 867, + 910, + 911, 7, 1, 0, 0, - 867, - 868, + 911, + 912, 7, 4, 0, 0, - 868, - 869, + 912, + 913, 7, 6, 0, 0, - 869, - 870, + 913, + 914, 7, 23, 0, 0, - 870, - 871, + 914, + 915, 7, 21, 0, 0, - 871, - 872, + 915, + 916, 5, 95, 0, 0, - 872, - 873, + 916, + 917, 7, 4, 0, 0, - 873, - 874, + 917, + 918, 7, 28, 0, 0, - 874, - 130, + 918, + 136, 1, 0, 0, 0, - 875, - 876, + 919, + 920, 7, 16, 0, 0, - 876, - 877, + 920, + 921, 7, 7, 0, 0, - 877, - 878, + 921, + 922, 7, 29, 0, 0, - 878, - 879, + 922, + 923, 7, 10, 0, 0, - 879, - 880, + 923, + 924, 7, - 12, + 13, 0, 0, - 880, - 881, + 924, + 925, 7, 8, 0, 0, - 881, - 882, + 925, + 926, 7, 24, 0, 0, - 882, - 883, + 926, + 927, 7, 6, 0, 0, - 883, - 884, + 927, + 928, 7, 5, 0, 0, - 884, - 132, + 928, + 138, 1, 0, 0, 0, - 885, - 886, + 929, + 930, 7, - 13, + 14, 0, 0, - 886, - 887, + 930, + 931, 7, 6, 0, 0, - 887, - 888, + 931, + 932, 7, 5, 0, 0, - 888, - 889, + 932, + 933, 7, 8, 0, 0, - 889, - 890, + 933, + 934, 7, 24, 0, 0, - 890, - 891, + 934, + 935, 7, 6, 0, 0, - 891, - 892, + 935, + 936, 7, 5, 0, 0, - 892, - 134, + 936, + 140, 1, 0, 0, 0, - 893, - 894, + 937, + 938, 7, 16, 0, 0, - 894, - 895, + 938, + 939, 7, 7, 0, 0, - 895, - 896, + 939, + 940, 7, 29, 0, 0, - 896, - 897, + 940, + 941, 7, 10, 0, 0, - 897, - 898, + 941, + 942, 7, - 12, + 13, 0, 0, - 898, - 899, + 942, + 943, 7, 3, 0, 0, - 899, - 900, + 943, + 944, 7, 7, 0, 0, - 900, - 901, + 944, + 945, 7, - 11, + 12, 0, 0, - 901, - 902, + 945, + 946, 7, 6, 0, 0, - 902, - 903, + 946, + 947, 7, 5, 0, 0, - 903, - 904, + 947, + 948, 7, 22, 0, 0, - 904, - 136, + 948, + 142, 1, 0, 0, 0, - 905, - 906, + 949, + 950, 7, 1, 0, 0, - 906, - 907, + 950, + 951, 7, 4, 0, 0, - 907, - 908, + 951, + 952, 7, 5, 0, 0, - 908, - 909, + 952, + 953, 7, 2, 0, 0, - 909, - 910, + 953, + 954, 7, 8, 0, 0, - 910, - 911, + 954, + 955, 7, 4, 0, 0, - 911, - 138, + 955, + 144, 1, 0, 0, 0, - 912, - 913, + 956, + 957, 7, - 11, + 12, 0, 0, - 913, - 914, + 957, + 958, 7, 1, 0, 0, - 914, - 915, + 958, + 959, 7, 4, 0, 0, - 915, - 916, + 959, + 960, 7, 5, 0, 0, - 916, - 917, + 960, + 961, 7, 2, 0, 0, - 917, - 918, + 961, + 962, 7, 8, 0, 0, - 918, - 919, + 962, + 963, 7, 4, 0, 0, - 919, - 140, + 963, + 146, 1, 0, 0, 0, - 920, - 921, + 964, + 965, 7, 9, 0, 0, - 921, - 922, + 965, + 966, 7, 7, 0, 0, - 922, - 923, + 966, + 967, 7, 1, 0, 0, - 923, - 924, + 967, + 968, 7, 4, 0, 0, - 924, - 142, + 968, + 148, 1, 0, 0, 0, - 925, - 926, + 969, + 970, 7, 23, 0, 0, - 926, - 927, + 970, + 971, 7, 6, 0, 0, - 927, - 928, + 971, + 972, 7, 21, 0, 0, - 928, - 144, + 972, + 150, 1, 0, 0, 0, - 929, - 930, + 973, + 974, 7, 2, 0, 0, - 930, - 931, + 974, + 975, 5, 33, 0, 0, - 931, - 146, + 975, + 152, 1, 0, 0, 0, - 932, - 933, + 976, + 977, 7, 3, 0, 0, - 933, - 934, + 977, + 978, 7, - 15, + 17, 0, 0, - 934, - 935, + 978, + 979, 7, - 15, + 17, 0, 0, - 935, - 936, + 979, + 980, 7, 9, 0, 0, - 936, - 148, + 980, + 154, 1, 0, 0, 0, - 937, - 938, + 981, + 982, 7, 1, 0, 0, - 938, - 939, + 982, + 983, 7, 4, 0, 0, - 939, - 940, + 983, + 984, 7, 5, 0, 0, - 940, - 150, + 984, + 156, 1, 0, 0, 0, - 941, - 942, + 985, + 986, 7, - 13, + 14, 0, 0, - 942, - 943, + 986, + 987, 7, 3, 0, 0, - 943, - 944, + 987, + 988, 7, 7, 0, 0, - 944, - 945, + 988, + 989, 7, - 11, + 12, 0, 0, - 945, - 152, + 989, + 158, 1, 0, 0, 0, - 946, - 947, + 990, + 991, 7, 4, 0, 0, - 947, - 948, + 991, + 992, 7, 1, 0, 0, - 948, - 154, + 992, + 160, 1, 0, 0, 0, - 949, - 950, + 993, + 994, 7, 4, 0, 0, - 950, - 951, + 994, + 995, 7, 1, 0, 0, - 951, - 952, + 995, + 996, 7, 4, 0, 0, - 952, - 953, + 996, + 997, 7, 28, 0, 0, - 953, - 156, + 997, + 162, 1, 0, 0, 0, - 954, - 955, + 998, + 999, 7, 7, 0, 0, - 955, - 956, + 999, + 1000, 7, 22, 0, 0, - 956, - 957, + 1000, + 1001, 7, 10, 0, 0, - 957, - 958, + 1001, + 1002, 7, 6, 0, 0, - 958, - 959, + 1002, + 1003, 7, 5, 0, 0, - 959, - 158, + 1003, + 164, 1, 0, 0, 0, - 960, - 961, + 1004, + 1005, 7, 7, 0, 0, - 961, - 962, + 1005, + 1006, 7, - 12, + 13, 0, 0, - 962, - 963, + 1006, + 1007, 7, 6, 0, 0, - 963, - 964, + 1007, + 1008, 7, 22, 0, 0, - 964, - 160, + 1008, + 166, 1, 0, 0, 0, - 965, - 966, + 1009, + 1010, 7, - 12, + 13, 0, 0, - 966, - 967, + 1010, + 1011, 7, 10, 0, 0, - 967, - 968, + 1011, + 1012, 7, 8, 0, 0, - 968, - 162, + 1012, + 168, 1, 0, 0, 0, - 969, - 970, + 1013, + 1014, 7, 21, 0, 0, - 970, - 971, + 1014, + 1015, 7, 4, 0, 0, - 971, - 972, + 1015, + 1016, 7, 1, 0, 0, - 972, - 164, + 1016, + 170, 1, 0, 0, 0, - 973, - 974, + 1017, + 1018, 7, 21, 0, 0, - 974, - 975, + 1018, + 1019, 7, 4, 0, 0, - 975, - 976, + 1019, + 1020, 7, 1, 0, 0, - 976, - 977, + 1020, + 1021, 7, 4, 0, 0, - 977, - 978, + 1021, + 1022, 7, 28, 0, 0, - 978, - 166, + 1022, + 172, 1, 0, 0, - 0, - 979, - 980, + 0, + 1023, + 1024, 7, 16, 0, 0, - 980, - 981, + 1024, + 1025, 7, 8, 0, 0, - 981, - 982, + 1025, + 1026, 7, 24, 0, 0, - 982, - 983, + 1026, + 1027, 7, 6, 0, 0, - 983, - 984, + 1027, + 1028, 7, 5, 0, 0, - 984, - 168, + 1028, + 174, 1, 0, 0, 0, - 985, - 986, + 1029, + 1030, 7, - 13, + 14, 0, 0, - 986, - 987, + 1030, + 1031, 7, 8, 0, 0, - 987, - 988, + 1031, + 1032, 7, 24, 0, 0, - 988, - 989, + 1032, + 1033, 7, 6, 0, 0, - 989, - 990, + 1033, + 1034, 7, 5, 0, 0, - 990, - 170, + 1034, + 176, 1, 0, 0, 0, - 991, - 992, + 1035, + 1036, 7, 16, 0, 0, - 992, - 993, + 1036, + 1037, 7, 3, 0, 0, - 993, - 994, + 1037, + 1038, 7, 7, 0, 0, - 994, - 995, + 1038, + 1039, 7, - 11, + 12, 0, 0, - 995, - 172, + 1039, + 178, 1, 0, 0, 0, - 996, - 997, + 1040, + 1041, 7, 6, 0, 0, - 997, - 998, + 1041, + 1042, 7, - 11, + 12, 0, 0, - 998, - 999, + 1042, + 1043, 7, 22, 0, 0, - 999, - 174, + 1043, + 180, 1, 0, 0, 0, - 1000, - 1001, + 1044, + 1045, 3, - 173, - 86, + 179, + 89, 0, - 1001, - 1002, + 1045, + 1046, 7, 20, 0, 0, - 1002, - 176, + 1046, + 182, 1, 0, 0, 0, - 1003, - 1004, + 1047, + 1048, 5, 58, 0, 0, - 1004, - 1005, + 1048, + 1049, 5, 58, 0, 0, - 1005, - 178, + 1049, + 184, 1, 0, 0, 0, - 1006, - 1007, + 1050, + 1051, 5, 43, 0, 0, - 1007, - 180, + 1051, + 186, 1, 0, 0, 0, - 1008, - 1009, + 1052, + 1053, 5, 45, 0, 0, - 1009, - 182, + 1053, + 188, 1, 0, 0, 0, - 1010, - 1011, + 1054, + 1055, 5, 42, 0, 0, - 1011, - 184, + 1055, + 190, 1, 0, 0, 0, - 1012, - 1013, + 1056, + 1057, 5, 47, 0, 0, - 1013, - 186, + 1057, + 192, 1, 0, 0, 0, - 1014, - 1015, + 1058, + 1059, 5, 37, 0, 0, - 1015, - 188, + 1059, + 194, 1, 0, 0, 0, - 1016, - 1017, + 1060, + 1061, 5, 61, 0, 0, - 1017, - 190, + 1061, + 196, 1, 0, 0, 0, - 1018, - 1019, + 1062, + 1063, 5, 33, 0, 0, - 1019, - 1020, + 1063, + 1064, 5, 61, 0, 0, - 1020, - 192, + 1064, + 198, 1, 0, 0, 0, - 1021, - 1022, + 1065, + 1066, 5, 62, 0, 0, - 1022, - 1023, + 1066, + 1067, 5, 61, 0, 0, - 1023, - 194, + 1067, + 200, 1, 0, 0, 0, - 1024, - 1025, + 1068, + 1069, 5, 60, 0, 0, - 1025, - 1026, + 1069, + 1070, 5, 61, 0, 0, - 1026, - 196, + 1070, + 202, 1, 0, 0, 0, - 1027, - 1028, + 1071, + 1072, 5, 62, 0, 0, - 1028, - 198, + 1072, + 204, 1, 0, 0, 0, - 1029, - 1030, + 1073, + 1074, 5, 60, 0, 0, - 1030, - 200, + 1074, + 206, 1, 0, 0, 0, - 1031, - 1032, + 1075, + 1076, 5, 33, 0, 0, - 1032, - 202, + 1076, + 208, 1, 0, 0, 0, - 1033, - 1034, + 1077, + 1078, 5, 40, 0, 0, - 1034, - 204, + 1078, + 210, 1, 0, 0, 0, - 1035, - 1036, + 1079, + 1080, 5, 41, 0, 0, - 1036, - 206, + 1080, + 212, 1, 0, 0, 0, - 1037, - 1038, + 1081, + 1082, 5, 91, 0, 0, - 1038, - 208, + 1082, + 214, 1, 0, 0, 0, - 1039, - 1040, + 1083, + 1084, 5, 93, 0, - 0, - 1040, - 210, + 0, + 1084, + 216, 1, 0, 0, 0, - 1041, - 1042, + 1085, + 1086, 5, 44, 0, 0, - 1042, - 212, + 1086, + 218, 1, 0, 0, 0, - 1043, - 1044, + 1087, + 1088, 5, 58, 0, 0, - 1044, - 214, + 1088, + 220, 1, 0, 0, 0, - 1045, - 1046, + 1089, + 1090, 5, 63, 0, 0, - 1046, - 216, + 1090, + 222, 1, 0, 0, 0, - 1047, - 1048, + 1091, + 1092, 5, 35, 0, 0, - 1048, - 218, + 1092, + 224, 1, 0, 0, 0, - 1049, - 1050, + 1093, + 1094, 5, 46, 0, 0, - 1050, - 220, + 1094, + 226, 1, 0, 0, 0, - 1051, - 1052, + 1095, + 1096, 7, 6, 0, 0, - 1052, - 1053, + 1096, + 1097, 7, - 11, + 12, 0, 0, - 1053, - 1054, + 1097, + 1098, 7, - 12, + 13, 0, 0, - 1054, - 222, + 1098, + 228, 1, 0, 0, 0, - 1055, - 1056, + 1099, + 1100, 7, - 15, + 17, 0, 0, - 1056, - 1057, + 1100, + 1101, 7, 5, 0, 0, - 1057, - 224, + 1101, + 230, 1, 0, 0, 0, - 1058, - 1059, + 1102, + 1103, 5, 58, 0, 0, - 1059, - 1060, + 1103, + 1104, 5, 61, 0, 0, - 1060, - 226, + 1104, + 232, 1, 0, 0, 0, - 1061, - 1065, + 1105, + 1109, 2, 49, 57, 0, - 1062, - 1064, + 1106, + 1108, 3, - 229, - 114, + 235, + 117, 0, - 1063, - 1062, + 1107, + 1106, 1, 0, 0, 0, - 1064, - 1067, + 1108, + 1111, 1, 0, 0, 0, - 1065, - 1063, + 1109, + 1107, 1, 0, 0, 0, - 1065, - 1066, + 1109, + 1110, 1, 0, 0, 0, - 1066, - 1070, + 1110, + 1114, 1, 0, 0, 0, - 1067, - 1065, + 1111, + 1109, 1, 0, 0, 0, - 1068, - 1070, + 1112, + 1114, 5, 48, 0, 0, - 1069, - 1061, + 1113, + 1105, 1, 0, 0, 0, - 1069, - 1068, + 1113, + 1112, 1, 0, 0, 0, - 1070, - 228, + 1114, + 234, 1, 0, 0, 0, - 1071, - 1072, + 1115, + 1116, 2, 48, 57, 0, - 1072, - 230, + 1116, + 236, 1, 0, 0, 0, - 1073, - 1075, + 1117, + 1119, 5, 45, 0, 0, - 1074, - 1073, + 1118, + 1117, 1, 0, 0, 0, - 1074, - 1075, + 1118, + 1119, 1, 0, 0, 0, - 1075, - 1076, + 1119, + 1120, 1, 0, 0, 0, - 1076, - 1077, + 1120, + 1121, 3, - 227, - 113, + 233, + 116, 0, - 1077, - 232, + 1121, + 238, 1, 0, 0, 0, - 1078, - 1083, + 1122, + 1127, 7, 30, 0, 0, - 1079, - 1082, + 1123, + 1126, 7, 30, 0, 0, - 1080, - 1082, + 1124, + 1126, 3, - 229, - 114, + 235, + 117, 0, - 1081, - 1079, + 1125, + 1123, 1, 0, 0, 0, - 1081, - 1080, + 1125, + 1124, 1, 0, 0, 0, - 1082, - 1085, + 1126, + 1129, 1, 0, 0, 0, - 1083, - 1081, + 1127, + 1125, 1, 0, 0, 0, - 1083, - 1084, + 1127, + 1128, 1, 0, 0, 0, - 1084, - 234, + 1128, + 240, 1, 0, 0, 0, - 1085, - 1083, + 1129, + 1127, 1, 0, 0, 0, - 1086, - 1088, + 1130, + 1132, 5, 13, 0, 0, - 1087, - 1089, + 1131, + 1133, 5, 10, 0, 0, - 1088, - 1087, + 1132, + 1131, 1, 0, 0, 0, - 1088, - 1089, + 1132, + 1133, 1, 0, 0, 0, - 1089, - 1092, + 1133, + 1136, 1, 0, 0, 0, - 1090, - 1092, + 1134, + 1136, 5, 10, 0, 0, - 1091, - 1086, + 1135, + 1130, 1, 0, 0, 0, - 1091, - 1090, + 1135, + 1134, 1, 0, 0, 0, - 1092, - 236, + 1136, + 242, 1, 0, 0, 0, 52, 0, - 240, - 292, - 298, - 300, - 308, - 312, - 395, - 400, - 405, - 411, - 413, - 416, - 421, - 427, - 430, - 434, - 439, - 441, - 444, - 453, - 464, - 490, - 492, - 516, - 518, - 532, - 534, - 573, - 583, - 592, - 602, - 609, - 614, - 619, - 626, - 631, - 638, - 643, - 656, - 658, + 246, + 323, + 329, + 331, + 339, + 343, + 433, + 438, + 443, + 449, + 451, + 454, + 459, + 465, + 468, + 472, + 477, + 479, + 482, + 491, + 502, + 528, + 530, + 554, + 556, + 570, + 572, + 611, + 621, + 630, + 640, + 647, + 652, + 657, + 664, 669, + 676, 681, - 684, - 689, - 1065, - 1069, - 1074, - 1081, - 1083, - 1088, - 1091, + 694, + 696, + 713, + 725, + 728, + 733, + 1109, + 1113, + 1118, + 1125, + 1127, + 1132, + 1135, 1, 0, 1, @@ -9614,115 +9972,118 @@ class FuncTestCaseLexer(Lexer): Whitespace = 1 TripleHash = 2 SubstraitScalarTest = 3 - SubstraitInclude = 4 - FormatVersion = 5 - DescriptionLine = 6 - ErrorResult = 7 - UndefineResult = 8 - Overflow = 9 - Rounding = 10 - Error = 11 - Saturate = 12 - Silent = 13 - TieToEven = 14 - NaN = 15 - IntegerLiteral = 16 - DecimalLiteral = 17 - FloatLiteral = 18 - BooleanLiteral = 19 - TimestampTzLiteral = 20 - TimestampLiteral = 21 - TimeLiteral = 22 - DateLiteral = 23 - PeriodPrefix = 24 - TimePrefix = 25 - YearPrefix = 26 - MSuffix = 27 - DaySuffix = 28 - HourSuffix = 29 - SecondSuffix = 30 - FractionalSecondSuffix = 31 - OAngleBracket = 32 - CAngleBracket = 33 - IntervalYearLiteral = 34 - IntervalDayLiteral = 35 - NullLiteral = 36 - StringLiteral = 37 - LineComment = 38 - BlockComment = 39 - If = 40 - Then = 41 - Else = 42 - Boolean = 43 - I8 = 44 - I16 = 45 - I32 = 46 - I64 = 47 - FP32 = 48 - FP64 = 49 - String = 50 - Binary = 51 - Timestamp = 52 - Timestamp_TZ = 53 - Date = 54 - Time = 55 - Interval_Year = 56 - Interval_Day = 57 - UUID = 58 - Decimal = 59 - Precision_Timestamp = 60 - Precision_Timestamp_TZ = 61 - FixedChar = 62 - VarChar = 63 - FixedBinary = 64 - Struct = 65 - NStruct = 66 - List = 67 - Map = 68 - UserDefined = 69 - Bool = 70 - Str = 71 - VBin = 72 - Ts = 73 - TsTZ = 74 - IYear = 75 - IDay = 76 - Dec = 77 - PTs = 78 - PTsTZ = 79 - FChar = 80 - VChar = 81 - FBin = 82 - Any = 83 - AnyVar = 84 - DoubleColon = 85 - Plus = 86 - Minus = 87 - Asterisk = 88 - ForwardSlash = 89 - Percent = 90 - Eq = 91 - Ne = 92 - Gte = 93 - Lte = 94 - Gt = 95 - Lt = 96 - Bang = 97 - OParen = 98 - CParen = 99 - OBracket = 100 - CBracket = 101 - Comma = 102 - Colon = 103 - QMark = 104 - Hash = 105 - Dot = 106 - And = 107 - Or = 108 - Assign = 109 - Number = 110 - Identifier = 111 - Newline = 112 + SubstraitAggregateTest = 4 + SubstraitInclude = 5 + FormatVersion = 6 + DescriptionLine = 7 + Define = 8 + ErrorResult = 9 + UndefineResult = 10 + Overflow = 11 + Rounding = 12 + Error = 13 + Saturate = 14 + Silent = 15 + TieToEven = 16 + NaN = 17 + IntegerLiteral = 18 + DecimalLiteral = 19 + FloatLiteral = 20 + BooleanLiteral = 21 + TimestampTzLiteral = 22 + TimestampLiteral = 23 + TimeLiteral = 24 + DateLiteral = 25 + PeriodPrefix = 26 + TimePrefix = 27 + YearPrefix = 28 + MSuffix = 29 + DaySuffix = 30 + HourSuffix = 31 + SecondSuffix = 32 + FractionalSecondSuffix = 33 + OAngleBracket = 34 + CAngleBracket = 35 + IntervalYearLiteral = 36 + IntervalDayLiteral = 37 + NullLiteral = 38 + StringLiteral = 39 + ColumnName = 40 + LineComment = 41 + BlockComment = 42 + If = 43 + Then = 44 + Else = 45 + Boolean = 46 + I8 = 47 + I16 = 48 + I32 = 49 + I64 = 50 + FP32 = 51 + FP64 = 52 + String = 53 + Binary = 54 + Timestamp = 55 + Timestamp_TZ = 56 + Date = 57 + Time = 58 + Interval_Year = 59 + Interval_Day = 60 + UUID = 61 + Decimal = 62 + Precision_Timestamp = 63 + Precision_Timestamp_TZ = 64 + FixedChar = 65 + VarChar = 66 + FixedBinary = 67 + Struct = 68 + NStruct = 69 + List = 70 + Map = 71 + UserDefined = 72 + Bool = 73 + Str = 74 + VBin = 75 + Ts = 76 + TsTZ = 77 + IYear = 78 + IDay = 79 + Dec = 80 + PTs = 81 + PTsTZ = 82 + FChar = 83 + VChar = 84 + FBin = 85 + Any = 86 + AnyVar = 87 + DoubleColon = 88 + Plus = 89 + Minus = 90 + Asterisk = 91 + ForwardSlash = 92 + Percent = 93 + Eq = 94 + Ne = 95 + Gte = 96 + Lte = 97 + Gt = 98 + Lt = 99 + Bang = 100 + OParen = 101 + CParen = 102 + OBracket = 103 + CBracket = 104 + Comma = 105 + Colon = 106 + QMark = 107 + Hash = 108 + Dot = 109 + And = 110 + Or = 111 + Assign = 112 + Number = 113 + Identifier = 114 + Newline = 115 channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] @@ -9732,7 +10093,9 @@ class FuncTestCaseLexer(Lexer): "", "'###'", "'SUBSTRAIT_SCALAR_TEST'", + "'SUBSTRAIT_AGGREGATE_TEST'", "'SUBSTRAIT_INCLUDE'", + "'DEFINE'", "''", "''", "'OVERFLOW'", @@ -9827,9 +10190,11 @@ class FuncTestCaseLexer(Lexer): "Whitespace", "TripleHash", "SubstraitScalarTest", + "SubstraitAggregateTest", "SubstraitInclude", "FormatVersion", "DescriptionLine", + "Define", "ErrorResult", "UndefineResult", "Overflow", @@ -9861,6 +10226,7 @@ class FuncTestCaseLexer(Lexer): "IntervalDayLiteral", "NullLiteral", "StringLiteral", + "ColumnName", "LineComment", "BlockComment", "If", @@ -9942,9 +10308,11 @@ class FuncTestCaseLexer(Lexer): "Whitespace", "TripleHash", "SubstraitScalarTest", + "SubstraitAggregateTest", "SubstraitInclude", "FormatVersion", "DescriptionLine", + "Define", "ErrorResult", "UndefineResult", "Overflow", @@ -9979,6 +10347,7 @@ class FuncTestCaseLexer(Lexer): "TimeInterval", "NullLiteral", "StringLiteral", + "ColumnName", "LineComment", "BlockComment", "DIGIT", diff --git a/tests/coverage/antlr_parser/FuncTestCaseParser.py b/tests/coverage/antlr_parser/FuncTestCaseParser.py index 6812996d3..848635fef 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParser.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.py @@ -15,8 +15,8 @@ def serializedATN(): return [ 4, 1, - 112, - 378, + 115, + 522, 2, 0, 7, @@ -185,20 +185,64 @@ def serializedATN(): 41, 7, 41, + 2, + 42, + 7, + 42, + 2, + 43, + 7, + 43, + 2, + 44, + 7, + 44, + 2, + 45, + 7, + 45, + 2, + 46, + 7, + 46, + 2, + 47, + 7, + 47, + 2, + 48, + 7, + 48, + 2, + 49, + 7, + 49, + 2, + 50, + 7, + 50, + 2, + 51, + 7, + 51, + 2, + 52, + 7, + 52, 1, 0, 1, 0, 4, 0, - 87, + 109, 8, 0, 11, 0, 12, 0, - 88, + 110, 1, 0, 1, @@ -233,14 +277,14 @@ def serializedATN(): 3, 5, 3, - 107, + 129, 8, 3, 10, 3, 12, 3, - 110, + 132, 9, 3, 1, @@ -265,7 +309,7 @@ def serializedATN(): 5, 3, 5, - 122, + 144, 8, 5, 1, @@ -280,14 +324,33 @@ def serializedATN(): 6, 4, 6, - 129, + 151, 8, 6, 11, 6, 12, 6, - 130, + 152, + 1, + 6, + 1, + 6, + 4, + 6, + 157, + 8, + 6, + 11, + 6, + 12, + 6, + 158, + 3, + 6, + 161, + 8, + 6, 1, 7, 1, @@ -296,14 +359,14 @@ def serializedATN(): 7, 5, 7, - 136, + 166, 8, 7, 10, 7, 12, 7, - 139, + 169, 9, 7, 1, @@ -312,7 +375,7 @@ def serializedATN(): 8, 3, 8, - 143, + 173, 8, 8, 1, @@ -341,7 +404,7 @@ def serializedATN(): 9, 3, 9, - 157, + 187, 8, 9, 1, @@ -350,16 +413,85 @@ def serializedATN(): 10, 1, 10, + 1, + 10, + 1, + 10, 3, 10, - 162, + 194, 8, 10, 1, + 10, + 1, + 10, + 1, + 10, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, 11, 1, 11, 1, + 11, + 3, + 11, + 216, + 8, + 11, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 5, + 12, + 224, + 8, + 12, + 10, + 12, + 12, + 12, + 227, + 9, + 12, + 1, 12, 1, 12, @@ -375,6 +507,27 @@ def serializedATN(): 13, 1, 13, + 5, + 13, + 237, + 8, + 13, + 10, + 13, + 12, + 13, + 240, + 9, + 13, + 3, + 13, + 242, + 8, + 13, + 1, + 13, + 1, + 13, 1, 14, 1, @@ -391,6 +544,27 @@ def serializedATN(): 15, 1, 15, + 5, + 15, + 254, + 8, + 15, + 10, + 15, + 12, + 15, + 257, + 9, + 15, + 3, + 15, + 259, + 8, + 15, + 1, + 15, + 1, + 15, 1, 16, 1, @@ -400,20 +574,57 @@ def serializedATN(): 1, 16, 1, - 17, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 3, + 16, + 273, + 8, + 16, 1, 17, 1, 17, 1, 17, + 5, + 17, + 278, + 8, + 17, + 10, + 17, + 12, + 17, + 281, + 9, + 17, 1, 18, 1, 18, 1, 18, - 1, + 5, + 18, + 286, + 8, + 18, + 10, + 18, + 12, + 18, + 289, + 9, 18, 1, 19, @@ -423,6 +634,11 @@ def serializedATN(): 19, 1, 19, + 3, + 19, + 295, + 8, + 19, 1, 20, 1, @@ -431,18 +647,22 @@ def serializedATN(): 20, 1, 20, + 3, + 20, + 301, + 8, + 20, 1, 21, 1, 21, 1, 21, - 1, + 3, + 21, + 306, + 8, 21, - 1, - 22, - 1, - 22, 1, 22, 1, @@ -464,41 +684,6 @@ def serializedATN(): 1, 24, 1, - 24, - 1, - 24, - 3, - 24, - 220, - 8, - 24, - 1, - 24, - 1, - 24, - 1, - 24, - 3, - 24, - 225, - 8, - 24, - 1, - 25, - 1, - 25, - 1, - 25, - 1, - 25, - 1, - 25, - 1, - 25, - 3, - 25, - 233, - 8, 25, 1, 25, @@ -506,123 +691,22 @@ def serializedATN(): 25, 1, 25, - 3, - 25, - 238, - 8, - 25, - 1, - 26, - 1, - 26, - 1, - 26, - 1, - 26, - 3, - 26, - 244, - 8, - 26, - 1, - 26, - 1, - 26, - 3, - 26, - 248, - 8, - 26, - 1, - 26, - 1, - 26, - 3, - 26, - 252, - 8, - 26, - 1, - 26, - 1, - 26, - 1, - 26, - 1, - 26, - 3, - 26, - 258, - 8, - 26, - 1, - 26, - 1, - 26, - 3, - 26, - 262, - 8, - 26, - 1, - 26, 1, 26, 1, 26, 1, 26, - 3, - 26, - 268, - 8, - 26, - 1, - 26, 1, 26, - 3, - 26, - 272, - 8, - 26, 1, 27, 1, 27, - 3, - 27, - 276, - 8, - 27, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, 1, - 28, + 27, 1, - 28, + 27, 1, 28, 1, @@ -631,20 +715,6 @@ def serializedATN(): 28, 1, 28, - 3, - 28, - 296, - 8, - 28, - 1, - 29, - 1, - 29, - 3, - 29, - 300, - 8, - 29, 1, 29, 1, @@ -657,15 +727,6 @@ def serializedATN(): 30, 1, 30, - 3, - 30, - 308, - 8, - 30, - 1, - 30, - 1, - 30, 1, 30, 1, @@ -674,15 +735,6 @@ def serializedATN(): 31, 1, 31, - 3, - 31, - 316, - 8, - 31, - 1, - 31, - 1, - 31, 1, 31, 1, @@ -691,38 +743,11 @@ def serializedATN(): 32, 1, 32, - 3, - 32, - 324, - 8, - 32, - 1, - 32, - 1, - 32, - 1, - 32, 1, 32, 1, 32, 1, - 32, - 3, - 32, - 332, - 8, - 32, - 1, - 33, - 1, - 33, - 3, - 33, - 336, - 8, - 33, - 1, 33, 1, 33, @@ -734,25 +759,27 @@ def serializedATN(): 34, 1, 34, - 3, - 34, - 344, - 8, - 34, 1, 34, 1, 34, 1, - 34, + 35, 1, - 34, + 35, + 1, + 35, 1, 35, 1, 35, 1, 35, + 3, + 35, + 364, + 8, + 35, 1, 35, 1, @@ -761,7 +788,7 @@ def serializedATN(): 35, 3, 35, - 356, + 369, 8, 35, 1, @@ -769,2619 +796,3958 @@ def serializedATN(): 1, 36, 1, - 37, + 36, 1, - 37, + 36, 1, - 38, + 36, 1, - 38, + 36, + 3, + 36, + 377, + 8, + 36, 1, - 38, + 36, 1, - 38, + 36, 1, - 39, + 36, + 3, + 36, + 382, + 8, + 36, 1, - 39, + 37, 1, - 40, + 37, 1, - 40, + 37, 1, - 41, + 37, + 3, + 37, + 388, + 8, + 37, 1, - 41, + 37, 1, - 41, - 5, - 41, - 373, + 37, + 3, + 37, + 392, 8, - 41, - 10, - 41, - 12, - 41, - 376, - 9, - 41, + 37, 1, - 41, - 0, - 0, - 42, - 0, - 2, - 4, - 6, + 37, + 1, + 37, + 3, + 37, + 396, 8, - 10, - 12, - 14, - 16, - 18, - 20, - 22, - 24, - 26, - 28, - 30, - 32, - 34, - 36, - 38, - 40, - 42, - 44, - 46, - 48, - 50, - 52, - 54, - 56, - 58, - 60, - 62, - 64, - 66, - 68, - 70, - 72, - 74, - 76, - 78, - 80, - 82, - 0, - 6, - 2, - 0, - 15, - 15, - 18, - 18, + 37, 1, - 0, - 44, - 47, + 37, 1, - 0, - 48, - 49, + 37, 1, - 0, - 7, + 37, + 1, + 37, + 3, + 37, + 402, 8, - 2, - 0, - 9, - 10, - 111, - 111, + 37, 1, - 0, - 11, - 15, - 397, - 0, - 84, + 37, 1, - 0, - 0, - 0, - 2, - 92, + 37, + 3, + 37, + 406, + 8, + 37, 1, - 0, - 0, - 0, - 4, - 95, + 37, 1, - 0, - 0, - 0, - 6, - 100, + 37, 1, - 0, - 0, - 0, + 37, + 1, + 37, + 3, + 37, + 412, 8, - 111, + 37, 1, - 0, - 0, - 0, - 10, - 113, + 37, 1, - 0, - 0, - 0, - 12, - 126, + 37, + 3, + 37, + 416, + 8, + 37, 1, - 0, - 0, - 0, - 14, - 132, + 38, 1, - 0, - 0, - 0, - 16, - 142, + 38, + 3, + 38, + 420, + 8, + 38, 1, - 0, - 0, - 0, - 18, - 156, + 39, 1, - 0, - 0, - 0, - 20, - 161, + 39, 1, - 0, - 0, - 0, - 22, - 163, + 39, 1, - 0, - 0, - 0, - 24, - 165, + 39, 1, - 0, - 0, - 0, - 26, - 169, + 39, 1, - 0, - 0, - 0, - 28, - 173, + 39, 1, - 0, - 0, - 0, - 30, - 177, + 39, 1, - 0, - 0, - 0, - 32, - 181, + 39, 1, - 0, - 0, - 0, - 34, - 185, + 39, 1, - 0, - 0, - 0, - 36, - 189, + 39, 1, - 0, - 0, - 0, - 38, - 193, + 39, 1, - 0, - 0, - 0, - 40, - 197, + 39, 1, - 0, - 0, - 0, - 42, - 201, + 39, 1, - 0, - 0, - 0, - 44, - 205, + 39, 1, - 0, - 0, - 0, - 46, - 209, + 39, 1, - 0, - 0, - 0, - 48, - 224, + 39, 1, - 0, - 0, - 0, - 50, - 237, + 39, 1, - 0, - 0, - 0, - 52, - 271, + 39, + 3, + 39, + 440, + 8, + 39, 1, - 0, - 0, - 0, - 54, - 275, + 40, 1, - 0, - 0, - 0, - 56, - 295, + 40, + 3, + 40, + 444, + 8, + 40, 1, - 0, - 0, - 0, - 58, - 297, + 40, 1, - 0, - 0, - 0, - 60, - 305, + 40, 1, - 0, - 0, - 0, - 62, - 313, + 40, 1, - 0, - 0, - 0, - 64, - 321, + 40, 1, - 0, - 0, - 0, - 66, - 333, + 41, 1, - 0, - 0, - 0, - 68, - 341, + 41, + 3, + 41, + 452, + 8, + 41, 1, - 0, - 0, - 0, - 70, - 355, + 41, 1, - 0, - 0, - 0, - 72, - 357, + 41, 1, - 0, - 0, - 0, - 74, - 359, + 41, 1, - 0, - 0, - 0, - 76, - 361, + 41, 1, - 0, - 0, - 0, - 78, - 365, + 42, 1, - 0, - 0, - 0, - 80, - 367, + 42, + 3, + 42, + 460, + 8, + 42, 1, - 0, - 0, - 0, - 82, - 369, + 42, 1, - 0, - 0, - 0, - 84, - 86, - 3, - 2, + 42, 1, - 0, - 85, - 87, - 3, - 12, - 6, - 0, - 86, - 85, + 42, 1, - 0, - 0, - 0, - 87, - 88, + 42, 1, - 0, - 0, - 0, - 88, - 86, + 43, 1, - 0, - 0, - 0, - 88, - 89, + 43, + 3, + 43, + 468, + 8, + 43, 1, - 0, - 0, - 0, - 89, - 90, + 43, 1, - 0, - 0, - 0, - 90, - 91, - 5, - 0, - 0, + 43, 1, - 91, + 43, 1, + 43, 1, - 0, - 0, - 0, - 92, - 93, - 3, - 4, - 2, - 0, - 93, - 94, - 3, - 6, + 43, + 1, + 43, 3, - 0, - 94, + 43, + 476, + 8, + 43, + 1, + 44, + 1, + 44, 3, + 44, + 480, + 8, + 44, 1, - 0, - 0, - 0, - 95, - 96, - 5, - 2, - 0, - 0, - 96, - 97, - 5, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 45, + 1, + 45, 3, - 0, - 0, - 97, - 98, - 5, - 103, - 0, - 0, - 98, - 99, - 5, - 5, - 0, - 0, - 99, - 5, + 45, + 488, + 8, + 45, 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 3, + 46, + 500, + 8, + 46, + 1, + 47, + 1, + 47, + 1, + 48, + 1, + 48, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 50, + 1, + 50, + 1, + 51, + 1, + 51, + 1, + 52, + 1, + 52, + 1, + 52, + 5, + 52, + 517, + 8, + 52, + 10, + 52, + 12, + 52, + 520, + 9, + 52, + 1, + 52, 0, 0, + 53, 0, - 100, - 101, - 5, 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 32, + 34, + 36, + 38, + 40, + 42, + 44, + 46, + 48, + 50, + 52, + 54, + 56, + 58, + 60, + 62, + 64, + 66, + 68, + 70, + 72, + 74, + 76, + 78, + 80, + 82, + 84, + 86, + 88, + 90, + 92, + 94, + 96, + 98, + 100, + 102, + 104, 0, + 22, + 1, 0, - 101, - 102, - 5, + 3, 4, + 2, 0, + 17, + 17, + 20, + 20, + 1, 0, - 102, - 103, - 5, - 103, - 0, + 47, + 50, + 1, 0, - 103, - 108, - 5, - 37, + 51, + 52, + 2, 0, + 46, + 46, + 73, + 73, + 2, 0, - 104, - 105, - 5, - 102, + 53, + 53, + 74, + 74, + 2, 0, + 55, + 55, + 76, + 76, + 2, 0, - 105, - 107, - 5, - 37, + 56, + 56, + 77, + 77, + 2, 0, + 59, + 59, + 78, + 78, + 2, 0, - 106, - 104, - 1, + 60, + 60, + 79, + 79, + 2, 0, + 54, + 54, + 75, + 75, + 2, 0, + 59, + 59, + 79, + 79, + 2, 0, - 107, - 110, - 1, + 60, + 60, + 78, + 78, + 2, 0, + 65, + 65, + 83, + 83, + 2, 0, + 66, + 66, + 84, + 84, + 2, 0, - 108, - 106, - 1, + 67, + 67, + 85, + 85, + 2, 0, + 62, + 62, + 80, + 80, + 2, 0, + 63, + 63, + 81, + 81, + 2, 0, - 108, - 109, + 64, + 64, + 82, + 82, 1, 0, + 9, + 10, + 2, 0, - 0, - 109, - 7, + 11, + 12, + 114, + 114, 1, 0, + 13, + 17, + 553, 0, - 0, - 110, - 108, + 106, 1, 0, 0, 0, - 111, - 112, - 5, - 6, + 2, + 114, + 1, 0, 0, - 112, - 9, + 0, + 4, + 117, 1, 0, 0, 0, - 113, - 114, - 5, - 111, + 6, + 122, + 1, 0, 0, - 114, - 115, - 5, - 98, 0, + 8, + 133, + 1, 0, - 115, - 116, - 3, - 14, - 7, 0, - 116, - 121, - 5, - 99, 0, + 10, + 135, + 1, 0, - 117, - 118, - 5, - 100, 0, 0, - 118, - 119, - 3, - 82, - 41, + 12, + 160, + 1, 0, - 119, - 120, - 5, - 101, 0, 0, - 120, - 122, + 14, + 162, 1, 0, 0, 0, - 121, - 117, + 16, + 172, 1, 0, 0, 0, - 121, - 122, + 18, + 186, 1, 0, 0, 0, - 122, - 123, + 20, + 188, 1, 0, 0, 0, - 123, - 124, - 5, - 91, + 22, + 215, + 1, 0, 0, - 124, - 125, - 3, - 16, - 8, 0, - 125, - 11, + 24, + 217, 1, 0, 0, 0, - 126, - 128, - 3, - 8, - 4, + 26, + 232, + 1, 0, - 127, - 129, - 3, - 10, - 5, 0, - 128, - 127, + 0, + 28, + 245, 1, 0, 0, 0, - 129, - 130, + 30, + 249, 1, 0, 0, 0, - 130, - 128, + 32, + 272, 1, 0, 0, 0, - 130, - 131, + 34, + 274, 1, 0, 0, 0, - 131, - 13, + 36, + 282, 1, 0, 0, 0, - 132, - 137, - 3, - 18, - 9, - 0, - 133, - 134, - 5, - 102, + 38, + 294, + 1, 0, 0, - 134, - 136, - 3, - 18, - 9, 0, - 135, - 133, + 40, + 300, 1, 0, 0, 0, - 136, - 139, + 42, + 305, 1, 0, 0, 0, - 137, - 135, + 44, + 307, 1, 0, 0, 0, - 137, - 138, + 46, + 309, 1, 0, 0, 0, - 138, - 15, + 48, + 313, 1, 0, 0, 0, - 139, - 137, + 50, + 317, 1, 0, 0, 0, - 140, - 143, - 3, - 18, - 9, + 52, + 321, + 1, 0, - 141, - 143, - 3, - 74, - 37, 0, - 142, - 140, + 0, + 54, + 325, 1, 0, 0, 0, - 142, - 141, + 56, + 329, 1, 0, 0, 0, - 143, - 17, + 58, + 333, 1, 0, 0, 0, - 144, - 157, - 3, - 24, - 12, + 60, + 337, + 1, 0, - 145, - 157, - 3, - 26, - 13, 0, - 146, - 157, - 3, - 28, - 14, 0, - 147, - 157, - 3, - 32, - 16, + 62, + 341, + 1, 0, - 148, - 157, - 3, - 34, - 17, 0, - 149, - 157, - 3, - 30, - 15, 0, - 150, - 157, - 3, - 36, - 18, + 64, + 345, + 1, 0, - 151, - 157, - 3, - 38, - 19, 0, - 152, - 157, - 3, - 40, - 20, 0, - 153, - 157, - 3, - 42, - 21, + 66, + 349, + 1, 0, - 154, - 157, - 3, - 44, - 22, 0, - 155, - 157, - 3, - 46, - 23, 0, - 156, - 144, + 68, + 353, 1, 0, 0, 0, - 156, - 145, + 70, + 368, 1, 0, 0, 0, - 156, - 146, + 72, + 381, 1, 0, 0, 0, - 156, - 147, + 74, + 415, 1, 0, 0, 0, - 156, - 148, + 76, + 419, 1, 0, 0, 0, - 156, - 149, + 78, + 439, 1, 0, 0, 0, - 156, - 150, + 80, + 441, 1, 0, 0, 0, - 156, - 151, + 82, + 449, 1, 0, 0, 0, - 156, - 152, + 84, + 457, 1, 0, 0, 0, - 156, - 153, + 86, + 465, 1, 0, 0, 0, - 156, - 154, + 88, + 477, 1, 0, 0, 0, - 156, - 155, + 90, + 485, 1, 0, 0, 0, - 157, - 19, + 92, + 499, 1, 0, 0, 0, - 158, - 162, - 5, - 17, - 0, - 0, - 159, - 162, - 5, - 16, + 94, + 501, + 1, 0, 0, - 160, - 162, - 3, - 22, - 11, 0, - 161, - 158, + 96, + 503, 1, 0, 0, 0, - 161, - 159, + 98, + 505, 1, 0, 0, 0, - 161, - 160, + 100, + 509, 1, 0, 0, 0, - 162, - 21, + 102, + 511, 1, 0, 0, 0, - 163, - 164, - 7, + 104, + 513, + 1, 0, 0, 0, - 164, - 23, + 106, + 108, + 3, + 2, 1, 0, + 107, + 109, + 3, + 12, + 6, 0, + 108, + 107, + 1, 0, - 165, - 166, - 5, - 36, 0, 0, - 166, - 167, - 5, - 85, + 109, + 110, + 1, 0, 0, - 167, - 168, - 3, - 54, - 27, 0, - 168, - 25, + 110, + 108, 1, 0, 0, 0, - 169, - 170, - 5, - 16, - 0, + 110, + 111, + 1, 0, - 170, - 171, - 5, - 85, 0, 0, - 171, - 172, - 7, + 111, + 112, 1, 0, 0, - 172, - 27, - 1, 0, + 112, + 113, + 5, 0, 0, - 173, - 174, - 3, - 20, - 10, + 1, + 113, + 1, + 1, 0, - 174, - 175, - 5, - 85, 0, 0, - 175, - 176, - 7, + 114, + 115, + 3, + 4, 2, 0, + 115, + 116, + 3, + 6, + 3, 0, - 176, - 29, + 116, + 3, 1, 0, 0, 0, - 177, - 178, - 3, - 20, - 10, - 0, - 178, - 179, + 117, + 118, 5, - 85, - 0, + 2, 0, - 179, - 180, - 3, - 64, - 32, 0, - 180, - 31, - 1, + 118, + 119, + 7, 0, 0, 0, - 181, - 182, + 119, + 120, 5, - 19, + 106, 0, 0, - 182, - 183, + 120, + 121, 5, - 85, + 6, 0, 0, - 183, - 184, + 121, 5, - 70, - 0, - 0, - 184, - 33, 1, 0, 0, 0, - 185, - 186, + 122, + 123, 5, - 37, + 2, 0, 0, - 186, - 187, + 123, + 124, 5, - 85, - 0, - 0, - 187, - 188, 5, - 71, - 0, 0, - 188, - 35, - 1, 0, + 124, + 125, + 5, + 106, 0, 0, - 189, - 190, + 125, + 130, 5, - 23, + 39, 0, 0, - 190, - 191, + 126, + 127, 5, - 85, + 105, 0, 0, - 191, - 192, + 127, + 129, 5, - 54, + 39, 0, 0, - 192, - 37, + 128, + 126, 1, 0, 0, 0, - 193, - 194, - 5, - 22, - 0, - 0, - 194, - 195, - 5, - 85, - 0, + 129, + 132, + 1, 0, - 195, - 196, - 5, - 55, 0, 0, - 196, - 39, + 130, + 128, 1, 0, 0, 0, - 197, - 198, - 5, - 21, + 130, + 131, + 1, 0, 0, - 198, - 199, - 5, - 85, 0, + 131, + 7, + 1, 0, - 199, - 200, - 5, - 73, 0, 0, - 200, - 41, + 132, + 130, 1, 0, 0, 0, - 201, - 202, + 133, + 134, 5, - 20, + 7, 0, 0, - 202, - 203, - 5, - 85, + 134, + 9, + 1, 0, 0, - 203, - 204, + 0, + 135, + 136, 5, - 74, + 114, 0, 0, - 204, - 43, - 1, + 136, + 137, + 5, + 101, 0, 0, + 137, + 138, + 3, + 14, + 7, 0, - 205, - 206, + 138, + 143, 5, - 34, + 102, 0, 0, - 206, - 207, + 139, + 140, 5, - 85, + 103, 0, 0, - 207, - 208, + 140, + 141, + 3, + 104, + 52, + 0, + 141, + 142, 5, - 75, + 104, 0, 0, - 208, - 45, + 142, + 144, 1, 0, 0, 0, - 209, - 210, - 5, - 35, + 143, + 139, + 1, 0, 0, - 210, - 211, - 5, - 85, 0, + 143, + 144, + 1, 0, - 211, - 212, - 5, - 76, 0, 0, - 212, - 47, + 144, + 145, 1, 0, 0, 0, - 213, - 214, + 145, + 146, 5, - 24, + 94, 0, 0, - 214, - 215, - 5, + 146, + 147, + 3, 16, + 8, 0, - 0, - 215, - 216, - 5, - 26, - 0, - 0, - 216, - 219, + 147, + 11, 1, 0, 0, 0, - 217, - 218, + 148, + 150, + 3, + 8, + 4, + 0, + 149, + 151, + 3, + 10, 5, - 16, 0, + 150, + 149, + 1, 0, - 218, - 220, - 5, - 27, 0, 0, - 219, - 217, + 151, + 152, 1, 0, 0, 0, - 219, - 220, + 152, + 150, 1, 0, 0, 0, - 220, - 225, + 152, + 153, 1, 0, 0, 0, - 221, - 222, - 5, - 24, - 0, + 153, + 161, + 1, 0, - 222, - 223, - 5, - 16, 0, 0, - 223, - 225, - 5, - 27, + 154, + 156, + 3, + 8, + 4, 0, + 155, + 157, + 3, + 20, + 10, 0, - 224, - 213, + 156, + 155, 1, 0, 0, 0, - 224, - 221, + 157, + 158, 1, 0, 0, 0, - 225, - 49, + 158, + 156, 1, 0, 0, 0, - 226, - 227, - 5, - 24, + 158, + 159, + 1, 0, 0, - 227, - 228, - 5, - 16, 0, + 159, + 161, + 1, 0, - 228, - 229, - 5, - 28, 0, 0, - 229, - 232, + 160, + 148, 1, 0, 0, 0, - 230, - 231, - 5, - 25, + 160, + 154, + 1, 0, 0, - 231, - 233, - 3, - 52, - 26, - 0, - 232, - 230, - 1, 0, + 161, + 13, + 1, 0, 0, - 232, - 233, - 1, 0, + 162, + 167, + 3, + 18, + 9, 0, + 163, + 164, + 5, + 105, 0, - 233, - 238, - 1, 0, + 164, + 166, + 3, + 18, + 9, 0, + 165, + 163, + 1, 0, - 234, - 235, - 5, - 24, 0, 0, - 235, - 236, - 5, - 25, + 166, + 169, + 1, 0, 0, - 236, - 238, - 3, - 52, - 26, 0, - 237, - 226, + 167, + 165, 1, 0, 0, 0, - 237, - 234, + 167, + 168, 1, 0, 0, 0, - 238, - 51, + 168, + 15, 1, 0, 0, 0, - 239, - 240, - 5, - 16, + 169, + 167, + 1, 0, 0, - 240, - 243, - 5, - 29, 0, + 170, + 173, + 3, + 18, + 9, 0, - 241, - 242, - 5, - 16, + 171, + 173, + 3, + 96, + 48, 0, + 172, + 170, + 1, 0, - 242, - 244, - 5, - 27, 0, 0, - 243, - 241, + 172, + 171, 1, 0, 0, 0, - 243, - 244, + 173, + 17, 1, 0, 0, 0, - 244, - 247, - 1, + 174, + 187, + 3, + 46, + 23, 0, + 175, + 187, + 3, + 48, + 24, 0, + 176, + 187, + 3, + 50, + 25, 0, - 245, - 246, - 5, - 16, + 177, + 187, + 3, + 54, + 27, 0, + 178, + 187, + 3, + 56, + 28, 0, - 246, - 248, - 5, + 179, + 187, + 3, + 52, + 26, + 0, + 180, + 187, + 3, + 58, + 29, + 0, + 181, + 187, + 3, + 60, 30, 0, + 182, + 187, + 3, + 62, + 31, 0, - 247, - 245, - 1, + 183, + 187, + 3, + 64, + 32, 0, + 184, + 187, + 3, + 66, + 33, 0, + 185, + 187, + 3, + 68, + 34, 0, - 247, - 248, + 186, + 174, 1, 0, 0, 0, - 248, - 251, + 186, + 175, 1, 0, 0, 0, - 249, - 250, - 5, - 16, - 0, + 186, + 176, + 1, 0, - 250, - 252, - 5, - 31, 0, 0, - 251, - 249, + 186, + 177, 1, 0, 0, 0, - 251, - 252, + 186, + 178, 1, 0, 0, 0, - 252, - 272, + 186, + 179, 1, 0, 0, 0, - 253, - 254, - 5, - 16, - 0, - 0, - 254, - 257, - 5, - 27, + 186, + 180, + 1, 0, 0, - 255, - 256, - 5, - 16, 0, + 186, + 181, + 1, 0, - 256, - 258, - 5, - 30, 0, 0, - 257, - 255, + 186, + 182, 1, 0, 0, 0, - 257, - 258, + 186, + 183, 1, 0, 0, 0, - 258, - 261, + 186, + 184, 1, 0, 0, 0, - 259, - 260, - 5, - 16, - 0, + 186, + 185, + 1, 0, - 260, - 262, - 5, - 31, 0, 0, - 261, - 259, + 187, + 19, 1, 0, 0, 0, - 261, - 262, - 1, - 0, - 0, - 0, - 262, - 272, - 1, - 0, - 0, + 188, + 193, + 3, + 22, + 11, 0, - 263, - 264, + 189, + 190, 5, - 16, - 0, + 103, 0, - 264, - 267, - 5, - 30, 0, + 190, + 191, + 3, + 104, + 52, 0, - 265, - 266, + 191, + 192, 5, - 16, + 104, 0, 0, - 266, - 268, - 5, - 31, + 192, + 194, + 1, 0, 0, - 267, - 265, + 0, + 193, + 189, 1, 0, 0, 0, - 267, - 268, + 193, + 194, 1, 0, 0, 0, - 268, - 272, + 194, + 195, 1, 0, 0, 0, - 269, - 270, + 195, + 196, 5, - 16, - 0, + 94, 0, - 270, - 272, - 5, - 31, 0, + 196, + 197, + 3, + 16, + 8, 0, - 271, - 239, + 197, + 21, 1, 0, 0, 0, - 271, - 253, - 1, - 0, + 198, + 199, + 3, + 24, + 12, 0, + 199, + 200, + 5, + 114, 0, - 271, - 263, - 1, 0, + 200, + 201, + 5, + 101, 0, 0, - 271, - 269, - 1, + 201, + 202, + 3, + 34, + 17, 0, + 202, + 203, + 5, + 102, 0, 0, - 272, - 53, + 203, + 216, 1, 0, 0, 0, - 273, - 276, + 204, + 205, 3, - 56, - 28, + 26, + 13, 0, - 274, - 276, - 3, - 70, - 35, + 205, + 206, + 5, + 114, 0, - 275, - 273, - 1, 0, + 206, + 207, + 5, + 101, 0, 0, - 275, - 274, - 1, + 207, + 208, + 3, + 36, + 18, 0, + 208, + 209, + 5, + 102, 0, 0, - 276, - 55, + 209, + 216, 1, 0, 0, 0, - 277, - 296, + 210, + 211, 5, - 70, + 114, 0, 0, - 278, - 296, + 211, + 212, 5, - 44, + 101, 0, 0, - 279, - 296, + 212, + 213, + 3, + 28, + 14, + 0, + 213, + 214, 5, - 45, + 102, 0, 0, - 280, - 296, - 5, - 46, + 214, + 216, + 1, 0, 0, - 281, - 296, - 5, - 47, 0, + 215, + 198, + 1, 0, - 282, - 296, - 5, - 48, 0, 0, - 283, - 296, - 5, - 49, + 215, + 204, + 1, 0, 0, - 284, - 296, - 5, - 71, 0, + 215, + 210, + 1, 0, - 285, - 296, - 5, - 51, 0, 0, - 286, - 296, - 5, - 73, + 216, + 23, + 1, 0, 0, - 287, - 296, + 0, + 217, + 218, 5, - 74, + 8, 0, 0, - 288, - 296, + 218, + 219, 5, - 54, + 114, 0, 0, - 289, - 296, + 219, + 220, 5, - 55, + 101, 0, 0, - 290, - 296, - 5, + 220, + 225, + 3, 76, + 38, 0, - 0, - 291, - 296, + 221, + 222, 5, - 75, - 0, + 105, 0, - 292, - 296, - 5, - 58, 0, + 222, + 224, + 3, + 76, + 38, 0, - 293, - 294, - 5, - 69, - 0, + 223, + 221, + 1, 0, - 294, - 296, - 5, - 111, 0, 0, - 295, - 277, + 224, + 227, 1, 0, 0, 0, - 295, - 278, + 225, + 223, 1, 0, 0, 0, - 295, - 279, + 225, + 226, 1, 0, 0, 0, - 295, - 280, + 226, + 228, 1, 0, 0, 0, - 295, - 281, + 227, + 225, 1, 0, 0, 0, - 295, - 282, - 1, - 0, + 228, + 229, + 5, + 102, 0, 0, - 295, - 283, - 1, + 229, + 230, + 5, + 94, 0, 0, + 230, + 231, + 3, + 26, + 13, 0, - 295, - 284, + 231, + 25, 1, 0, 0, 0, - 295, - 285, - 1, + 232, + 241, + 5, + 101, 0, 0, + 233, + 238, + 3, + 30, + 15, 0, - 295, - 286, - 1, + 234, + 235, + 5, + 105, 0, 0, + 235, + 237, + 3, + 30, + 15, 0, - 295, - 287, + 236, + 234, 1, 0, 0, 0, - 295, - 288, + 237, + 240, 1, 0, 0, 0, - 295, - 289, + 238, + 236, 1, 0, 0, 0, - 295, - 290, + 238, + 239, 1, 0, 0, 0, - 295, - 291, + 239, + 242, 1, 0, 0, 0, - 295, - 292, + 240, + 238, 1, 0, 0, 0, - 295, - 293, + 241, + 233, 1, 0, 0, 0, - 296, - 57, + 241, + 242, 1, 0, 0, 0, - 297, - 299, - 5, - 80, + 242, + 243, + 1, 0, 0, - 298, - 300, + 0, + 243, + 244, 5, - 104, + 102, 0, 0, - 299, - 298, + 244, + 27, 1, 0, 0, 0, - 299, - 300, - 1, + 245, + 246, + 3, + 30, + 15, + 0, + 246, + 247, + 5, + 88, 0, 0, + 247, + 248, + 3, + 76, + 38, 0, - 300, - 301, + 248, + 29, 1, 0, 0, 0, - 301, - 302, + 249, + 258, 5, - 32, + 101, 0, 0, - 302, - 303, + 250, + 255, 3, - 72, - 36, + 32, + 16, 0, - 303, - 304, + 251, + 252, 5, - 33, + 105, 0, 0, - 304, - 59, - 1, + 252, + 254, + 3, + 32, + 16, 0, + 253, + 251, + 1, 0, 0, - 305, - 307, - 5, - 81, 0, + 254, + 257, + 1, 0, - 306, - 308, - 5, - 104, 0, 0, - 307, - 306, + 255, + 253, 1, 0, 0, 0, - 307, - 308, + 255, + 256, 1, 0, 0, 0, - 308, - 309, + 256, + 259, 1, 0, 0, 0, - 309, - 310, - 5, - 32, + 257, + 255, + 1, 0, 0, - 310, - 311, - 3, - 72, - 36, 0, - 311, - 312, - 5, - 33, + 258, + 250, + 1, 0, 0, - 312, - 61, + 0, + 258, + 259, 1, 0, 0, 0, - 313, - 315, - 5, - 82, + 259, + 260, + 1, 0, 0, - 314, - 316, + 0, + 260, + 261, 5, - 104, + 102, 0, 0, - 315, - 314, + 261, + 31, 1, 0, 0, 0, - 315, - 316, - 1, - 0, + 262, + 273, + 5, + 38, 0, 0, - 316, - 317, - 1, + 263, + 273, + 3, + 42, + 21, 0, + 264, + 273, + 5, + 21, 0, 0, - 317, - 318, + 265, + 273, 5, - 32, + 39, 0, 0, - 318, - 319, - 3, - 72, - 36, + 266, + 273, + 5, + 25, 0, - 319, - 320, + 0, + 267, + 273, 5, - 33, + 24, 0, 0, - 320, - 63, - 1, + 268, + 273, + 5, + 23, 0, 0, + 269, + 273, + 5, + 22, + 0, 0, - 321, - 323, + 270, + 273, 5, - 77, + 36, 0, 0, - 322, - 324, + 271, + 273, 5, - 104, + 37, 0, 0, - 323, - 322, + 272, + 262, 1, 0, 0, 0, - 323, - 324, + 272, + 263, 1, 0, 0, 0, - 324, - 331, + 272, + 264, 1, 0, 0, 0, - 325, - 326, - 5, - 32, + 272, + 265, + 1, 0, 0, - 326, - 327, - 3, - 72, - 36, 0, - 327, - 328, - 5, - 102, + 272, + 266, + 1, 0, 0, - 328, - 329, - 3, - 72, - 36, 0, - 329, - 330, - 5, - 33, + 272, + 267, + 1, 0, 0, - 330, - 332, + 0, + 272, + 268, 1, 0, 0, 0, - 331, - 325, + 272, + 269, 1, 0, 0, 0, - 331, - 332, + 272, + 270, 1, 0, 0, 0, - 332, - 65, + 272, + 271, 1, 0, 0, 0, - 333, - 335, - 5, - 78, + 273, + 33, + 1, 0, 0, - 334, - 336, + 0, + 274, + 279, + 3, + 38, + 19, + 0, + 275, + 276, 5, - 104, + 105, 0, 0, - 335, - 334, + 276, + 278, + 3, + 38, + 19, + 0, + 277, + 275, 1, 0, 0, 0, - 335, - 336, + 278, + 281, 1, 0, 0, 0, - 336, - 337, + 279, + 277, 1, 0, 0, 0, - 337, - 338, - 5, - 32, + 279, + 280, + 1, 0, 0, - 338, - 339, - 3, - 72, - 36, 0, - 339, - 340, - 5, - 33, + 280, + 35, + 1, 0, 0, - 340, - 67, - 1, 0, + 281, + 279, + 1, 0, 0, - 341, - 343, - 5, - 79, 0, + 282, + 287, + 3, + 40, + 20, 0, - 342, - 344, + 283, + 284, 5, - 104, + 105, 0, 0, - 343, - 342, + 284, + 286, + 3, + 40, + 20, + 0, + 285, + 283, 1, 0, 0, 0, - 343, - 344, + 286, + 289, 1, 0, 0, 0, - 344, - 345, + 287, + 285, 1, 0, 0, 0, - 345, - 346, - 5, - 32, + 287, + 288, + 1, 0, 0, - 346, - 347, - 3, - 72, - 36, 0, - 347, - 348, - 5, - 33, + 288, + 37, + 1, 0, 0, - 348, - 69, + 0, + 289, + 287, 1, 0, 0, 0, - 349, - 356, - 3, - 58, - 29, + 290, + 291, + 5, + 114, 0, - 350, - 356, - 3, - 60, - 30, 0, - 351, - 356, - 3, - 62, - 31, + 291, + 292, + 5, + 109, 0, - 352, - 356, - 3, - 64, - 32, 0, - 353, - 356, - 3, - 66, - 33, + 292, + 295, + 5, + 40, 0, - 354, - 356, + 0, + 293, + 295, 3, - 68, - 34, + 18, + 9, 0, - 355, - 349, + 294, + 290, 1, 0, 0, 0, - 355, - 350, + 294, + 293, 1, 0, 0, 0, - 355, - 351, + 295, + 39, 1, 0, 0, 0, - 355, - 352, - 1, + 296, + 297, + 5, + 40, 0, 0, + 297, + 298, + 5, + 88, + 0, 0, - 355, - 353, + 298, + 301, + 3, + 76, + 38, + 0, + 299, + 301, + 3, + 18, + 9, + 0, + 300, + 296, 1, 0, 0, 0, - 355, - 354, + 300, + 299, 1, 0, 0, 0, - 356, - 71, + 301, + 41, 1, 0, 0, 0, - 357, - 358, + 302, + 306, 5, - 16, + 19, 0, 0, - 358, - 73, + 303, + 306, + 5, + 18, + 0, + 0, + 304, + 306, + 3, + 44, + 22, + 0, + 305, + 302, 1, 0, 0, 0, - 359, - 360, + 305, + 303, + 1, + 0, + 0, + 0, + 305, + 304, + 1, + 0, + 0, + 0, + 306, + 43, + 1, + 0, + 0, + 0, + 307, + 308, 7, - 3, + 1, 0, 0, - 360, - 75, + 308, + 45, 1, 0, 0, 0, - 361, - 362, - 3, - 78, - 39, + 309, + 310, + 5, + 38, 0, - 362, - 363, + 0, + 310, + 311, 5, - 103, + 88, 0, 0, - 363, - 364, + 311, + 312, 3, - 80, - 40, + 76, + 38, 0, - 364, - 77, + 312, + 47, 1, 0, 0, 0, - 365, - 366, - 7, - 4, - 0, + 313, + 314, + 5, + 18, 0, - 366, - 79, - 1, 0, + 314, + 315, + 5, + 88, 0, 0, - 367, - 368, + 315, + 316, 7, - 5, + 2, 0, 0, - 368, - 81, + 316, + 49, 1, 0, 0, 0, - 369, - 374, + 317, + 318, 3, - 76, - 38, + 42, + 21, 0, - 370, - 371, + 318, + 319, 5, - 102, + 88, 0, 0, - 371, - 373, + 319, + 320, + 7, 3, - 76, - 38, 0, - 372, - 370, + 0, + 320, + 51, 1, 0, 0, 0, - 373, - 376, - 1, + 321, + 322, + 3, + 42, + 21, 0, + 322, + 323, + 5, + 88, 0, 0, - 374, - 372, + 323, + 324, + 3, + 86, + 43, + 0, + 324, + 53, 1, 0, 0, 0, - 374, - 375, - 1, + 325, + 326, + 5, + 21, 0, 0, + 326, + 327, + 5, + 88, 0, - 375, - 83, - 1, 0, + 327, + 328, + 7, + 4, 0, 0, - 376, - 374, + 328, + 55, 1, 0, 0, 0, - 30, + 329, + 330, + 5, + 39, + 0, + 0, + 330, + 331, + 5, 88, - 108, - 121, - 130, - 137, - 142, - 156, - 161, - 219, - 224, - 232, - 237, - 243, - 247, - 251, - 257, - 261, - 267, - 271, - 275, - 295, - 299, - 307, - 315, - 323, + 0, + 0, 331, + 332, + 7, + 5, + 0, + 0, + 332, + 57, + 1, + 0, + 0, + 0, + 333, + 334, + 5, + 25, + 0, + 0, + 334, + 335, + 5, + 88, + 0, + 0, 335, + 336, + 5, + 57, + 0, + 0, + 336, + 59, + 1, + 0, + 0, + 0, + 337, + 338, + 5, + 24, + 0, + 0, + 338, + 339, + 5, + 88, + 0, + 0, + 339, + 340, + 5, + 58, + 0, + 0, + 340, + 61, + 1, + 0, + 0, + 0, + 341, + 342, + 5, + 23, + 0, + 0, + 342, + 343, + 5, + 88, + 0, + 0, 343, + 344, + 7, + 6, + 0, + 0, + 344, + 63, + 1, + 0, + 0, + 0, + 345, + 346, + 5, + 22, + 0, + 0, + 346, + 347, + 5, + 88, + 0, + 0, + 347, + 348, + 7, + 7, + 0, + 0, + 348, + 65, + 1, + 0, + 0, + 0, + 349, + 350, + 5, + 36, + 0, + 0, + 350, + 351, + 5, + 88, + 0, + 0, + 351, + 352, + 7, + 8, + 0, + 0, + 352, + 67, + 1, + 0, + 0, + 0, + 353, + 354, + 5, + 37, + 0, + 0, + 354, 355, - 374, - ] - - -class FuncTestCaseParser(Parser): - grammarFileName = "FuncTestCaseParser.g4" - - atn = ATNDeserializer().deserialize(serializedATN()) - - decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] - - sharedContextCache = PredictionContextCache() - - literalNames = [ - "", - "", - "'###'", - "'SUBSTRAIT_SCALAR_TEST'", - "'SUBSTRAIT_INCLUDE'", - "", - "", - "''", - "''", - "'OVERLFOW'", - "'ROUNDING'", - "'ERROR'", - "'SATURATE'", - "'SILENT'", - "'TIE_TO_EVEN'", - "'NAN'", - "", - "", - "", - "", - "", - "", - "", - "", - "'P'", - "'T'", - "'Y'", - "'M'", - "'D'", - "'H'", - "'S'", - "'F'", - "", - "", - "", - "", - "'null'", - "", - "", - "", - "'IF'", - "'THEN'", - "'ELSE'", - "'BOOLEAN'", - "'I8'", - "'I16'", - "'I32'", - "'I64'", - "'FP32'", - "'FP64'", - "'STRING'", - "'BINARY'", - "'TIMESTAMP'", - "'TIMESTAMP_TZ'", - "'DATE'", - "'TIME'", - "'INTERVAL_YEAR'", - "'INTERVAL_DAY'", - "'UUID'", - "'DECIMAL'", - "'PRECISION_TIMESTAMP'", - "'PRECISION_TIMESTAMP_TZ'", - "'FIXEDCHAR'", - "'VARCHAR'", - "'FIXEDBINARY'", - "'STRUCT'", - "'NSTRUCT'", - "'LIST'", - "'MAP'", - "'U!'", - "'BOOL'", - "'STR'", + 5, + 88, + 0, + 0, + 355, + 356, + 7, + 9, + 0, + 0, + 356, + 69, + 1, + 0, + 0, + 0, + 357, + 358, + 5, + 26, + 0, + 0, + 358, + 359, + 5, + 18, + 0, + 0, + 359, + 360, + 5, + 28, + 0, + 0, + 360, + 363, + 1, + 0, + 0, + 0, + 361, + 362, + 5, + 18, + 0, + 0, + 362, + 364, + 5, + 29, + 0, + 0, + 363, + 361, + 1, + 0, + 0, + 0, + 363, + 364, + 1, + 0, + 0, + 0, + 364, + 369, + 1, + 0, + 0, + 0, + 365, + 366, + 5, + 26, + 0, + 0, + 366, + 367, + 5, + 18, + 0, + 0, + 367, + 369, + 5, + 29, + 0, + 0, + 368, + 357, + 1, + 0, + 0, + 0, + 368, + 365, + 1, + 0, + 0, + 0, + 369, + 71, + 1, + 0, + 0, + 0, + 370, + 371, + 5, + 26, + 0, + 0, + 371, + 372, + 5, + 18, + 0, + 0, + 372, + 373, + 5, + 30, + 0, + 0, + 373, + 376, + 1, + 0, + 0, + 0, + 374, + 375, + 5, + 27, + 0, + 0, + 375, + 377, + 3, + 74, + 37, + 0, + 376, + 374, + 1, + 0, + 0, + 0, + 376, + 377, + 1, + 0, + 0, + 0, + 377, + 382, + 1, + 0, + 0, + 0, + 378, + 379, + 5, + 26, + 0, + 0, + 379, + 380, + 5, + 27, + 0, + 0, + 380, + 382, + 3, + 74, + 37, + 0, + 381, + 370, + 1, + 0, + 0, + 0, + 381, + 378, + 1, + 0, + 0, + 0, + 382, + 73, + 1, + 0, + 0, + 0, + 383, + 384, + 5, + 18, + 0, + 0, + 384, + 387, + 5, + 31, + 0, + 0, + 385, + 386, + 5, + 18, + 0, + 0, + 386, + 388, + 5, + 29, + 0, + 0, + 387, + 385, + 1, + 0, + 0, + 0, + 387, + 388, + 1, + 0, + 0, + 0, + 388, + 391, + 1, + 0, + 0, + 0, + 389, + 390, + 5, + 18, + 0, + 0, + 390, + 392, + 5, + 32, + 0, + 0, + 391, + 389, + 1, + 0, + 0, + 0, + 391, + 392, + 1, + 0, + 0, + 0, + 392, + 395, + 1, + 0, + 0, + 0, + 393, + 394, + 5, + 18, + 0, + 0, + 394, + 396, + 5, + 33, + 0, + 0, + 395, + 393, + 1, + 0, + 0, + 0, + 395, + 396, + 1, + 0, + 0, + 0, + 396, + 416, + 1, + 0, + 0, + 0, + 397, + 398, + 5, + 18, + 0, + 0, + 398, + 401, + 5, + 29, + 0, + 0, + 399, + 400, + 5, + 18, + 0, + 0, + 400, + 402, + 5, + 32, + 0, + 0, + 401, + 399, + 1, + 0, + 0, + 0, + 401, + 402, + 1, + 0, + 0, + 0, + 402, + 405, + 1, + 0, + 0, + 0, + 403, + 404, + 5, + 18, + 0, + 0, + 404, + 406, + 5, + 33, + 0, + 0, + 405, + 403, + 1, + 0, + 0, + 0, + 405, + 406, + 1, + 0, + 0, + 0, + 406, + 416, + 1, + 0, + 0, + 0, + 407, + 408, + 5, + 18, + 0, + 0, + 408, + 411, + 5, + 32, + 0, + 0, + 409, + 410, + 5, + 18, + 0, + 0, + 410, + 412, + 5, + 33, + 0, + 0, + 411, + 409, + 1, + 0, + 0, + 0, + 411, + 412, + 1, + 0, + 0, + 0, + 412, + 416, + 1, + 0, + 0, + 0, + 413, + 414, + 5, + 18, + 0, + 0, + 414, + 416, + 5, + 33, + 0, + 0, + 415, + 383, + 1, + 0, + 0, + 0, + 415, + 397, + 1, + 0, + 0, + 0, + 415, + 407, + 1, + 0, + 0, + 0, + 415, + 413, + 1, + 0, + 0, + 0, + 416, + 75, + 1, + 0, + 0, + 0, + 417, + 420, + 3, + 78, + 39, + 0, + 418, + 420, + 3, + 92, + 46, + 0, + 419, + 417, + 1, + 0, + 0, + 0, + 419, + 418, + 1, + 0, + 0, + 0, + 420, + 77, + 1, + 0, + 0, + 0, + 421, + 440, + 7, + 4, + 0, + 0, + 422, + 440, + 5, + 47, + 0, + 0, + 423, + 440, + 5, + 48, + 0, + 0, + 424, + 440, + 5, + 49, + 0, + 0, + 425, + 440, + 5, + 50, + 0, + 0, + 426, + 440, + 5, + 51, + 0, + 0, + 427, + 440, + 5, + 52, + 0, + 0, + 428, + 440, + 7, + 5, + 0, + 0, + 429, + 440, + 7, + 10, + 0, + 0, + 430, + 440, + 7, + 6, + 0, + 0, + 431, + 440, + 7, + 7, + 0, + 0, + 432, + 440, + 5, + 57, + 0, + 0, + 433, + 440, + 5, + 58, + 0, + 0, + 434, + 440, + 7, + 11, + 0, + 0, + 435, + 440, + 7, + 12, + 0, + 0, + 436, + 440, + 5, + 61, + 0, + 0, + 437, + 438, + 5, + 72, + 0, + 0, + 438, + 440, + 5, + 114, + 0, + 0, + 439, + 421, + 1, + 0, + 0, + 0, + 439, + 422, + 1, + 0, + 0, + 0, + 439, + 423, + 1, + 0, + 0, + 0, + 439, + 424, + 1, + 0, + 0, + 0, + 439, + 425, + 1, + 0, + 0, + 0, + 439, + 426, + 1, + 0, + 0, + 0, + 439, + 427, + 1, + 0, + 0, + 0, + 439, + 428, + 1, + 0, + 0, + 0, + 439, + 429, + 1, + 0, + 0, + 0, + 439, + 430, + 1, + 0, + 0, + 0, + 439, + 431, + 1, + 0, + 0, + 0, + 439, + 432, + 1, + 0, + 0, + 0, + 439, + 433, + 1, + 0, + 0, + 0, + 439, + 434, + 1, + 0, + 0, + 0, + 439, + 435, + 1, + 0, + 0, + 0, + 439, + 436, + 1, + 0, + 0, + 0, + 439, + 437, + 1, + 0, + 0, + 0, + 440, + 79, + 1, + 0, + 0, + 0, + 441, + 443, + 7, + 13, + 0, + 0, + 442, + 444, + 5, + 107, + 0, + 0, + 443, + 442, + 1, + 0, + 0, + 0, + 443, + 444, + 1, + 0, + 0, + 0, + 444, + 445, + 1, + 0, + 0, + 0, + 445, + 446, + 5, + 34, + 0, + 0, + 446, + 447, + 3, + 94, + 47, + 0, + 447, + 448, + 5, + 35, + 0, + 0, + 448, + 81, + 1, + 0, + 0, + 0, + 449, + 451, + 7, + 14, + 0, + 0, + 450, + 452, + 5, + 107, + 0, + 0, + 451, + 450, + 1, + 0, + 0, + 0, + 451, + 452, + 1, + 0, + 0, + 0, + 452, + 453, + 1, + 0, + 0, + 0, + 453, + 454, + 5, + 34, + 0, + 0, + 454, + 455, + 3, + 94, + 47, + 0, + 455, + 456, + 5, + 35, + 0, + 0, + 456, + 83, + 1, + 0, + 0, + 0, + 457, + 459, + 7, + 15, + 0, + 0, + 458, + 460, + 5, + 107, + 0, + 0, + 459, + 458, + 1, + 0, + 0, + 0, + 459, + 460, + 1, + 0, + 0, + 0, + 460, + 461, + 1, + 0, + 0, + 0, + 461, + 462, + 5, + 34, + 0, + 0, + 462, + 463, + 3, + 94, + 47, + 0, + 463, + 464, + 5, + 35, + 0, + 0, + 464, + 85, + 1, + 0, + 0, + 0, + 465, + 467, + 7, + 16, + 0, + 0, + 466, + 468, + 5, + 107, + 0, + 0, + 467, + 466, + 1, + 0, + 0, + 0, + 467, + 468, + 1, + 0, + 0, + 0, + 468, + 475, + 1, + 0, + 0, + 0, + 469, + 470, + 5, + 34, + 0, + 0, + 470, + 471, + 3, + 94, + 47, + 0, + 471, + 472, + 5, + 105, + 0, + 0, + 472, + 473, + 3, + 94, + 47, + 0, + 473, + 474, + 5, + 35, + 0, + 0, + 474, + 476, + 1, + 0, + 0, + 0, + 475, + 469, + 1, + 0, + 0, + 0, + 475, + 476, + 1, + 0, + 0, + 0, + 476, + 87, + 1, + 0, + 0, + 0, + 477, + 479, + 7, + 17, + 0, + 0, + 478, + 480, + 5, + 107, + 0, + 0, + 479, + 478, + 1, + 0, + 0, + 0, + 479, + 480, + 1, + 0, + 0, + 0, + 480, + 481, + 1, + 0, + 0, + 0, + 481, + 482, + 5, + 34, + 0, + 0, + 482, + 483, + 3, + 94, + 47, + 0, + 483, + 484, + 5, + 35, + 0, + 0, + 484, + 89, + 1, + 0, + 0, + 0, + 485, + 487, + 7, + 18, + 0, + 0, + 486, + 488, + 5, + 107, + 0, + 0, + 487, + 486, + 1, + 0, + 0, + 0, + 487, + 488, + 1, + 0, + 0, + 0, + 488, + 489, + 1, + 0, + 0, + 0, + 489, + 490, + 5, + 34, + 0, + 0, + 490, + 491, + 3, + 94, + 47, + 0, + 491, + 492, + 5, + 35, + 0, + 0, + 492, + 91, + 1, + 0, + 0, + 0, + 493, + 500, + 3, + 80, + 40, + 0, + 494, + 500, + 3, + 82, + 41, + 0, + 495, + 500, + 3, + 84, + 42, + 0, + 496, + 500, + 3, + 86, + 43, + 0, + 497, + 500, + 3, + 88, + 44, + 0, + 498, + 500, + 3, + 90, + 45, + 0, + 499, + 493, + 1, + 0, + 0, + 0, + 499, + 494, + 1, + 0, + 0, + 0, + 499, + 495, + 1, + 0, + 0, + 0, + 499, + 496, + 1, + 0, + 0, + 0, + 499, + 497, + 1, + 0, + 0, + 0, + 499, + 498, + 1, + 0, + 0, + 0, + 500, + 93, + 1, + 0, + 0, + 0, + 501, + 502, + 5, + 18, + 0, + 0, + 502, + 95, + 1, + 0, + 0, + 0, + 503, + 504, + 7, + 19, + 0, + 0, + 504, + 97, + 1, + 0, + 0, + 0, + 505, + 506, + 3, + 100, + 50, + 0, + 506, + 507, + 5, + 106, + 0, + 0, + 507, + 508, + 3, + 102, + 51, + 0, + 508, + 99, + 1, + 0, + 0, + 0, + 509, + 510, + 7, + 20, + 0, + 0, + 510, + 101, + 1, + 0, + 0, + 0, + 511, + 512, + 7, + 21, + 0, + 0, + 512, + 103, + 1, + 0, + 0, + 0, + 513, + 518, + 3, + 98, + 49, + 0, + 514, + 515, + 5, + 105, + 0, + 0, + 515, + 517, + 3, + 98, + 49, + 0, + 516, + 514, + 1, + 0, + 0, + 0, + 517, + 520, + 1, + 0, + 0, + 0, + 518, + 516, + 1, + 0, + 0, + 0, + 518, + 519, + 1, + 0, + 0, + 0, + 519, + 105, + 1, + 0, + 0, + 0, + 520, + 518, + 1, + 0, + 0, + 0, + 44, + 110, + 130, + 143, + 152, + 158, + 160, + 167, + 172, + 186, + 193, + 215, + 225, + 238, + 241, + 255, + 258, + 272, + 279, + 287, + 294, + 300, + 305, + 363, + 368, + 376, + 381, + 387, + 391, + 395, + 401, + 405, + 411, + 415, + 419, + 439, + 443, + 451, + 459, + 467, + 475, + 479, + 487, + 499, + 518, + ] + + +class FuncTestCaseParser(Parser): + grammarFileName = "FuncTestCaseParser.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] + + sharedContextCache = PredictionContextCache() + + literalNames = [ + "", + "", + "'###'", + "'SUBSTRAIT_SCALAR_TEST'", + "'SUBSTRAIT_AGGREGATE_TEST'", + "'SUBSTRAIT_INCLUDE'", + "", + "", + "'DEFINE'", + "''", + "''", + "'OVERFLOW'", + "'ROUNDING'", + "'ERROR'", + "'SATURATE'", + "'SILENT'", + "'TIE_TO_EVEN'", + "'NAN'", + "", + "", + "", + "", + "", + "", + "", + "", + "'P'", + "'T'", + "'Y'", + "'M'", + "'D'", + "'H'", + "'S'", + "'F'", + "", + "", + "", + "", + "'null'", + "", + "", + "", + "", + "'IF'", + "'THEN'", + "'ELSE'", + "'BOOLEAN'", + "'I8'", + "'I16'", + "'I32'", + "'I64'", + "'FP32'", + "'FP64'", + "'STRING'", + "'BINARY'", + "'TIMESTAMP'", + "'TIMESTAMP_TZ'", + "'DATE'", + "'TIME'", + "'INTERVAL_YEAR'", + "'INTERVAL_DAY'", + "'UUID'", + "'DECIMAL'", + "'PRECISION_TIMESTAMP'", + "'PRECISION_TIMESTAMP_TZ'", + "'FIXEDCHAR'", + "'VARCHAR'", + "'FIXEDBINARY'", + "'STRUCT'", + "'NSTRUCT'", + "'LIST'", + "'MAP'", + "'U!'", + "'BOOL'", + "'STR'", "'VBIN'", "'TS'", "'TSTZ'", @@ -3422,333 +4788,1448 @@ class FuncTestCaseParser(Parser): "':='", ] - symbolicNames = [ - "", - "Whitespace", - "TripleHash", - "SubstraitScalarTest", - "SubstraitInclude", - "FormatVersion", - "DescriptionLine", - "ErrorResult", - "UndefineResult", - "Overflow", - "Rounding", - "Error", - "Saturate", - "Silent", - "TieToEven", - "NaN", - "IntegerLiteral", - "DecimalLiteral", - "FloatLiteral", - "BooleanLiteral", - "TimestampTzLiteral", - "TimestampLiteral", - "TimeLiteral", - "DateLiteral", - "PeriodPrefix", - "TimePrefix", - "YearPrefix", - "MSuffix", - "DaySuffix", - "HourSuffix", - "SecondSuffix", - "FractionalSecondSuffix", - "OAngleBracket", - "CAngleBracket", - "IntervalYearLiteral", - "IntervalDayLiteral", - "NullLiteral", - "StringLiteral", - "LineComment", - "BlockComment", - "If", - "Then", - "Else", - "Boolean", - "I8", - "I16", - "I32", - "I64", - "FP32", - "FP64", - "String", - "Binary", - "Timestamp", - "Timestamp_TZ", - "Date", - "Time", - "Interval_Year", - "Interval_Day", - "UUID", - "Decimal", - "Precision_Timestamp", - "Precision_Timestamp_TZ", - "FixedChar", - "VarChar", - "FixedBinary", - "Struct", - "NStruct", - "List", - "Map", - "UserDefined", - "Bool", - "Str", - "VBin", - "Ts", - "TsTZ", - "IYear", - "IDay", - "Dec", - "PTs", - "PTsTZ", - "FChar", - "VChar", - "FBin", - "Any", - "AnyVar", - "DoubleColon", - "Plus", - "Minus", - "Asterisk", - "ForwardSlash", - "Percent", - "Eq", - "Ne", - "Gte", - "Lte", - "Gt", - "Lt", - "Bang", - "OParen", - "CParen", - "OBracket", - "CBracket", - "Comma", - "Colon", - "QMark", - "Hash", - "Dot", - "And", - "Or", - "Assign", - "Number", - "Identifier", - "Newline", - ] + symbolicNames = [ + "", + "Whitespace", + "TripleHash", + "SubstraitScalarTest", + "SubstraitAggregateTest", + "SubstraitInclude", + "FormatVersion", + "DescriptionLine", + "Define", + "ErrorResult", + "UndefineResult", + "Overflow", + "Rounding", + "Error", + "Saturate", + "Silent", + "TieToEven", + "NaN", + "IntegerLiteral", + "DecimalLiteral", + "FloatLiteral", + "BooleanLiteral", + "TimestampTzLiteral", + "TimestampLiteral", + "TimeLiteral", + "DateLiteral", + "PeriodPrefix", + "TimePrefix", + "YearPrefix", + "MSuffix", + "DaySuffix", + "HourSuffix", + "SecondSuffix", + "FractionalSecondSuffix", + "OAngleBracket", + "CAngleBracket", + "IntervalYearLiteral", + "IntervalDayLiteral", + "NullLiteral", + "StringLiteral", + "ColumnName", + "LineComment", + "BlockComment", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "Timestamp_TZ", + "Date", + "Time", + "Interval_Year", + "Interval_Day", + "UUID", + "Decimal", + "Precision_Timestamp", + "Precision_Timestamp_TZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "UserDefined", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "Any", + "AnyVar", + "DoubleColon", + "Plus", + "Minus", + "Asterisk", + "ForwardSlash", + "Percent", + "Eq", + "Ne", + "Gte", + "Lte", + "Gt", + "Lt", + "Bang", + "OParen", + "CParen", + "OBracket", + "CBracket", + "Comma", + "Colon", + "QMark", + "Hash", + "Dot", + "And", + "Or", + "Assign", + "Number", + "Identifier", + "Newline", + ] + + RULE_doc = 0 + RULE_header = 1 + RULE_version = 2 + RULE_include = 3 + RULE_testGroupDescription = 4 + RULE_testCase = 5 + RULE_testGroup = 6 + RULE_arguments = 7 + RULE_result = 8 + RULE_argument = 9 + RULE_aggFuncTestCase = 10 + RULE_aggFuncCall = 11 + RULE_tableData = 12 + RULE_tableRows = 13 + RULE_dataColumn = 14 + RULE_literalValueList = 15 + RULE_literal = 16 + RULE_qualifiedAggregateFuncArgs = 17 + RULE_aggregateFuncArgs = 18 + RULE_qualifiedAggregateFuncArg = 19 + RULE_aggregateFuncArg = 20 + RULE_numericLiteral = 21 + RULE_floatLiteral = 22 + RULE_nullArg = 23 + RULE_intArg = 24 + RULE_floatArg = 25 + RULE_decimalArg = 26 + RULE_booleanArg = 27 + RULE_stringArg = 28 + RULE_dateArg = 29 + RULE_timeArg = 30 + RULE_timestampArg = 31 + RULE_timestampTzArg = 32 + RULE_intervalYearArg = 33 + RULE_intervalDayArg = 34 + RULE_intervalYearLiteral = 35 + RULE_intervalDayLiteral = 36 + RULE_timeInterval = 37 + RULE_dataType = 38 + RULE_scalarType = 39 + RULE_fixedCharType = 40 + RULE_varCharType = 41 + RULE_fixedBinaryType = 42 + RULE_decimalType = 43 + RULE_precisionTimestampType = 44 + RULE_precisionTimestampTZType = 45 + RULE_parameterizedType = 46 + RULE_numericParameter = 47 + RULE_substraitError = 48 + RULE_func_option = 49 + RULE_option_name = 50 + RULE_option_value = 51 + RULE_func_options = 52 + + ruleNames = [ + "doc", + "header", + "version", + "include", + "testGroupDescription", + "testCase", + "testGroup", + "arguments", + "result", + "argument", + "aggFuncTestCase", + "aggFuncCall", + "tableData", + "tableRows", + "dataColumn", + "literalValueList", + "literal", + "qualifiedAggregateFuncArgs", + "aggregateFuncArgs", + "qualifiedAggregateFuncArg", + "aggregateFuncArg", + "numericLiteral", + "floatLiteral", + "nullArg", + "intArg", + "floatArg", + "decimalArg", + "booleanArg", + "stringArg", + "dateArg", + "timeArg", + "timestampArg", + "timestampTzArg", + "intervalYearArg", + "intervalDayArg", + "intervalYearLiteral", + "intervalDayLiteral", + "timeInterval", + "dataType", + "scalarType", + "fixedCharType", + "varCharType", + "fixedBinaryType", + "decimalType", + "precisionTimestampType", + "precisionTimestampTZType", + "parameterizedType", + "numericParameter", + "substraitError", + "func_option", + "option_name", + "option_value", + "func_options", + ] + + EOF = Token.EOF + Whitespace = 1 + TripleHash = 2 + SubstraitScalarTest = 3 + SubstraitAggregateTest = 4 + SubstraitInclude = 5 + FormatVersion = 6 + DescriptionLine = 7 + Define = 8 + ErrorResult = 9 + UndefineResult = 10 + Overflow = 11 + Rounding = 12 + Error = 13 + Saturate = 14 + Silent = 15 + TieToEven = 16 + NaN = 17 + IntegerLiteral = 18 + DecimalLiteral = 19 + FloatLiteral = 20 + BooleanLiteral = 21 + TimestampTzLiteral = 22 + TimestampLiteral = 23 + TimeLiteral = 24 + DateLiteral = 25 + PeriodPrefix = 26 + TimePrefix = 27 + YearPrefix = 28 + MSuffix = 29 + DaySuffix = 30 + HourSuffix = 31 + SecondSuffix = 32 + FractionalSecondSuffix = 33 + OAngleBracket = 34 + CAngleBracket = 35 + IntervalYearLiteral = 36 + IntervalDayLiteral = 37 + NullLiteral = 38 + StringLiteral = 39 + ColumnName = 40 + LineComment = 41 + BlockComment = 42 + If = 43 + Then = 44 + Else = 45 + Boolean = 46 + I8 = 47 + I16 = 48 + I32 = 49 + I64 = 50 + FP32 = 51 + FP64 = 52 + String = 53 + Binary = 54 + Timestamp = 55 + Timestamp_TZ = 56 + Date = 57 + Time = 58 + Interval_Year = 59 + Interval_Day = 60 + UUID = 61 + Decimal = 62 + Precision_Timestamp = 63 + Precision_Timestamp_TZ = 64 + FixedChar = 65 + VarChar = 66 + FixedBinary = 67 + Struct = 68 + NStruct = 69 + List = 70 + Map = 71 + UserDefined = 72 + Bool = 73 + Str = 74 + VBin = 75 + Ts = 76 + TsTZ = 77 + IYear = 78 + IDay = 79 + Dec = 80 + PTs = 81 + PTsTZ = 82 + FChar = 83 + VChar = 84 + FBin = 85 + Any = 86 + AnyVar = 87 + DoubleColon = 88 + Plus = 89 + Minus = 90 + Asterisk = 91 + ForwardSlash = 92 + Percent = 93 + Eq = 94 + Ne = 95 + Gte = 96 + Lte = 97 + Gt = 98 + Lt = 99 + Bang = 100 + OParen = 101 + CParen = 102 + OBracket = 103 + CBracket = 104 + Comma = 105 + Colon = 106 + QMark = 107 + Hash = 108 + Dot = 109 + And = 110 + Or = 111 + Assign = 112 + Number = 113 + Identifier = 114 + Newline = 115 + + def __init__(self, input: TokenStream, output: TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.2") + self._interp = ParserATNSimulator( + self, self.atn, self.decisionsToDFA, self.sharedContextCache + ) + self._predicates = None + + class DocContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def header(self): + return self.getTypedRuleContext(FuncTestCaseParser.HeaderContext, 0) + + def EOF(self): + return self.getToken(FuncTestCaseParser.EOF, 0) + + def testGroup(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(FuncTestCaseParser.TestGroupContext) + else: + return self.getTypedRuleContext(FuncTestCaseParser.TestGroupContext, i) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_doc + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDoc"): + listener.enterDoc(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDoc"): + listener.exitDoc(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDoc"): + return visitor.visitDoc(self) + else: + return visitor.visitChildren(self) + + def doc(self): + localctx = FuncTestCaseParser.DocContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_doc) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 106 + self.header() + self.state = 108 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 107 + self.testGroup() + self.state = 110 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la == 7): + break + + self.state = 112 + self.match(FuncTestCaseParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class HeaderContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def version(self): + return self.getTypedRuleContext(FuncTestCaseParser.VersionContext, 0) + + def include(self): + return self.getTypedRuleContext(FuncTestCaseParser.IncludeContext, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_header + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHeader"): + listener.enterHeader(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHeader"): + listener.exitHeader(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHeader"): + return visitor.visitHeader(self) + else: + return visitor.visitChildren(self) + + def header(self): + localctx = FuncTestCaseParser.HeaderContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_header) + try: + self.enterOuterAlt(localctx, 1) + self.state = 114 + self.version() + self.state = 115 + self.include() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class VersionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def TripleHash(self): + return self.getToken(FuncTestCaseParser.TripleHash, 0) + + def Colon(self): + return self.getToken(FuncTestCaseParser.Colon, 0) + + def FormatVersion(self): + return self.getToken(FuncTestCaseParser.FormatVersion, 0) + + def SubstraitScalarTest(self): + return self.getToken(FuncTestCaseParser.SubstraitScalarTest, 0) + + def SubstraitAggregateTest(self): + return self.getToken(FuncTestCaseParser.SubstraitAggregateTest, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_version + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVersion"): + listener.enterVersion(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVersion"): + listener.exitVersion(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVersion"): + return visitor.visitVersion(self) + else: + return visitor.visitChildren(self) + + def version(self): + localctx = FuncTestCaseParser.VersionContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_version) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 117 + self.match(FuncTestCaseParser.TripleHash) + self.state = 118 + _la = self._input.LA(1) + if not (_la == 3 or _la == 4): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 119 + self.match(FuncTestCaseParser.Colon) + self.state = 120 + self.match(FuncTestCaseParser.FormatVersion) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class IncludeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def TripleHash(self): + return self.getToken(FuncTestCaseParser.TripleHash, 0) + + def SubstraitInclude(self): + return self.getToken(FuncTestCaseParser.SubstraitInclude, 0) + + def Colon(self): + return self.getToken(FuncTestCaseParser.Colon, 0) + + def StringLiteral(self, i: int = None): + if i is None: + return self.getTokens(FuncTestCaseParser.StringLiteral) + else: + return self.getToken(FuncTestCaseParser.StringLiteral, i) + + def Comma(self, i: int = None): + if i is None: + return self.getTokens(FuncTestCaseParser.Comma) + else: + return self.getToken(FuncTestCaseParser.Comma, i) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_include + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInclude"): + listener.enterInclude(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInclude"): + listener.exitInclude(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInclude"): + return visitor.visitInclude(self) + else: + return visitor.visitChildren(self) + + def include(self): + localctx = FuncTestCaseParser.IncludeContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_include) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 122 + self.match(FuncTestCaseParser.TripleHash) + self.state = 123 + self.match(FuncTestCaseParser.SubstraitInclude) + self.state = 124 + self.match(FuncTestCaseParser.Colon) + self.state = 125 + self.match(FuncTestCaseParser.StringLiteral) + self.state = 130 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 105: + self.state = 126 + self.match(FuncTestCaseParser.Comma) + self.state = 127 + self.match(FuncTestCaseParser.StringLiteral) + self.state = 132 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TestGroupDescriptionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def DescriptionLine(self): + return self.getToken(FuncTestCaseParser.DescriptionLine, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_testGroupDescription + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTestGroupDescription"): + listener.enterTestGroupDescription(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTestGroupDescription"): + listener.exitTestGroupDescription(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTestGroupDescription"): + return visitor.visitTestGroupDescription(self) + else: + return visitor.visitChildren(self) + + def testGroupDescription(self): + localctx = FuncTestCaseParser.TestGroupDescriptionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 8, self.RULE_testGroupDescription) + try: + self.enterOuterAlt(localctx, 1) + self.state = 133 + self.match(FuncTestCaseParser.DescriptionLine) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TestCaseContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + self.functionName = None # Token + + def OParen(self): + return self.getToken(FuncTestCaseParser.OParen, 0) + + def arguments(self): + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentsContext, 0) + + def CParen(self): + return self.getToken(FuncTestCaseParser.CParen, 0) + + def Eq(self): + return self.getToken(FuncTestCaseParser.Eq, 0) + + def result(self): + return self.getTypedRuleContext(FuncTestCaseParser.ResultContext, 0) + + def Identifier(self): + return self.getToken(FuncTestCaseParser.Identifier, 0) + + def OBracket(self): + return self.getToken(FuncTestCaseParser.OBracket, 0) + + def func_options(self): + return self.getTypedRuleContext(FuncTestCaseParser.Func_optionsContext, 0) + + def CBracket(self): + return self.getToken(FuncTestCaseParser.CBracket, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_testCase + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTestCase"): + listener.enterTestCase(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTestCase"): + listener.exitTestCase(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTestCase"): + return visitor.visitTestCase(self) + else: + return visitor.visitChildren(self) + + def testCase(self): + localctx = FuncTestCaseParser.TestCaseContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_testCase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 135 + localctx.functionName = self.match(FuncTestCaseParser.Identifier) + self.state = 136 + self.match(FuncTestCaseParser.OParen) + self.state = 137 + self.arguments() + self.state = 138 + self.match(FuncTestCaseParser.CParen) + self.state = 143 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 103: + self.state = 139 + self.match(FuncTestCaseParser.OBracket) + self.state = 140 + self.func_options() + self.state = 141 + self.match(FuncTestCaseParser.CBracket) + + self.state = 145 + self.match(FuncTestCaseParser.Eq) + self.state = 146 + self.result() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TestGroupContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_testGroup + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class ScalarFuncTestGroupContext(TestGroupContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.TestGroupContext + super().__init__(parser) + self.copyFrom(ctx) + + def testGroupDescription(self): + return self.getTypedRuleContext( + FuncTestCaseParser.TestGroupDescriptionContext, 0 + ) + + def testCase(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(FuncTestCaseParser.TestCaseContext) + else: + return self.getTypedRuleContext(FuncTestCaseParser.TestCaseContext, i) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterScalarFuncTestGroup"): + listener.enterScalarFuncTestGroup(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitScalarFuncTestGroup"): + listener.exitScalarFuncTestGroup(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitScalarFuncTestGroup"): + return visitor.visitScalarFuncTestGroup(self) + else: + return visitor.visitChildren(self) + + class AggregateFuncTestGroupContext(TestGroupContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.TestGroupContext + super().__init__(parser) + self.copyFrom(ctx) + + def testGroupDescription(self): + return self.getTypedRuleContext( + FuncTestCaseParser.TestGroupDescriptionContext, 0 + ) + + def aggFuncTestCase(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + FuncTestCaseParser.AggFuncTestCaseContext + ) + else: + return self.getTypedRuleContext( + FuncTestCaseParser.AggFuncTestCaseContext, i + ) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAggregateFuncTestGroup"): + listener.enterAggregateFuncTestGroup(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAggregateFuncTestGroup"): + listener.exitAggregateFuncTestGroup(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggregateFuncTestGroup"): + return visitor.visitAggregateFuncTestGroup(self) + else: + return visitor.visitChildren(self) + + def testGroup(self): + localctx = FuncTestCaseParser.TestGroupContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_testGroup) + self._la = 0 # Token type + try: + self.state = 160 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 5, self._ctx) + if la_ == 1: + localctx = FuncTestCaseParser.ScalarFuncTestGroupContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 148 + self.testGroupDescription() + self.state = 150 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 149 + self.testCase() + self.state = 152 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la == 114): + break + + pass + + elif la_ == 2: + localctx = FuncTestCaseParser.AggregateFuncTestGroupContext( + self, localctx + ) + self.enterOuterAlt(localctx, 2) + self.state = 154 + self.testGroupDescription() + self.state = 156 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 155 + self.aggFuncTestCase() + self.state = 158 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la == 8 or _la == 101 or _la == 114): + break + + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ArgumentsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def argument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(FuncTestCaseParser.ArgumentContext) + else: + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext, i) + + def Comma(self, i: int = None): + if i is None: + return self.getTokens(FuncTestCaseParser.Comma) + else: + return self.getToken(FuncTestCaseParser.Comma, i) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_arguments + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArguments"): + listener.enterArguments(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArguments"): + listener.exitArguments(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArguments"): + return visitor.visitArguments(self) + else: + return visitor.visitChildren(self) + + def arguments(self): + localctx = FuncTestCaseParser.ArgumentsContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_arguments) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 162 + self.argument() + self.state = 167 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 105: + self.state = 163 + self.match(FuncTestCaseParser.Comma) + self.state = 164 + self.argument() + self.state = 169 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ResultContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def argument(self): + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext, 0) + + def substraitError(self): + return self.getTypedRuleContext(FuncTestCaseParser.SubstraitErrorContext, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_result + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterResult"): + listener.enterResult(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitResult"): + listener.exitResult(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitResult"): + return visitor.visitResult(self) + else: + return visitor.visitChildren(self) + + def result(self): + localctx = FuncTestCaseParser.ResultContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_result) + try: + self.state = 172 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [17, 18, 19, 20, 21, 22, 23, 24, 25, 36, 37, 38, 39]: + self.enterOuterAlt(localctx, 1) + self.state = 170 + self.argument() + pass + elif token in [9, 10]: + self.enterOuterAlt(localctx, 2) + self.state = 171 + self.substraitError() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def nullArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.NullArgContext, 0) + + def intArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.IntArgContext, 0) + + def floatArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.FloatArgContext, 0) + + def booleanArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.BooleanArgContext, 0) + + def stringArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.StringArgContext, 0) + + def decimalArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.DecimalArgContext, 0) + + def dateArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.DateArgContext, 0) + + def timeArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.TimeArgContext, 0) + + def timestampArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.TimestampArgContext, 0) + + def timestampTzArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.TimestampTzArgContext, 0) + + def intervalYearArg(self): + return self.getTypedRuleContext( + FuncTestCaseParser.IntervalYearArgContext, 0 + ) + + def intervalDayArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.IntervalDayArgContext, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_argument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArgument"): + listener.enterArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArgument"): + listener.exitArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArgument"): + return visitor.visitArgument(self) + else: + return visitor.visitChildren(self) + + def argument(self): + localctx = FuncTestCaseParser.ArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_argument) + try: + self.state = 186 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 174 + self.nullArg() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 175 + self.intArg() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 176 + self.floatArg() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 177 + self.booleanArg() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 178 + self.stringArg() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 179 + self.decimalArg() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 180 + self.dateArg() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 181 + self.timeArg() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 182 + self.timestampArg() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 183 + self.timestampTzArg() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 184 + self.intervalYearArg() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 185 + self.intervalDayArg() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class AggFuncTestCaseContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def aggFuncCall(self): + return self.getTypedRuleContext(FuncTestCaseParser.AggFuncCallContext, 0) + + def Eq(self): + return self.getToken(FuncTestCaseParser.Eq, 0) + + def result(self): + return self.getTypedRuleContext(FuncTestCaseParser.ResultContext, 0) + + def OBracket(self): + return self.getToken(FuncTestCaseParser.OBracket, 0) + + def func_options(self): + return self.getTypedRuleContext(FuncTestCaseParser.Func_optionsContext, 0) + + def CBracket(self): + return self.getToken(FuncTestCaseParser.CBracket, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_aggFuncTestCase + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterAggFuncTestCase"): + listener.enterAggFuncTestCase(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitAggFuncTestCase"): + listener.exitAggFuncTestCase(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggFuncTestCase"): + return visitor.visitAggFuncTestCase(self) + else: + return visitor.visitChildren(self) + + def aggFuncTestCase(self): + localctx = FuncTestCaseParser.AggFuncTestCaseContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 20, self.RULE_aggFuncTestCase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 188 + self.aggFuncCall() + self.state = 193 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 103: + self.state = 189 + self.match(FuncTestCaseParser.OBracket) + self.state = 190 + self.func_options() + self.state = 191 + self.match(FuncTestCaseParser.CBracket) + + self.state = 195 + self.match(FuncTestCaseParser.Eq) + self.state = 196 + self.result() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class AggFuncCallContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_aggFuncCall + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class SingleArgAggregateFuncCallContext(AggFuncCallContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.AggFuncCallContext + super().__init__(parser) + self.functName = None # Token + self.copyFrom(ctx) - RULE_doc = 0 - RULE_header = 1 - RULE_version = 2 - RULE_include = 3 - RULE_testGroupDescription = 4 - RULE_testCase = 5 - RULE_testGroup = 6 - RULE_arguments = 7 - RULE_result = 8 - RULE_argument = 9 - RULE_numericLiteral = 10 - RULE_floatLiteral = 11 - RULE_nullArg = 12 - RULE_intArg = 13 - RULE_floatArg = 14 - RULE_decimalArg = 15 - RULE_booleanArg = 16 - RULE_stringArg = 17 - RULE_dateArg = 18 - RULE_timeArg = 19 - RULE_timestampArg = 20 - RULE_timestampTzArg = 21 - RULE_intervalYearArg = 22 - RULE_intervalDayArg = 23 - RULE_intervalYearLiteral = 24 - RULE_intervalDayLiteral = 25 - RULE_timeInterval = 26 - RULE_datatype = 27 - RULE_scalarType = 28 - RULE_fixedCharType = 29 - RULE_varCharType = 30 - RULE_fixedBinaryType = 31 - RULE_decimalType = 32 - RULE_precisionTimestampType = 33 - RULE_precisionTimestampTZType = 34 - RULE_parameterizedType = 35 - RULE_numericParameter = 36 - RULE_substraitError = 37 - RULE_func_option = 38 - RULE_option_name = 39 - RULE_option_value = 40 - RULE_func_options = 41 + def OParen(self): + return self.getToken(FuncTestCaseParser.OParen, 0) - ruleNames = [ - "doc", - "header", - "version", - "include", - "testGroupDescription", - "testCase", - "testGroup", - "arguments", - "result", - "argument", - "numericLiteral", - "floatLiteral", - "nullArg", - "intArg", - "floatArg", - "decimalArg", - "booleanArg", - "stringArg", - "dateArg", - "timeArg", - "timestampArg", - "timestampTzArg", - "intervalYearArg", - "intervalDayArg", - "intervalYearLiteral", - "intervalDayLiteral", - "timeInterval", - "datatype", - "scalarType", - "fixedCharType", - "varCharType", - "fixedBinaryType", - "decimalType", - "precisionTimestampType", - "precisionTimestampTZType", - "parameterizedType", - "numericParameter", - "substraitError", - "func_option", - "option_name", - "option_value", - "func_options", - ] + def dataColumn(self): + return self.getTypedRuleContext(FuncTestCaseParser.DataColumnContext, 0) - EOF = Token.EOF - Whitespace = 1 - TripleHash = 2 - SubstraitScalarTest = 3 - SubstraitInclude = 4 - FormatVersion = 5 - DescriptionLine = 6 - ErrorResult = 7 - UndefineResult = 8 - Overflow = 9 - Rounding = 10 - Error = 11 - Saturate = 12 - Silent = 13 - TieToEven = 14 - NaN = 15 - IntegerLiteral = 16 - DecimalLiteral = 17 - FloatLiteral = 18 - BooleanLiteral = 19 - TimestampTzLiteral = 20 - TimestampLiteral = 21 - TimeLiteral = 22 - DateLiteral = 23 - PeriodPrefix = 24 - TimePrefix = 25 - YearPrefix = 26 - MSuffix = 27 - DaySuffix = 28 - HourSuffix = 29 - SecondSuffix = 30 - FractionalSecondSuffix = 31 - OAngleBracket = 32 - CAngleBracket = 33 - IntervalYearLiteral = 34 - IntervalDayLiteral = 35 - NullLiteral = 36 - StringLiteral = 37 - LineComment = 38 - BlockComment = 39 - If = 40 - Then = 41 - Else = 42 - Boolean = 43 - I8 = 44 - I16 = 45 - I32 = 46 - I64 = 47 - FP32 = 48 - FP64 = 49 - String = 50 - Binary = 51 - Timestamp = 52 - Timestamp_TZ = 53 - Date = 54 - Time = 55 - Interval_Year = 56 - Interval_Day = 57 - UUID = 58 - Decimal = 59 - Precision_Timestamp = 60 - Precision_Timestamp_TZ = 61 - FixedChar = 62 - VarChar = 63 - FixedBinary = 64 - Struct = 65 - NStruct = 66 - List = 67 - Map = 68 - UserDefined = 69 - Bool = 70 - Str = 71 - VBin = 72 - Ts = 73 - TsTZ = 74 - IYear = 75 - IDay = 76 - Dec = 77 - PTs = 78 - PTsTZ = 79 - FChar = 80 - VChar = 81 - FBin = 82 - Any = 83 - AnyVar = 84 - DoubleColon = 85 - Plus = 86 - Minus = 87 - Asterisk = 88 - ForwardSlash = 89 - Percent = 90 - Eq = 91 - Ne = 92 - Gte = 93 - Lte = 94 - Gt = 95 - Lt = 96 - Bang = 97 - OParen = 98 - CParen = 99 - OBracket = 100 - CBracket = 101 - Comma = 102 - Colon = 103 - QMark = 104 - Hash = 105 - Dot = 106 - And = 107 - Or = 108 - Assign = 109 - Number = 110 - Identifier = 111 - Newline = 112 + def CParen(self): + return self.getToken(FuncTestCaseParser.CParen, 0) + + def Identifier(self): + return self.getToken(FuncTestCaseParser.Identifier, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSingleArgAggregateFuncCall"): + listener.enterSingleArgAggregateFuncCall(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSingleArgAggregateFuncCall"): + listener.exitSingleArgAggregateFuncCall(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSingleArgAggregateFuncCall"): + return visitor.visitSingleArgAggregateFuncCall(self) + else: + return visitor.visitChildren(self) + + class MultiArgAggregateFuncCallContext(AggFuncCallContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.AggFuncCallContext + super().__init__(parser) + self.funcName = None # Token + self.copyFrom(ctx) + + def tableData(self): + return self.getTypedRuleContext(FuncTestCaseParser.TableDataContext, 0) + + def OParen(self): + return self.getToken(FuncTestCaseParser.OParen, 0) + + def qualifiedAggregateFuncArgs(self): + return self.getTypedRuleContext( + FuncTestCaseParser.QualifiedAggregateFuncArgsContext, 0 + ) + + def CParen(self): + return self.getToken(FuncTestCaseParser.CParen, 0) + + def Identifier(self): + return self.getToken(FuncTestCaseParser.Identifier, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMultiArgAggregateFuncCall"): + listener.enterMultiArgAggregateFuncCall(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMultiArgAggregateFuncCall"): + listener.exitMultiArgAggregateFuncCall(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMultiArgAggregateFuncCall"): + return visitor.visitMultiArgAggregateFuncCall(self) + else: + return visitor.visitChildren(self) + + class CompactAggregateFuncCallContext(AggFuncCallContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.AggFuncCallContext + super().__init__(parser) + self.functName = None # Token + self.copyFrom(ctx) + + def tableRows(self): + return self.getTypedRuleContext(FuncTestCaseParser.TableRowsContext, 0) + + def OParen(self): + return self.getToken(FuncTestCaseParser.OParen, 0) + + def aggregateFuncArgs(self): + return self.getTypedRuleContext( + FuncTestCaseParser.AggregateFuncArgsContext, 0 + ) + + def CParen(self): + return self.getToken(FuncTestCaseParser.CParen, 0) + + def Identifier(self): + return self.getToken(FuncTestCaseParser.Identifier, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterCompactAggregateFuncCall"): + listener.enterCompactAggregateFuncCall(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitCompactAggregateFuncCall"): + listener.exitCompactAggregateFuncCall(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCompactAggregateFuncCall"): + return visitor.visitCompactAggregateFuncCall(self) + else: + return visitor.visitChildren(self) + + def aggFuncCall(self): + localctx = FuncTestCaseParser.AggFuncCallContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_aggFuncCall) + try: + self.state = 215 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [8]: + localctx = FuncTestCaseParser.MultiArgAggregateFuncCallContext( + self, localctx + ) + self.enterOuterAlt(localctx, 1) + self.state = 198 + self.tableData() + self.state = 199 + localctx.funcName = self.match(FuncTestCaseParser.Identifier) + self.state = 200 + self.match(FuncTestCaseParser.OParen) + self.state = 201 + self.qualifiedAggregateFuncArgs() + self.state = 202 + self.match(FuncTestCaseParser.CParen) + pass + elif token in [101]: + localctx = FuncTestCaseParser.CompactAggregateFuncCallContext( + self, localctx + ) + self.enterOuterAlt(localctx, 2) + self.state = 204 + self.tableRows() + self.state = 205 + localctx.functName = self.match(FuncTestCaseParser.Identifier) + self.state = 206 + self.match(FuncTestCaseParser.OParen) + self.state = 207 + self.aggregateFuncArgs() + self.state = 208 + self.match(FuncTestCaseParser.CParen) + pass + elif token in [114]: + localctx = FuncTestCaseParser.SingleArgAggregateFuncCallContext( + self, localctx + ) + self.enterOuterAlt(localctx, 3) + self.state = 210 + localctx.functName = self.match(FuncTestCaseParser.Identifier) + self.state = 211 + self.match(FuncTestCaseParser.OParen) + self.state = 212 + self.dataColumn() + self.state = 213 + self.match(FuncTestCaseParser.CParen) + pass + else: + raise NoViableAltException(self) - def __init__(self, input: TokenStream, output: TextIO = sys.stdout): - super().__init__(input, output) - self.checkVersion("4.13.2") - self._interp = ParserATNSimulator( - self, self.atn, self.decisionsToDFA, self.sharedContextCache - ) - self._predicates = None + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx - class DocContext(ParserRuleContext): + class TableDataContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -3756,58 +6237,87 @@ def __init__( ): super().__init__(parent, invokingState) self.parser = parser + self.tableName = None # Token - def header(self): - return self.getTypedRuleContext(FuncTestCaseParser.HeaderContext, 0) + def Define(self): + return self.getToken(FuncTestCaseParser.Define, 0) - def EOF(self): - return self.getToken(FuncTestCaseParser.EOF, 0) + def OParen(self): + return self.getToken(FuncTestCaseParser.OParen, 0) - def testGroup(self, i: int = None): + def dataType(self, i: int = None): if i is None: - return self.getTypedRuleContexts(FuncTestCaseParser.TestGroupContext) + return self.getTypedRuleContexts(FuncTestCaseParser.DataTypeContext) else: - return self.getTypedRuleContext(FuncTestCaseParser.TestGroupContext, i) + return self.getTypedRuleContext(FuncTestCaseParser.DataTypeContext, i) + + def CParen(self): + return self.getToken(FuncTestCaseParser.CParen, 0) + + def Eq(self): + return self.getToken(FuncTestCaseParser.Eq, 0) + + def tableRows(self): + return self.getTypedRuleContext(FuncTestCaseParser.TableRowsContext, 0) + + def Identifier(self): + return self.getToken(FuncTestCaseParser.Identifier, 0) + + def Comma(self, i: int = None): + if i is None: + return self.getTokens(FuncTestCaseParser.Comma) + else: + return self.getToken(FuncTestCaseParser.Comma, i) def getRuleIndex(self): - return FuncTestCaseParser.RULE_doc + return FuncTestCaseParser.RULE_tableData def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDoc"): - listener.enterDoc(self) + if hasattr(listener, "enterTableData"): + listener.enterTableData(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDoc"): - listener.exitDoc(self) + if hasattr(listener, "exitTableData"): + listener.exitTableData(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitDoc"): - return visitor.visitDoc(self) + if hasattr(visitor, "visitTableData"): + return visitor.visitTableData(self) else: return visitor.visitChildren(self) - def doc(self): - localctx = FuncTestCaseParser.DocContext(self, self._ctx, self.state) - self.enterRule(localctx, 0, self.RULE_doc) + def tableData(self): + localctx = FuncTestCaseParser.TableDataContext(self, self._ctx, self.state) + self.enterRule(localctx, 24, self.RULE_tableData) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 84 - self.header() - self.state = 86 + self.state = 217 + self.match(FuncTestCaseParser.Define) + self.state = 218 + localctx.tableName = self.match(FuncTestCaseParser.Identifier) + self.state = 219 + self.match(FuncTestCaseParser.OParen) + self.state = 220 + self.dataType() + self.state = 225 self._errHandler.sync(self) _la = self._input.LA(1) - while True: - self.state = 85 - self.testGroup() - self.state = 88 + while _la == 105: + self.state = 221 + self.match(FuncTestCaseParser.Comma) + self.state = 222 + self.dataType() + self.state = 227 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la == 6): - break - self.state = 90 - self.match(FuncTestCaseParser.EOF) + self.state = 228 + self.match(FuncTestCaseParser.CParen) + self.state = 229 + self.match(FuncTestCaseParser.Eq) + self.state = 230 + self.tableRows() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3816,7 +6326,7 @@ def doc(self): self.exitRule() return localctx - class HeaderContext(ParserRuleContext): + class TableRowsContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -3825,38 +6335,73 @@ def __init__( super().__init__(parent, invokingState) self.parser = parser - def version(self): - return self.getTypedRuleContext(FuncTestCaseParser.VersionContext, 0) + def OParen(self): + return self.getToken(FuncTestCaseParser.OParen, 0) - def include(self): - return self.getTypedRuleContext(FuncTestCaseParser.IncludeContext, 0) + def CParen(self): + return self.getToken(FuncTestCaseParser.CParen, 0) + + def literalValueList(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + FuncTestCaseParser.LiteralValueListContext + ) + else: + return self.getTypedRuleContext( + FuncTestCaseParser.LiteralValueListContext, i + ) + + def Comma(self, i: int = None): + if i is None: + return self.getTokens(FuncTestCaseParser.Comma) + else: + return self.getToken(FuncTestCaseParser.Comma, i) def getRuleIndex(self): - return FuncTestCaseParser.RULE_header + return FuncTestCaseParser.RULE_tableRows def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterHeader"): - listener.enterHeader(self) + if hasattr(listener, "enterTableRows"): + listener.enterTableRows(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitHeader"): - listener.exitHeader(self) + if hasattr(listener, "exitTableRows"): + listener.exitTableRows(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitHeader"): - return visitor.visitHeader(self) + if hasattr(visitor, "visitTableRows"): + return visitor.visitTableRows(self) else: return visitor.visitChildren(self) - def header(self): - localctx = FuncTestCaseParser.HeaderContext(self, self._ctx, self.state) - self.enterRule(localctx, 2, self.RULE_header) + def tableRows(self): + localctx = FuncTestCaseParser.TableRowsContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_tableRows) + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 92 - self.version() - self.state = 93 - self.include() + self.state = 232 + self.match(FuncTestCaseParser.OParen) + self.state = 241 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 101: + self.state = 233 + self.literalValueList() + self.state = 238 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 105: + self.state = 234 + self.match(FuncTestCaseParser.Comma) + self.state = 235 + self.literalValueList() + self.state = 240 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 243 + self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3865,7 +6410,7 @@ def header(self): self.exitRule() return localctx - class VersionContext(ParserRuleContext): + class DataColumnContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -3874,48 +6419,45 @@ def __init__( super().__init__(parent, invokingState) self.parser = parser - def TripleHash(self): - return self.getToken(FuncTestCaseParser.TripleHash, 0) - - def SubstraitScalarTest(self): - return self.getToken(FuncTestCaseParser.SubstraitScalarTest, 0) + def literalValueList(self): + return self.getTypedRuleContext( + FuncTestCaseParser.LiteralValueListContext, 0 + ) - def Colon(self): - return self.getToken(FuncTestCaseParser.Colon, 0) + def DoubleColon(self): + return self.getToken(FuncTestCaseParser.DoubleColon, 0) - def FormatVersion(self): - return self.getToken(FuncTestCaseParser.FormatVersion, 0) + def dataType(self): + return self.getTypedRuleContext(FuncTestCaseParser.DataTypeContext, 0) def getRuleIndex(self): - return FuncTestCaseParser.RULE_version + return FuncTestCaseParser.RULE_dataColumn def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterVersion"): - listener.enterVersion(self) + if hasattr(listener, "enterDataColumn"): + listener.enterDataColumn(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitVersion"): - listener.exitVersion(self) + if hasattr(listener, "exitDataColumn"): + listener.exitDataColumn(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitVersion"): - return visitor.visitVersion(self) + if hasattr(visitor, "visitDataColumn"): + return visitor.visitDataColumn(self) else: return visitor.visitChildren(self) - def version(self): - localctx = FuncTestCaseParser.VersionContext(self, self._ctx, self.state) - self.enterRule(localctx, 4, self.RULE_version) + def dataColumn(self): + localctx = FuncTestCaseParser.DataColumnContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_dataColumn) try: self.enterOuterAlt(localctx, 1) - self.state = 95 - self.match(FuncTestCaseParser.TripleHash) - self.state = 96 - self.match(FuncTestCaseParser.SubstraitScalarTest) - self.state = 97 - self.match(FuncTestCaseParser.Colon) - self.state = 98 - self.match(FuncTestCaseParser.FormatVersion) + self.state = 245 + self.literalValueList() + self.state = 246 + self.match(FuncTestCaseParser.DoubleColon) + self.state = 247 + self.dataType() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3924,7 +6466,7 @@ def version(self): self.exitRule() return localctx - class IncludeContext(ParserRuleContext): + class LiteralValueListContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -3933,20 +6475,17 @@ def __init__( super().__init__(parent, invokingState) self.parser = parser - def TripleHash(self): - return self.getToken(FuncTestCaseParser.TripleHash, 0) - - def SubstraitInclude(self): - return self.getToken(FuncTestCaseParser.SubstraitInclude, 0) + def OParen(self): + return self.getToken(FuncTestCaseParser.OParen, 0) - def Colon(self): - return self.getToken(FuncTestCaseParser.Colon, 0) + def CParen(self): + return self.getToken(FuncTestCaseParser.CParen, 0) - def StringLiteral(self, i: int = None): + def literal(self, i: int = None): if i is None: - return self.getTokens(FuncTestCaseParser.StringLiteral) + return self.getTypedRuleContexts(FuncTestCaseParser.LiteralContext) else: - return self.getToken(FuncTestCaseParser.StringLiteral, i) + return self.getTypedRuleContext(FuncTestCaseParser.LiteralContext, i) def Comma(self, i: int = None): if i is None: @@ -3955,48 +6494,52 @@ def Comma(self, i: int = None): return self.getToken(FuncTestCaseParser.Comma, i) def getRuleIndex(self): - return FuncTestCaseParser.RULE_include + return FuncTestCaseParser.RULE_literalValueList def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterInclude"): - listener.enterInclude(self) + if hasattr(listener, "enterLiteralValueList"): + listener.enterLiteralValueList(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitInclude"): - listener.exitInclude(self) + if hasattr(listener, "exitLiteralValueList"): + listener.exitLiteralValueList(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitInclude"): - return visitor.visitInclude(self) + if hasattr(visitor, "visitLiteralValueList"): + return visitor.visitLiteralValueList(self) else: return visitor.visitChildren(self) - def include(self): - localctx = FuncTestCaseParser.IncludeContext(self, self._ctx, self.state) - self.enterRule(localctx, 6, self.RULE_include) + def literalValueList(self): + localctx = FuncTestCaseParser.LiteralValueListContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 30, self.RULE_literalValueList) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 100 - self.match(FuncTestCaseParser.TripleHash) - self.state = 101 - self.match(FuncTestCaseParser.SubstraitInclude) - self.state = 102 - self.match(FuncTestCaseParser.Colon) - self.state = 103 - self.match(FuncTestCaseParser.StringLiteral) - self.state = 108 + self.state = 249 + self.match(FuncTestCaseParser.OParen) + self.state = 258 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == 102: - self.state = 104 - self.match(FuncTestCaseParser.Comma) - self.state = 105 - self.match(FuncTestCaseParser.StringLiteral) - self.state = 110 + if ((_la) & ~0x3F) == 0 and ((1 << _la) & 1030859128832) != 0: + self.state = 250 + self.literal() + self.state = 255 self._errHandler.sync(self) _la = self._input.LA(1) - + while _la == 105: + self.state = 251 + self.match(FuncTestCaseParser.Comma) + self.state = 252 + self.literal() + self.state = 257 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 260 + self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4005,7 +6548,7 @@ def include(self): self.exitRule() return localctx - class TestGroupDescriptionContext(ParserRuleContext): + class LiteralContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -4014,126 +6557,113 @@ def __init__( super().__init__(parent, invokingState) self.parser = parser - def DescriptionLine(self): - return self.getToken(FuncTestCaseParser.DescriptionLine, 0) - - def getRuleIndex(self): - return FuncTestCaseParser.RULE_testGroupDescription - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTestGroupDescription"): - listener.enterTestGroupDescription(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTestGroupDescription"): - listener.exitTestGroupDescription(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTestGroupDescription"): - return visitor.visitTestGroupDescription(self) - else: - return visitor.visitChildren(self) - - def testGroupDescription(self): - localctx = FuncTestCaseParser.TestGroupDescriptionContext( - self, self._ctx, self.state - ) - self.enterRule(localctx, 8, self.RULE_testGroupDescription) - try: - self.enterOuterAlt(localctx, 1) - self.state = 111 - self.match(FuncTestCaseParser.DescriptionLine) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class TestCaseContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - self.functionName = None # Token + def NullLiteral(self): + return self.getToken(FuncTestCaseParser.NullLiteral, 0) - def OParen(self): - return self.getToken(FuncTestCaseParser.OParen, 0) + def numericLiteral(self): + return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext, 0) - def arguments(self): - return self.getTypedRuleContext(FuncTestCaseParser.ArgumentsContext, 0) + def BooleanLiteral(self): + return self.getToken(FuncTestCaseParser.BooleanLiteral, 0) - def CParen(self): - return self.getToken(FuncTestCaseParser.CParen, 0) + def StringLiteral(self): + return self.getToken(FuncTestCaseParser.StringLiteral, 0) - def Eq(self): - return self.getToken(FuncTestCaseParser.Eq, 0) + def DateLiteral(self): + return self.getToken(FuncTestCaseParser.DateLiteral, 0) - def result(self): - return self.getTypedRuleContext(FuncTestCaseParser.ResultContext, 0) + def TimeLiteral(self): + return self.getToken(FuncTestCaseParser.TimeLiteral, 0) - def Identifier(self): - return self.getToken(FuncTestCaseParser.Identifier, 0) + def TimestampLiteral(self): + return self.getToken(FuncTestCaseParser.TimestampLiteral, 0) - def OBracket(self): - return self.getToken(FuncTestCaseParser.OBracket, 0) + def TimestampTzLiteral(self): + return self.getToken(FuncTestCaseParser.TimestampTzLiteral, 0) - def func_options(self): - return self.getTypedRuleContext(FuncTestCaseParser.Func_optionsContext, 0) + def IntervalYearLiteral(self): + return self.getToken(FuncTestCaseParser.IntervalYearLiteral, 0) - def CBracket(self): - return self.getToken(FuncTestCaseParser.CBracket, 0) + def IntervalDayLiteral(self): + return self.getToken(FuncTestCaseParser.IntervalDayLiteral, 0) def getRuleIndex(self): - return FuncTestCaseParser.RULE_testCase + return FuncTestCaseParser.RULE_literal def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTestCase"): - listener.enterTestCase(self) + if hasattr(listener, "enterLiteral"): + listener.enterLiteral(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTestCase"): - listener.exitTestCase(self) + if hasattr(listener, "exitLiteral"): + listener.exitLiteral(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTestCase"): - return visitor.visitTestCase(self) + if hasattr(visitor, "visitLiteral"): + return visitor.visitLiteral(self) else: return visitor.visitChildren(self) - def testCase(self): - localctx = FuncTestCaseParser.TestCaseContext(self, self._ctx, self.state) - self.enterRule(localctx, 10, self.RULE_testCase) - self._la = 0 # Token type + def literal(self): + localctx = FuncTestCaseParser.LiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 32, self.RULE_literal) try: - self.enterOuterAlt(localctx, 1) - self.state = 113 - localctx.functionName = self.match(FuncTestCaseParser.Identifier) - self.state = 114 - self.match(FuncTestCaseParser.OParen) - self.state = 115 - self.arguments() - self.state = 116 - self.match(FuncTestCaseParser.CParen) - self.state = 121 + self.state = 272 self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 100: - self.state = 117 - self.match(FuncTestCaseParser.OBracket) - self.state = 118 - self.func_options() - self.state = 119 - self.match(FuncTestCaseParser.CBracket) + token = self._input.LA(1) + if token in [38]: + self.enterOuterAlt(localctx, 1) + self.state = 262 + self.match(FuncTestCaseParser.NullLiteral) + pass + elif token in [17, 18, 19, 20]: + self.enterOuterAlt(localctx, 2) + self.state = 263 + self.numericLiteral() + pass + elif token in [21]: + self.enterOuterAlt(localctx, 3) + self.state = 264 + self.match(FuncTestCaseParser.BooleanLiteral) + pass + elif token in [39]: + self.enterOuterAlt(localctx, 4) + self.state = 265 + self.match(FuncTestCaseParser.StringLiteral) + pass + elif token in [25]: + self.enterOuterAlt(localctx, 5) + self.state = 266 + self.match(FuncTestCaseParser.DateLiteral) + pass + elif token in [24]: + self.enterOuterAlt(localctx, 6) + self.state = 267 + self.match(FuncTestCaseParser.TimeLiteral) + pass + elif token in [23]: + self.enterOuterAlt(localctx, 7) + self.state = 268 + self.match(FuncTestCaseParser.TimestampLiteral) + pass + elif token in [22]: + self.enterOuterAlt(localctx, 8) + self.state = 269 + self.match(FuncTestCaseParser.TimestampTzLiteral) + pass + elif token in [36]: + self.enterOuterAlt(localctx, 9) + self.state = 270 + self.match(FuncTestCaseParser.IntervalYearLiteral) + pass + elif token in [37]: + self.enterOuterAlt(localctx, 10) + self.state = 271 + self.match(FuncTestCaseParser.IntervalDayLiteral) + pass + else: + raise NoViableAltException(self) - self.state = 123 - self.match(FuncTestCaseParser.Eq) - self.state = 124 - self.result() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4142,7 +6672,7 @@ def testCase(self): self.exitRule() return localctx - class TestGroupContext(ParserRuleContext): + class QualifiedAggregateFuncArgsContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -4151,53 +6681,60 @@ def __init__( super().__init__(parent, invokingState) self.parser = parser - def testGroupDescription(self): - return self.getTypedRuleContext( - FuncTestCaseParser.TestGroupDescriptionContext, 0 - ) + def qualifiedAggregateFuncArg(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + FuncTestCaseParser.QualifiedAggregateFuncArgContext + ) + else: + return self.getTypedRuleContext( + FuncTestCaseParser.QualifiedAggregateFuncArgContext, i + ) - def testCase(self, i: int = None): + def Comma(self, i: int = None): if i is None: - return self.getTypedRuleContexts(FuncTestCaseParser.TestCaseContext) + return self.getTokens(FuncTestCaseParser.Comma) else: - return self.getTypedRuleContext(FuncTestCaseParser.TestCaseContext, i) + return self.getToken(FuncTestCaseParser.Comma, i) def getRuleIndex(self): - return FuncTestCaseParser.RULE_testGroup + return FuncTestCaseParser.RULE_qualifiedAggregateFuncArgs def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTestGroup"): - listener.enterTestGroup(self) + if hasattr(listener, "enterQualifiedAggregateFuncArgs"): + listener.enterQualifiedAggregateFuncArgs(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTestGroup"): - listener.exitTestGroup(self) + if hasattr(listener, "exitQualifiedAggregateFuncArgs"): + listener.exitQualifiedAggregateFuncArgs(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTestGroup"): - return visitor.visitTestGroup(self) + if hasattr(visitor, "visitQualifiedAggregateFuncArgs"): + return visitor.visitQualifiedAggregateFuncArgs(self) else: return visitor.visitChildren(self) - def testGroup(self): - localctx = FuncTestCaseParser.TestGroupContext(self, self._ctx, self.state) - self.enterRule(localctx, 12, self.RULE_testGroup) + def qualifiedAggregateFuncArgs(self): + localctx = FuncTestCaseParser.QualifiedAggregateFuncArgsContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 34, self.RULE_qualifiedAggregateFuncArgs) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 126 - self.testGroupDescription() - self.state = 128 + self.state = 274 + self.qualifiedAggregateFuncArg() + self.state = 279 self._errHandler.sync(self) _la = self._input.LA(1) - while True: - self.state = 127 - self.testCase() - self.state = 130 + while _la == 105: + self.state = 275 + self.match(FuncTestCaseParser.Comma) + self.state = 276 + self.qualifiedAggregateFuncArg() + self.state = 281 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la == 111): - break except RecognitionException as re: localctx.exception = re @@ -4207,7 +6744,7 @@ def testGroup(self): self.exitRule() return localctx - class ArgumentsContext(ParserRuleContext): + class AggregateFuncArgsContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -4216,11 +6753,15 @@ def __init__( super().__init__(parent, invokingState) self.parser = parser - def argument(self, i: int = None): + def aggregateFuncArg(self, i: int = None): if i is None: - return self.getTypedRuleContexts(FuncTestCaseParser.ArgumentContext) + return self.getTypedRuleContexts( + FuncTestCaseParser.AggregateFuncArgContext + ) else: - return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext, i) + return self.getTypedRuleContext( + FuncTestCaseParser.AggregateFuncArgContext, i + ) def Comma(self, i: int = None): if i is None: @@ -4229,39 +6770,41 @@ def Comma(self, i: int = None): return self.getToken(FuncTestCaseParser.Comma, i) def getRuleIndex(self): - return FuncTestCaseParser.RULE_arguments + return FuncTestCaseParser.RULE_aggregateFuncArgs def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterArguments"): - listener.enterArguments(self) + if hasattr(listener, "enterAggregateFuncArgs"): + listener.enterAggregateFuncArgs(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitArguments"): - listener.exitArguments(self) + if hasattr(listener, "exitAggregateFuncArgs"): + listener.exitAggregateFuncArgs(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitArguments"): - return visitor.visitArguments(self) + if hasattr(visitor, "visitAggregateFuncArgs"): + return visitor.visitAggregateFuncArgs(self) else: return visitor.visitChildren(self) - def arguments(self): - localctx = FuncTestCaseParser.ArgumentsContext(self, self._ctx, self.state) - self.enterRule(localctx, 14, self.RULE_arguments) + def aggregateFuncArgs(self): + localctx = FuncTestCaseParser.AggregateFuncArgsContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 36, self.RULE_aggregateFuncArgs) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 132 - self.argument() - self.state = 137 + self.state = 282 + self.aggregateFuncArg() + self.state = 287 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == 102: - self.state = 133 + while _la == 105: + self.state = 283 self.match(FuncTestCaseParser.Comma) - self.state = 134 - self.argument() - self.state = 139 + self.state = 284 + self.aggregateFuncArg() + self.state = 289 self._errHandler.sync(self) _la = self._input.LA(1) @@ -4273,7 +6816,7 @@ def arguments(self): self.exitRule() return localctx - class ResultContext(ParserRuleContext): + class QualifiedAggregateFuncArgContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -4281,46 +6824,59 @@ def __init__( ): super().__init__(parent, invokingState) self.parser = parser + self.tableName = None # Token + + def Dot(self): + return self.getToken(FuncTestCaseParser.Dot, 0) + + def ColumnName(self): + return self.getToken(FuncTestCaseParser.ColumnName, 0) + + def Identifier(self): + return self.getToken(FuncTestCaseParser.Identifier, 0) def argument(self): return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext, 0) - def substraitError(self): - return self.getTypedRuleContext(FuncTestCaseParser.SubstraitErrorContext, 0) - def getRuleIndex(self): - return FuncTestCaseParser.RULE_result + return FuncTestCaseParser.RULE_qualifiedAggregateFuncArg def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterResult"): - listener.enterResult(self) + if hasattr(listener, "enterQualifiedAggregateFuncArg"): + listener.enterQualifiedAggregateFuncArg(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitResult"): - listener.exitResult(self) + if hasattr(listener, "exitQualifiedAggregateFuncArg"): + listener.exitQualifiedAggregateFuncArg(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitResult"): - return visitor.visitResult(self) + if hasattr(visitor, "visitQualifiedAggregateFuncArg"): + return visitor.visitQualifiedAggregateFuncArg(self) else: return visitor.visitChildren(self) - def result(self): - localctx = FuncTestCaseParser.ResultContext(self, self._ctx, self.state) - self.enterRule(localctx, 16, self.RULE_result) + def qualifiedAggregateFuncArg(self): + localctx = FuncTestCaseParser.QualifiedAggregateFuncArgContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 38, self.RULE_qualifiedAggregateFuncArg) try: - self.state = 142 + self.state = 294 self._errHandler.sync(self) token = self._input.LA(1) - if token in [15, 16, 17, 18, 19, 20, 21, 22, 23, 34, 35, 36, 37]: + if token in [114]: self.enterOuterAlt(localctx, 1) - self.state = 140 - self.argument() + self.state = 290 + localctx.tableName = self.match(FuncTestCaseParser.Identifier) + self.state = 291 + self.match(FuncTestCaseParser.Dot) + self.state = 292 + self.match(FuncTestCaseParser.ColumnName) pass - elif token in [7, 8]: + elif token in [17, 18, 19, 20, 21, 22, 23, 24, 25, 36, 37, 38, 39]: self.enterOuterAlt(localctx, 2) - self.state = 141 - self.substraitError() + self.state = 293 + self.argument() pass else: raise NoViableAltException(self) @@ -4333,7 +6889,7 @@ def result(self): self.exitRule() return localctx - class ArgumentContext(ParserRuleContext): + class AggregateFuncArgContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -4342,139 +6898,60 @@ def __init__( super().__init__(parent, invokingState) self.parser = parser - def nullArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.NullArgContext, 0) - - def intArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.IntArgContext, 0) - - def floatArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.FloatArgContext, 0) - - def booleanArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.BooleanArgContext, 0) - - def stringArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.StringArgContext, 0) - - def decimalArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.DecimalArgContext, 0) - - def dateArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.DateArgContext, 0) - - def timeArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.TimeArgContext, 0) - - def timestampArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.TimestampArgContext, 0) + def ColumnName(self): + return self.getToken(FuncTestCaseParser.ColumnName, 0) - def timestampTzArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.TimestampTzArgContext, 0) + def DoubleColon(self): + return self.getToken(FuncTestCaseParser.DoubleColon, 0) - def intervalYearArg(self): - return self.getTypedRuleContext( - FuncTestCaseParser.IntervalYearArgContext, 0 - ) + def dataType(self): + return self.getTypedRuleContext(FuncTestCaseParser.DataTypeContext, 0) - def intervalDayArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.IntervalDayArgContext, 0) + def argument(self): + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext, 0) def getRuleIndex(self): - return FuncTestCaseParser.RULE_argument + return FuncTestCaseParser.RULE_aggregateFuncArg def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterArgument"): - listener.enterArgument(self) + if hasattr(listener, "enterAggregateFuncArg"): + listener.enterAggregateFuncArg(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitArgument"): - listener.exitArgument(self) + if hasattr(listener, "exitAggregateFuncArg"): + listener.exitAggregateFuncArg(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitArgument"): - return visitor.visitArgument(self) + if hasattr(visitor, "visitAggregateFuncArg"): + return visitor.visitAggregateFuncArg(self) else: return visitor.visitChildren(self) - def argument(self): - localctx = FuncTestCaseParser.ArgumentContext(self, self._ctx, self.state) - self.enterRule(localctx, 18, self.RULE_argument) + def aggregateFuncArg(self): + localctx = FuncTestCaseParser.AggregateFuncArgContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 40, self.RULE_aggregateFuncArg) try: - self.state = 156 + self.state = 300 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 6, self._ctx) - if la_ == 1: + token = self._input.LA(1) + if token in [40]: self.enterOuterAlt(localctx, 1) - self.state = 144 - self.nullArg() + self.state = 296 + self.match(FuncTestCaseParser.ColumnName) + self.state = 297 + self.match(FuncTestCaseParser.DoubleColon) + self.state = 298 + self.dataType() pass - - elif la_ == 2: + elif token in [17, 18, 19, 20, 21, 22, 23, 24, 25, 36, 37, 38, 39]: self.enterOuterAlt(localctx, 2) - self.state = 145 - self.intArg() - pass - - elif la_ == 3: - self.enterOuterAlt(localctx, 3) - self.state = 146 - self.floatArg() - pass - - elif la_ == 4: - self.enterOuterAlt(localctx, 4) - self.state = 147 - self.booleanArg() - pass - - elif la_ == 5: - self.enterOuterAlt(localctx, 5) - self.state = 148 - self.stringArg() - pass - - elif la_ == 6: - self.enterOuterAlt(localctx, 6) - self.state = 149 - self.decimalArg() - pass - - elif la_ == 7: - self.enterOuterAlt(localctx, 7) - self.state = 150 - self.dateArg() - pass - - elif la_ == 8: - self.enterOuterAlt(localctx, 8) - self.state = 151 - self.timeArg() - pass - - elif la_ == 9: - self.enterOuterAlt(localctx, 9) - self.state = 152 - self.timestampArg() - pass - - elif la_ == 10: - self.enterOuterAlt(localctx, 10) - self.state = 153 - self.timestampTzArg() - pass - - elif la_ == 11: - self.enterOuterAlt(localctx, 11) - self.state = 154 - self.intervalYearArg() - pass - - elif la_ == 12: - self.enterOuterAlt(localctx, 12) - self.state = 155 - self.intervalDayArg() + self.state = 299 + self.argument() pass + else: + raise NoViableAltException(self) except RecognitionException as re: localctx.exception = re @@ -4521,24 +6998,24 @@ def accept(self, visitor: ParseTreeVisitor): def numericLiteral(self): localctx = FuncTestCaseParser.NumericLiteralContext(self, self._ctx, self.state) - self.enterRule(localctx, 20, self.RULE_numericLiteral) + self.enterRule(localctx, 42, self.RULE_numericLiteral) try: - self.state = 161 + self.state = 305 self._errHandler.sync(self) token = self._input.LA(1) - if token in [17]: + if token in [19]: self.enterOuterAlt(localctx, 1) - self.state = 158 + self.state = 302 self.match(FuncTestCaseParser.DecimalLiteral) pass - elif token in [16]: + elif token in [18]: self.enterOuterAlt(localctx, 2) - self.state = 159 + self.state = 303 self.match(FuncTestCaseParser.IntegerLiteral) pass - elif token in [15, 18]: + elif token in [17, 20]: self.enterOuterAlt(localctx, 3) - self.state = 160 + self.state = 304 self.floatLiteral() pass else: @@ -4586,13 +7063,13 @@ def accept(self, visitor: ParseTreeVisitor): def floatLiteral(self): localctx = FuncTestCaseParser.FloatLiteralContext(self, self._ctx, self.state) - self.enterRule(localctx, 22, self.RULE_floatLiteral) + self.enterRule(localctx, 44, self.RULE_floatLiteral) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 163 + self.state = 307 _la = self._input.LA(1) - if not (_la == 15 or _la == 18): + if not (_la == 17 or _la == 20): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4620,8 +7097,8 @@ def NullLiteral(self): def DoubleColon(self): return self.getToken(FuncTestCaseParser.DoubleColon, 0) - def datatype(self): - return self.getTypedRuleContext(FuncTestCaseParser.DatatypeContext, 0) + def dataType(self): + return self.getTypedRuleContext(FuncTestCaseParser.DataTypeContext, 0) def getRuleIndex(self): return FuncTestCaseParser.RULE_nullArg @@ -4642,15 +7119,15 @@ def accept(self, visitor: ParseTreeVisitor): def nullArg(self): localctx = FuncTestCaseParser.NullArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 24, self.RULE_nullArg) + self.enterRule(localctx, 46, self.RULE_nullArg) try: self.enterOuterAlt(localctx, 1) - self.state = 165 + self.state = 309 self.match(FuncTestCaseParser.NullLiteral) - self.state = 166 + self.state = 310 self.match(FuncTestCaseParser.DoubleColon) - self.state = 167 - self.datatype() + self.state = 311 + self.dataType() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4705,17 +7182,17 @@ def accept(self, visitor: ParseTreeVisitor): def intArg(self): localctx = FuncTestCaseParser.IntArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 26, self.RULE_intArg) + self.enterRule(localctx, 48, self.RULE_intArg) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 169 + self.state = 313 self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 170 + self.state = 314 self.match(FuncTestCaseParser.DoubleColon) - self.state = 171 + self.state = 315 _la = self._input.LA(1) - if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 263882790666240) != 0)): + if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 2111062325329920) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4768,17 +7245,17 @@ def accept(self, visitor: ParseTreeVisitor): def floatArg(self): localctx = FuncTestCaseParser.FloatArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 28, self.RULE_floatArg) + self.enterRule(localctx, 50, self.RULE_floatArg) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 173 + self.state = 317 self.numericLiteral() - self.state = 174 + self.state = 318 self.match(FuncTestCaseParser.DoubleColon) - self.state = 175 + self.state = 319 _la = self._input.LA(1) - if not (_la == 48 or _la == 49): + if not (_la == 51 or _la == 52): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4828,14 +7305,14 @@ def accept(self, visitor: ParseTreeVisitor): def decimalArg(self): localctx = FuncTestCaseParser.DecimalArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 30, self.RULE_decimalArg) + self.enterRule(localctx, 52, self.RULE_decimalArg) try: self.enterOuterAlt(localctx, 1) - self.state = 177 + self.state = 321 self.numericLiteral() - self.state = 178 + self.state = 322 self.match(FuncTestCaseParser.DoubleColon) - self.state = 179 + self.state = 323 self.decimalType() except RecognitionException as re: localctx.exception = re @@ -4863,6 +7340,9 @@ def DoubleColon(self): def Bool(self): return self.getToken(FuncTestCaseParser.Bool, 0) + def Boolean(self): + return self.getToken(FuncTestCaseParser.Boolean, 0) + def getRuleIndex(self): return FuncTestCaseParser.RULE_booleanArg @@ -4882,15 +7362,21 @@ def accept(self, visitor: ParseTreeVisitor): def booleanArg(self): localctx = FuncTestCaseParser.BooleanArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 32, self.RULE_booleanArg) + self.enterRule(localctx, 54, self.RULE_booleanArg) + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 181 + self.state = 325 self.match(FuncTestCaseParser.BooleanLiteral) - self.state = 182 + self.state = 326 self.match(FuncTestCaseParser.DoubleColon) - self.state = 183 - self.match(FuncTestCaseParser.Bool) + self.state = 327 + _la = self._input.LA(1) + if not (_la == 46 or _la == 73): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4917,6 +7403,9 @@ def DoubleColon(self): def Str(self): return self.getToken(FuncTestCaseParser.Str, 0) + def String(self): + return self.getToken(FuncTestCaseParser.String, 0) + def getRuleIndex(self): return FuncTestCaseParser.RULE_stringArg @@ -4936,15 +7425,21 @@ def accept(self, visitor: ParseTreeVisitor): def stringArg(self): localctx = FuncTestCaseParser.StringArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 34, self.RULE_stringArg) + self.enterRule(localctx, 56, self.RULE_stringArg) + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 185 + self.state = 329 self.match(FuncTestCaseParser.StringLiteral) - self.state = 186 + self.state = 330 self.match(FuncTestCaseParser.DoubleColon) - self.state = 187 - self.match(FuncTestCaseParser.Str) + self.state = 331 + _la = self._input.LA(1) + if not (_la == 53 or _la == 74): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -4990,14 +7485,14 @@ def accept(self, visitor: ParseTreeVisitor): def dateArg(self): localctx = FuncTestCaseParser.DateArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 36, self.RULE_dateArg) + self.enterRule(localctx, 58, self.RULE_dateArg) try: self.enterOuterAlt(localctx, 1) - self.state = 189 + self.state = 333 self.match(FuncTestCaseParser.DateLiteral) - self.state = 190 + self.state = 334 self.match(FuncTestCaseParser.DoubleColon) - self.state = 191 + self.state = 335 self.match(FuncTestCaseParser.Date) except RecognitionException as re: localctx.exception = re @@ -5044,14 +7539,14 @@ def accept(self, visitor: ParseTreeVisitor): def timeArg(self): localctx = FuncTestCaseParser.TimeArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 38, self.RULE_timeArg) + self.enterRule(localctx, 60, self.RULE_timeArg) try: self.enterOuterAlt(localctx, 1) - self.state = 193 + self.state = 337 self.match(FuncTestCaseParser.TimeLiteral) - self.state = 194 + self.state = 338 self.match(FuncTestCaseParser.DoubleColon) - self.state = 195 + self.state = 339 self.match(FuncTestCaseParser.Time) except RecognitionException as re: localctx.exception = re @@ -5079,6 +7574,9 @@ def DoubleColon(self): def Ts(self): return self.getToken(FuncTestCaseParser.Ts, 0) + def Timestamp(self): + return self.getToken(FuncTestCaseParser.Timestamp, 0) + def getRuleIndex(self): return FuncTestCaseParser.RULE_timestampArg @@ -5098,15 +7596,21 @@ def accept(self, visitor: ParseTreeVisitor): def timestampArg(self): localctx = FuncTestCaseParser.TimestampArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 40, self.RULE_timestampArg) + self.enterRule(localctx, 62, self.RULE_timestampArg) + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 197 + self.state = 341 self.match(FuncTestCaseParser.TimestampLiteral) - self.state = 198 + self.state = 342 self.match(FuncTestCaseParser.DoubleColon) - self.state = 199 - self.match(FuncTestCaseParser.Ts) + self.state = 343 + _la = self._input.LA(1) + if not (_la == 55 or _la == 76): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -5133,6 +7637,9 @@ def DoubleColon(self): def TsTZ(self): return self.getToken(FuncTestCaseParser.TsTZ, 0) + def Timestamp_TZ(self): + return self.getToken(FuncTestCaseParser.Timestamp_TZ, 0) + def getRuleIndex(self): return FuncTestCaseParser.RULE_timestampTzArg @@ -5152,15 +7659,21 @@ def accept(self, visitor: ParseTreeVisitor): def timestampTzArg(self): localctx = FuncTestCaseParser.TimestampTzArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 42, self.RULE_timestampTzArg) + self.enterRule(localctx, 64, self.RULE_timestampTzArg) + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 201 + self.state = 345 self.match(FuncTestCaseParser.TimestampTzLiteral) - self.state = 202 + self.state = 346 self.match(FuncTestCaseParser.DoubleColon) - self.state = 203 - self.match(FuncTestCaseParser.TsTZ) + self.state = 347 + _la = self._input.LA(1) + if not (_la == 56 or _la == 77): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -5187,6 +7700,9 @@ def DoubleColon(self): def IYear(self): return self.getToken(FuncTestCaseParser.IYear, 0) + def Interval_Year(self): + return self.getToken(FuncTestCaseParser.Interval_Year, 0) + def getRuleIndex(self): return FuncTestCaseParser.RULE_intervalYearArg @@ -5208,15 +7724,21 @@ def intervalYearArg(self): localctx = FuncTestCaseParser.IntervalYearArgContext( self, self._ctx, self.state ) - self.enterRule(localctx, 44, self.RULE_intervalYearArg) + self.enterRule(localctx, 66, self.RULE_intervalYearArg) + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 205 + self.state = 349 self.match(FuncTestCaseParser.IntervalYearLiteral) - self.state = 206 + self.state = 350 self.match(FuncTestCaseParser.DoubleColon) - self.state = 207 - self.match(FuncTestCaseParser.IYear) + self.state = 351 + _la = self._input.LA(1) + if not (_la == 59 or _la == 78): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -5243,6 +7765,9 @@ def DoubleColon(self): def IDay(self): return self.getToken(FuncTestCaseParser.IDay, 0) + def Interval_Day(self): + return self.getToken(FuncTestCaseParser.Interval_Day, 0) + def getRuleIndex(self): return FuncTestCaseParser.RULE_intervalDayArg @@ -5262,15 +7787,21 @@ def accept(self, visitor: ParseTreeVisitor): def intervalDayArg(self): localctx = FuncTestCaseParser.IntervalDayArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 46, self.RULE_intervalDayArg) + self.enterRule(localctx, 68, self.RULE_intervalDayArg) + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 209 + self.state = 353 self.match(FuncTestCaseParser.IntervalDayLiteral) - self.state = 210 + self.state = 354 self.match(FuncTestCaseParser.DoubleColon) - self.state = 211 - self.match(FuncTestCaseParser.IDay) + self.state = 355 + _la = self._input.LA(1) + if not (_la == 60 or _la == 79): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -5326,40 +7857,40 @@ def intervalYearLiteral(self): localctx = FuncTestCaseParser.IntervalYearLiteralContext( self, self._ctx, self.state ) - self.enterRule(localctx, 48, self.RULE_intervalYearLiteral) + self.enterRule(localctx, 70, self.RULE_intervalYearLiteral) self._la = 0 # Token type try: - self.state = 224 + self.state = 368 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 9, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 23, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 213 + self.state = 357 self.match(FuncTestCaseParser.PeriodPrefix) - self.state = 214 + self.state = 358 localctx.years = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 215 + self.state = 359 self.match(FuncTestCaseParser.YearPrefix) - self.state = 219 + self.state = 363 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 16: - self.state = 217 + if _la == 18: + self.state = 361 localctx.months = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 218 + self.state = 362 self.match(FuncTestCaseParser.MSuffix) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 221 + self.state = 365 self.match(FuncTestCaseParser.PeriodPrefix) - self.state = 222 + self.state = 366 localctx.months = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 223 + self.state = 367 self.match(FuncTestCaseParser.MSuffix) pass @@ -5417,39 +7948,39 @@ def intervalDayLiteral(self): localctx = FuncTestCaseParser.IntervalDayLiteralContext( self, self._ctx, self.state ) - self.enterRule(localctx, 50, self.RULE_intervalDayLiteral) + self.enterRule(localctx, 72, self.RULE_intervalDayLiteral) self._la = 0 # Token type try: - self.state = 237 + self.state = 381 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 11, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 25, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 226 + self.state = 370 self.match(FuncTestCaseParser.PeriodPrefix) - self.state = 227 + self.state = 371 localctx.days = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 228 + self.state = 372 self.match(FuncTestCaseParser.DaySuffix) - self.state = 232 + self.state = 376 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 25: - self.state = 230 + if _la == 27: + self.state = 374 self.match(FuncTestCaseParser.TimePrefix) - self.state = 231 + self.state = 375 self.timeInterval() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 234 + self.state = 378 self.match(FuncTestCaseParser.PeriodPrefix) - self.state = 235 + self.state = 379 self.match(FuncTestCaseParser.TimePrefix) - self.state = 236 + self.state = 380 self.timeInterval() pass @@ -5511,103 +8042,103 @@ def accept(self, visitor: ParseTreeVisitor): def timeInterval(self): localctx = FuncTestCaseParser.TimeIntervalContext(self, self._ctx, self.state) - self.enterRule(localctx, 52, self.RULE_timeInterval) + self.enterRule(localctx, 74, self.RULE_timeInterval) self._la = 0 # Token type try: - self.state = 271 + self.state = 415 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 18, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 32, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 239 + self.state = 383 localctx.hours = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 240 + self.state = 384 self.match(FuncTestCaseParser.HourSuffix) - self.state = 243 + self.state = 387 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 12, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 26, self._ctx) if la_ == 1: - self.state = 241 + self.state = 385 localctx.minutes = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 242 + self.state = 386 self.match(FuncTestCaseParser.MSuffix) - self.state = 247 + self.state = 391 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 13, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 27, self._ctx) if la_ == 1: - self.state = 245 + self.state = 389 localctx.seconds = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 246 + self.state = 390 self.match(FuncTestCaseParser.SecondSuffix) - self.state = 251 + self.state = 395 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 16: - self.state = 249 + if _la == 18: + self.state = 393 localctx.fractionalSeconds = self.match( FuncTestCaseParser.IntegerLiteral ) - self.state = 250 + self.state = 394 self.match(FuncTestCaseParser.FractionalSecondSuffix) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 253 + self.state = 397 localctx.minutes = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 254 + self.state = 398 self.match(FuncTestCaseParser.MSuffix) - self.state = 257 + self.state = 401 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 15, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 29, self._ctx) if la_ == 1: - self.state = 255 + self.state = 399 localctx.seconds = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 256 + self.state = 400 self.match(FuncTestCaseParser.SecondSuffix) - self.state = 261 + self.state = 405 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 16: - self.state = 259 + if _la == 18: + self.state = 403 localctx.fractionalSeconds = self.match( FuncTestCaseParser.IntegerLiteral ) - self.state = 260 + self.state = 404 self.match(FuncTestCaseParser.FractionalSecondSuffix) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) - self.state = 263 + self.state = 407 localctx.seconds = self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 264 + self.state = 408 self.match(FuncTestCaseParser.SecondSuffix) - self.state = 267 + self.state = 411 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 16: - self.state = 265 + if _la == 18: + self.state = 409 localctx.fractionalSeconds = self.match( FuncTestCaseParser.IntegerLiteral ) - self.state = 266 + self.state = 410 self.match(FuncTestCaseParser.FractionalSecondSuffix) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) - self.state = 269 + self.state = 413 localctx.fractionalSeconds = self.match( FuncTestCaseParser.IntegerLiteral ) - self.state = 270 + self.state = 414 self.match(FuncTestCaseParser.FractionalSecondSuffix) pass @@ -5619,7 +8150,7 @@ def timeInterval(self): self.exitRule() return localctx - class DatatypeContext(ParserRuleContext): + class DataTypeContext(ParserRuleContext): __slots__ = "parser" def __init__( @@ -5637,55 +8168,62 @@ def parameterizedType(self): ) def getRuleIndex(self): - return FuncTestCaseParser.RULE_datatype + return FuncTestCaseParser.RULE_dataType def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDatatype"): - listener.enterDatatype(self) + if hasattr(listener, "enterDataType"): + listener.enterDataType(self) def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDatatype"): - listener.exitDatatype(self) + if hasattr(listener, "exitDataType"): + listener.exitDataType(self) def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitDatatype"): - return visitor.visitDatatype(self) + if hasattr(visitor, "visitDataType"): + return visitor.visitDataType(self) else: return visitor.visitChildren(self) - def datatype(self): - localctx = FuncTestCaseParser.DatatypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 54, self.RULE_datatype) + def dataType(self): + localctx = FuncTestCaseParser.DataTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 76, self.RULE_dataType) try: - self.state = 275 + self.state = 419 self._errHandler.sync(self) token = self._input.LA(1) if token in [ - 44, - 45, 46, 47, 48, 49, + 50, 51, + 52, + 53, 54, 55, + 56, + 57, 58, - 69, - 70, - 71, + 59, + 60, + 61, + 72, 73, 74, 75, 76, + 77, + 78, + 79, ]: self.enterOuterAlt(localctx, 1) - self.state = 273 + self.state = 417 self.scalarType() pass - elif token in [77, 78, 79, 80, 81, 82]: + elif token in [62, 63, 64, 65, 66, 67, 80, 81, 82, 83, 84, 85]: self.enterOuterAlt(localctx, 2) - self.state = 274 + self.state = 418 self.parameterizedType() pass else: @@ -5748,6 +8286,9 @@ def __init__( def Str(self): return self.getToken(FuncTestCaseParser.Str, 0) + def String(self): + return self.getToken(FuncTestCaseParser.String, 0) + def enterRule(self, listener: ParseTreeListener): if hasattr(listener, "enterString"): listener.enterString(self) @@ -5847,6 +8388,9 @@ def __init__( def IYear(self): return self.getToken(FuncTestCaseParser.IYear, 0) + def Interval_Day(self): + return self.getToken(FuncTestCaseParser.Interval_Day, 0) + def enterRule(self, listener: ParseTreeListener): if hasattr(listener, "enterIntervalYear"): listener.enterIntervalYear(self) @@ -5933,6 +8477,33 @@ def accept(self, visitor: ParseTreeVisitor): else: return visitor.visitChildren(self) + class BooleanContext(ScalarTypeContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Bool(self): + return self.getToken(FuncTestCaseParser.Bool, 0) + + def Boolean(self): + return self.getToken(FuncTestCaseParser.Boolean, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBoolean"): + listener.enterBoolean(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBoolean"): + listener.exitBoolean(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBoolean"): + return visitor.visitBoolean(self) + else: + return visitor.visitChildren(self) + class BinaryContext(ScalarTypeContext): def __init__( self, parser, ctx: ParserRuleContext @@ -5943,6 +8514,9 @@ def __init__( def Binary(self): return self.getToken(FuncTestCaseParser.Binary, 0) + def VBin(self): + return self.getToken(FuncTestCaseParser.VBin, 0) + def enterRule(self, listener: ParseTreeListener): if hasattr(listener, "enterBinary"): listener.enterBinary(self) @@ -5967,6 +8541,9 @@ def __init__( def IDay(self): return self.getToken(FuncTestCaseParser.IDay, 0) + def Interval_Year(self): + return self.getToken(FuncTestCaseParser.Interval_Year, 0) + def enterRule(self, listener: ParseTreeListener): if hasattr(listener, "enterIntervalDay"): listener.enterIntervalDay(self) @@ -6053,30 +8630,6 @@ def accept(self, visitor: ParseTreeVisitor): else: return visitor.visitChildren(self) - class BooleanContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a FuncTestCaseParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def Bool(self): - return self.getToken(FuncTestCaseParser.Bool, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBoolean"): - listener.enterBoolean(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBoolean"): - listener.exitBoolean(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitBoolean"): - return visitor.visitBoolean(self) - else: - return visitor.visitChildren(self) - class TimestampContext(ScalarTypeContext): def __init__( self, parser, ctx: ParserRuleContext @@ -6087,6 +8640,9 @@ def __init__( def Ts(self): return self.getToken(FuncTestCaseParser.Ts, 0) + def Timestamp(self): + return self.getToken(FuncTestCaseParser.Timestamp, 0) + def enterRule(self, listener: ParseTreeListener): if hasattr(listener, "enterTimestamp"): listener.enterTimestamp(self) @@ -6111,6 +8667,9 @@ def __init__( def TsTZ(self): return self.getToken(FuncTestCaseParser.TsTZ, 0) + def Timestamp_TZ(self): + return self.getToken(FuncTestCaseParser.Timestamp_TZ, 0) + def enterRule(self, listener: ParseTreeListener): if hasattr(listener, "enterTimestampTz"): listener.enterTimestampTz(self) @@ -6127,113 +8686,149 @@ def accept(self, visitor: ParseTreeVisitor): def scalarType(self): localctx = FuncTestCaseParser.ScalarTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 56, self.RULE_scalarType) + self.enterRule(localctx, 78, self.RULE_scalarType) + self._la = 0 # Token type try: - self.state = 295 + self.state = 439 self._errHandler.sync(self) token = self._input.LA(1) - if token in [70]: + if token in [46, 73]: localctx = FuncTestCaseParser.BooleanContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 277 - self.match(FuncTestCaseParser.Bool) + self.state = 421 + _la = self._input.LA(1) + if not (_la == 46 or _la == 73): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() pass - elif token in [44]: + elif token in [47]: localctx = FuncTestCaseParser.I8Context(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 278 + self.state = 422 self.match(FuncTestCaseParser.I8) pass - elif token in [45]: + elif token in [48]: localctx = FuncTestCaseParser.I16Context(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 279 + self.state = 423 self.match(FuncTestCaseParser.I16) pass - elif token in [46]: + elif token in [49]: localctx = FuncTestCaseParser.I32Context(self, localctx) self.enterOuterAlt(localctx, 4) - self.state = 280 + self.state = 424 self.match(FuncTestCaseParser.I32) pass - elif token in [47]: + elif token in [50]: localctx = FuncTestCaseParser.I64Context(self, localctx) self.enterOuterAlt(localctx, 5) - self.state = 281 + self.state = 425 self.match(FuncTestCaseParser.I64) pass - elif token in [48]: + elif token in [51]: localctx = FuncTestCaseParser.Fp32Context(self, localctx) self.enterOuterAlt(localctx, 6) - self.state = 282 + self.state = 426 self.match(FuncTestCaseParser.FP32) pass - elif token in [49]: + elif token in [52]: localctx = FuncTestCaseParser.Fp64Context(self, localctx) self.enterOuterAlt(localctx, 7) - self.state = 283 + self.state = 427 self.match(FuncTestCaseParser.FP64) pass - elif token in [71]: + elif token in [53, 74]: localctx = FuncTestCaseParser.StringContext(self, localctx) self.enterOuterAlt(localctx, 8) - self.state = 284 - self.match(FuncTestCaseParser.Str) + self.state = 428 + _la = self._input.LA(1) + if not (_la == 53 or _la == 74): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() pass - elif token in [51]: + elif token in [54, 75]: localctx = FuncTestCaseParser.BinaryContext(self, localctx) self.enterOuterAlt(localctx, 9) - self.state = 285 - self.match(FuncTestCaseParser.Binary) + self.state = 429 + _la = self._input.LA(1) + if not (_la == 54 or _la == 75): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() pass - elif token in [73]: + elif token in [55, 76]: localctx = FuncTestCaseParser.TimestampContext(self, localctx) self.enterOuterAlt(localctx, 10) - self.state = 286 - self.match(FuncTestCaseParser.Ts) + self.state = 430 + _la = self._input.LA(1) + if not (_la == 55 or _la == 76): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() pass - elif token in [74]: + elif token in [56, 77]: localctx = FuncTestCaseParser.TimestampTzContext(self, localctx) self.enterOuterAlt(localctx, 11) - self.state = 287 - self.match(FuncTestCaseParser.TsTZ) + self.state = 431 + _la = self._input.LA(1) + if not (_la == 56 or _la == 77): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() pass - elif token in [54]: + elif token in [57]: localctx = FuncTestCaseParser.DateContext(self, localctx) self.enterOuterAlt(localctx, 12) - self.state = 288 + self.state = 432 self.match(FuncTestCaseParser.Date) pass - elif token in [55]: + elif token in [58]: localctx = FuncTestCaseParser.TimeContext(self, localctx) self.enterOuterAlt(localctx, 13) - self.state = 289 + self.state = 433 self.match(FuncTestCaseParser.Time) pass - elif token in [76]: + elif token in [59, 79]: localctx = FuncTestCaseParser.IntervalDayContext(self, localctx) self.enterOuterAlt(localctx, 14) - self.state = 290 - self.match(FuncTestCaseParser.IDay) + self.state = 434 + _la = self._input.LA(1) + if not (_la == 59 or _la == 79): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() pass - elif token in [75]: + elif token in [60, 78]: localctx = FuncTestCaseParser.IntervalYearContext(self, localctx) self.enterOuterAlt(localctx, 15) - self.state = 291 - self.match(FuncTestCaseParser.IYear) + self.state = 435 + _la = self._input.LA(1) + if not (_la == 60 or _la == 78): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() pass - elif token in [58]: + elif token in [61]: localctx = FuncTestCaseParser.UuidContext(self, localctx) self.enterOuterAlt(localctx, 16) - self.state = 292 + self.state = 436 self.match(FuncTestCaseParser.UUID) pass - elif token in [69]: + elif token in [72]: localctx = FuncTestCaseParser.UserDefinedContext(self, localctx) self.enterOuterAlt(localctx, 17) - self.state = 293 + self.state = 437 self.match(FuncTestCaseParser.UserDefined) - self.state = 294 + self.state = 438 self.match(FuncTestCaseParser.Identifier) pass else: @@ -6271,15 +8866,18 @@ def __init__( self.len_ = None # NumericParameterContext self.copyFrom(ctx) - def FChar(self): - return self.getToken(FuncTestCaseParser.FChar, 0) - def OAngleBracket(self): return self.getToken(FuncTestCaseParser.OAngleBracket, 0) def CAngleBracket(self): return self.getToken(FuncTestCaseParser.CAngleBracket, 0) + def FChar(self): + return self.getToken(FuncTestCaseParser.FChar, 0) + + def FixedChar(self): + return self.getToken(FuncTestCaseParser.FixedChar, 0) + def numericParameter(self): return self.getTypedRuleContext( FuncTestCaseParser.NumericParameterContext, 0 @@ -6304,25 +8902,30 @@ def accept(self, visitor: ParseTreeVisitor): def fixedCharType(self): localctx = FuncTestCaseParser.FixedCharTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 58, self.RULE_fixedCharType) + self.enterRule(localctx, 80, self.RULE_fixedCharType) self._la = 0 # Token type try: localctx = FuncTestCaseParser.FixedCharContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 297 - self.match(FuncTestCaseParser.FChar) - self.state = 299 + self.state = 441 + _la = self._input.LA(1) + if not (_la == 65 or _la == 83): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 443 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 104: - self.state = 298 + if _la == 107: + self.state = 442 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 301 + self.state = 445 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 302 + self.state = 446 localctx.len_ = self.numericParameter() - self.state = 303 + self.state = 447 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6356,15 +8959,18 @@ def __init__( self.len_ = None # NumericParameterContext self.copyFrom(ctx) - def VChar(self): - return self.getToken(FuncTestCaseParser.VChar, 0) - def OAngleBracket(self): return self.getToken(FuncTestCaseParser.OAngleBracket, 0) def CAngleBracket(self): return self.getToken(FuncTestCaseParser.CAngleBracket, 0) + def VChar(self): + return self.getToken(FuncTestCaseParser.VChar, 0) + + def VarChar(self): + return self.getToken(FuncTestCaseParser.VarChar, 0) + def numericParameter(self): return self.getTypedRuleContext( FuncTestCaseParser.NumericParameterContext, 0 @@ -6389,25 +8995,30 @@ def accept(self, visitor: ParseTreeVisitor): def varCharType(self): localctx = FuncTestCaseParser.VarCharTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 60, self.RULE_varCharType) + self.enterRule(localctx, 82, self.RULE_varCharType) self._la = 0 # Token type try: localctx = FuncTestCaseParser.VarCharContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 305 - self.match(FuncTestCaseParser.VChar) - self.state = 307 + self.state = 449 + _la = self._input.LA(1) + if not (_la == 66 or _la == 84): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 451 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 104: - self.state = 306 + if _la == 107: + self.state = 450 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 309 + self.state = 453 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 310 + self.state = 454 localctx.len_ = self.numericParameter() - self.state = 311 + self.state = 455 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6441,15 +9052,18 @@ def __init__( self.len_ = None # NumericParameterContext self.copyFrom(ctx) - def FBin(self): - return self.getToken(FuncTestCaseParser.FBin, 0) - def OAngleBracket(self): return self.getToken(FuncTestCaseParser.OAngleBracket, 0) def CAngleBracket(self): return self.getToken(FuncTestCaseParser.CAngleBracket, 0) + def FBin(self): + return self.getToken(FuncTestCaseParser.FBin, 0) + + def FixedBinary(self): + return self.getToken(FuncTestCaseParser.FixedBinary, 0) + def numericParameter(self): return self.getTypedRuleContext( FuncTestCaseParser.NumericParameterContext, 0 @@ -6476,25 +9090,30 @@ def fixedBinaryType(self): localctx = FuncTestCaseParser.FixedBinaryTypeContext( self, self._ctx, self.state ) - self.enterRule(localctx, 62, self.RULE_fixedBinaryType) + self.enterRule(localctx, 84, self.RULE_fixedBinaryType) self._la = 0 # Token type try: localctx = FuncTestCaseParser.FixedBinaryContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 313 - self.match(FuncTestCaseParser.FBin) - self.state = 315 + self.state = 457 + _la = self._input.LA(1) + if not (_la == 67 or _la == 85): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 459 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 104: - self.state = 314 + if _la == 107: + self.state = 458 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 317 + self.state = 461 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 318 + self.state = 462 localctx.len_ = self.numericParameter() - self.state = 319 + self.state = 463 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6532,6 +9151,9 @@ def __init__( def Dec(self): return self.getToken(FuncTestCaseParser.Dec, 0) + def Decimal(self): + return self.getToken(FuncTestCaseParser.Decimal, 0) + def OAngleBracket(self): return self.getToken(FuncTestCaseParser.OAngleBracket, 0) @@ -6570,33 +9192,38 @@ def accept(self, visitor: ParseTreeVisitor): def decimalType(self): localctx = FuncTestCaseParser.DecimalTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 64, self.RULE_decimalType) + self.enterRule(localctx, 86, self.RULE_decimalType) self._la = 0 # Token type try: localctx = FuncTestCaseParser.DecimalContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 321 - self.match(FuncTestCaseParser.Dec) - self.state = 323 + self.state = 465 + _la = self._input.LA(1) + if not (_la == 62 or _la == 80): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 467 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 104: - self.state = 322 + if _la == 107: + self.state = 466 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 331 + self.state = 475 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 32: - self.state = 325 + if _la == 34: + self.state = 469 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 326 + self.state = 470 localctx.precision = self.numericParameter() - self.state = 327 + self.state = 471 self.match(FuncTestCaseParser.Comma) - self.state = 328 + self.state = 472 localctx.scale = self.numericParameter() - self.state = 329 + self.state = 473 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: @@ -6631,15 +9258,18 @@ def __init__( self.precision = None # NumericParameterContext self.copyFrom(ctx) - def PTs(self): - return self.getToken(FuncTestCaseParser.PTs, 0) - def OAngleBracket(self): return self.getToken(FuncTestCaseParser.OAngleBracket, 0) def CAngleBracket(self): return self.getToken(FuncTestCaseParser.CAngleBracket, 0) + def PTs(self): + return self.getToken(FuncTestCaseParser.PTs, 0) + + def Precision_Timestamp(self): + return self.getToken(FuncTestCaseParser.Precision_Timestamp, 0) + def numericParameter(self): return self.getTypedRuleContext( FuncTestCaseParser.NumericParameterContext, 0 @@ -6666,25 +9296,30 @@ def precisionTimestampType(self): localctx = FuncTestCaseParser.PrecisionTimestampTypeContext( self, self._ctx, self.state ) - self.enterRule(localctx, 66, self.RULE_precisionTimestampType) + self.enterRule(localctx, 88, self.RULE_precisionTimestampType) self._la = 0 # Token type try: localctx = FuncTestCaseParser.PrecisionTimestampContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 333 - self.match(FuncTestCaseParser.PTs) - self.state = 335 + self.state = 477 + _la = self._input.LA(1) + if not (_la == 63 or _la == 81): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 479 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 104: - self.state = 334 + if _la == 107: + self.state = 478 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 337 + self.state = 481 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 338 + self.state = 482 localctx.precision = self.numericParameter() - self.state = 339 + self.state = 483 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6718,15 +9353,18 @@ def __init__( self.precision = None # NumericParameterContext self.copyFrom(ctx) - def PTsTZ(self): - return self.getToken(FuncTestCaseParser.PTsTZ, 0) - def OAngleBracket(self): return self.getToken(FuncTestCaseParser.OAngleBracket, 0) def CAngleBracket(self): return self.getToken(FuncTestCaseParser.CAngleBracket, 0) + def PTsTZ(self): + return self.getToken(FuncTestCaseParser.PTsTZ, 0) + + def Precision_Timestamp_TZ(self): + return self.getToken(FuncTestCaseParser.Precision_Timestamp_TZ, 0) + def numericParameter(self): return self.getTypedRuleContext( FuncTestCaseParser.NumericParameterContext, 0 @@ -6753,25 +9391,30 @@ def precisionTimestampTZType(self): localctx = FuncTestCaseParser.PrecisionTimestampTZTypeContext( self, self._ctx, self.state ) - self.enterRule(localctx, 68, self.RULE_precisionTimestampTZType) + self.enterRule(localctx, 90, self.RULE_precisionTimestampTZType) self._la = 0 # Token type try: localctx = FuncTestCaseParser.PrecisionTimestampTZContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 341 - self.match(FuncTestCaseParser.PTsTZ) - self.state = 343 + self.state = 485 + _la = self._input.LA(1) + if not (_la == 64 or _la == 82): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 487 self._errHandler.sync(self) _la = self._input.LA(1) - if _la == 104: - self.state = 342 + if _la == 107: + self.state = 486 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 345 + self.state = 489 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 346 + self.state = 490 localctx.precision = self.numericParameter() - self.state = 347 + self.state = 491 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6835,39 +9478,39 @@ def parameterizedType(self): localctx = FuncTestCaseParser.ParameterizedTypeContext( self, self._ctx, self.state ) - self.enterRule(localctx, 70, self.RULE_parameterizedType) + self.enterRule(localctx, 92, self.RULE_parameterizedType) try: - self.state = 355 + self.state = 499 self._errHandler.sync(self) token = self._input.LA(1) - if token in [80]: + if token in [65, 83]: self.enterOuterAlt(localctx, 1) - self.state = 349 + self.state = 493 self.fixedCharType() pass - elif token in [81]: + elif token in [66, 84]: self.enterOuterAlt(localctx, 2) - self.state = 350 + self.state = 494 self.varCharType() pass - elif token in [82]: + elif token in [67, 85]: self.enterOuterAlt(localctx, 3) - self.state = 351 + self.state = 495 self.fixedBinaryType() pass - elif token in [77]: + elif token in [62, 80]: self.enterOuterAlt(localctx, 4) - self.state = 352 + self.state = 496 self.decimalType() pass - elif token in [78]: + elif token in [63, 81]: self.enterOuterAlt(localctx, 5) - self.state = 353 + self.state = 497 self.precisionTimestampType() pass - elif token in [79]: + elif token in [64, 82]: self.enterOuterAlt(localctx, 6) - self.state = 354 + self.state = 498 self.precisionTimestampTZType() pass else: @@ -6924,11 +9567,11 @@ def numericParameter(self): localctx = FuncTestCaseParser.NumericParameterContext( self, self._ctx, self.state ) - self.enterRule(localctx, 72, self.RULE_numericParameter) + self.enterRule(localctx, 94, self.RULE_numericParameter) try: localctx = FuncTestCaseParser.IntegerLiteralContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 357 + self.state = 501 self.match(FuncTestCaseParser.IntegerLiteral) except RecognitionException as re: localctx.exception = re @@ -6972,13 +9615,13 @@ def accept(self, visitor: ParseTreeVisitor): def substraitError(self): localctx = FuncTestCaseParser.SubstraitErrorContext(self, self._ctx, self.state) - self.enterRule(localctx, 74, self.RULE_substraitError) + self.enterRule(localctx, 96, self.RULE_substraitError) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 359 + self.state = 503 _la = self._input.LA(1) - if not (_la == 7 or _la == 8): + if not (_la == 9 or _la == 10): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -7028,14 +9671,14 @@ def accept(self, visitor: ParseTreeVisitor): def func_option(self): localctx = FuncTestCaseParser.Func_optionContext(self, self._ctx, self.state) - self.enterRule(localctx, 76, self.RULE_func_option) + self.enterRule(localctx, 98, self.RULE_func_option) try: self.enterOuterAlt(localctx, 1) - self.state = 361 + self.state = 505 self.option_name() - self.state = 362 + self.state = 506 self.match(FuncTestCaseParser.Colon) - self.state = 363 + self.state = 507 self.option_value() except RecognitionException as re: localctx.exception = re @@ -7082,13 +9725,13 @@ def accept(self, visitor: ParseTreeVisitor): def option_name(self): localctx = FuncTestCaseParser.Option_nameContext(self, self._ctx, self.state) - self.enterRule(localctx, 78, self.RULE_option_name) + self.enterRule(localctx, 100, self.RULE_option_name) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 365 + self.state = 509 _la = self._input.LA(1) - if not (_la == 9 or _la == 10 or _la == 111): + if not (_la == 11 or _la == 12 or _la == 114): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -7144,13 +9787,13 @@ def accept(self, visitor: ParseTreeVisitor): def option_value(self): localctx = FuncTestCaseParser.Option_valueContext(self, self._ctx, self.state) - self.enterRule(localctx, 80, self.RULE_option_value) + self.enterRule(localctx, 102, self.RULE_option_value) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 367 + self.state = 511 _la = self._input.LA(1) - if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 63488) != 0)): + if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 253952) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -7205,21 +9848,21 @@ def accept(self, visitor: ParseTreeVisitor): def func_options(self): localctx = FuncTestCaseParser.Func_optionsContext(self, self._ctx, self.state) - self.enterRule(localctx, 82, self.RULE_func_options) + self.enterRule(localctx, 104, self.RULE_func_options) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 369 + self.state = 513 self.func_option() - self.state = 374 + self.state = 518 self._errHandler.sync(self) _la = self._input.LA(1) - while _la == 102: - self.state = 370 + while _la == 105: + self.state = 514 self.match(FuncTestCaseParser.Comma) - self.state = 371 + self.state = 515 self.func_option() - self.state = 376 + self.state = 520 self._errHandler.sync(self) _la = self._input.LA(1) diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py index e743017e5..30408dd84 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py @@ -62,12 +62,28 @@ def enterTestCase(self, ctx: FuncTestCaseParser.TestCaseContext): def exitTestCase(self, ctx: FuncTestCaseParser.TestCaseContext): pass - # Enter a parse tree produced by FuncTestCaseParser#testGroup. - def enterTestGroup(self, ctx: FuncTestCaseParser.TestGroupContext): + # Enter a parse tree produced by FuncTestCaseParser#scalarFuncTestGroup. + def enterScalarFuncTestGroup( + self, ctx: FuncTestCaseParser.ScalarFuncTestGroupContext + ): pass - # Exit a parse tree produced by FuncTestCaseParser#testGroup. - def exitTestGroup(self, ctx: FuncTestCaseParser.TestGroupContext): + # Exit a parse tree produced by FuncTestCaseParser#scalarFuncTestGroup. + def exitScalarFuncTestGroup( + self, ctx: FuncTestCaseParser.ScalarFuncTestGroupContext + ): + pass + + # Enter a parse tree produced by FuncTestCaseParser#aggregateFuncTestGroup. + def enterAggregateFuncTestGroup( + self, ctx: FuncTestCaseParser.AggregateFuncTestGroupContext + ): + pass + + # Exit a parse tree produced by FuncTestCaseParser#aggregateFuncTestGroup. + def exitAggregateFuncTestGroup( + self, ctx: FuncTestCaseParser.AggregateFuncTestGroupContext + ): pass # Enter a parse tree produced by FuncTestCaseParser#arguments. @@ -94,6 +110,130 @@ def enterArgument(self, ctx: FuncTestCaseParser.ArgumentContext): def exitArgument(self, ctx: FuncTestCaseParser.ArgumentContext): pass + # Enter a parse tree produced by FuncTestCaseParser#aggFuncTestCase. + def enterAggFuncTestCase(self, ctx: FuncTestCaseParser.AggFuncTestCaseContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#aggFuncTestCase. + def exitAggFuncTestCase(self, ctx: FuncTestCaseParser.AggFuncTestCaseContext): + pass + + # Enter a parse tree produced by FuncTestCaseParser#multiArgAggregateFuncCall. + def enterMultiArgAggregateFuncCall( + self, ctx: FuncTestCaseParser.MultiArgAggregateFuncCallContext + ): + pass + + # Exit a parse tree produced by FuncTestCaseParser#multiArgAggregateFuncCall. + def exitMultiArgAggregateFuncCall( + self, ctx: FuncTestCaseParser.MultiArgAggregateFuncCallContext + ): + pass + + # Enter a parse tree produced by FuncTestCaseParser#compactAggregateFuncCall. + def enterCompactAggregateFuncCall( + self, ctx: FuncTestCaseParser.CompactAggregateFuncCallContext + ): + pass + + # Exit a parse tree produced by FuncTestCaseParser#compactAggregateFuncCall. + def exitCompactAggregateFuncCall( + self, ctx: FuncTestCaseParser.CompactAggregateFuncCallContext + ): + pass + + # Enter a parse tree produced by FuncTestCaseParser#singleArgAggregateFuncCall. + def enterSingleArgAggregateFuncCall( + self, ctx: FuncTestCaseParser.SingleArgAggregateFuncCallContext + ): + pass + + # Exit a parse tree produced by FuncTestCaseParser#singleArgAggregateFuncCall. + def exitSingleArgAggregateFuncCall( + self, ctx: FuncTestCaseParser.SingleArgAggregateFuncCallContext + ): + pass + + # Enter a parse tree produced by FuncTestCaseParser#tableData. + def enterTableData(self, ctx: FuncTestCaseParser.TableDataContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#tableData. + def exitTableData(self, ctx: FuncTestCaseParser.TableDataContext): + pass + + # Enter a parse tree produced by FuncTestCaseParser#tableRows. + def enterTableRows(self, ctx: FuncTestCaseParser.TableRowsContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#tableRows. + def exitTableRows(self, ctx: FuncTestCaseParser.TableRowsContext): + pass + + # Enter a parse tree produced by FuncTestCaseParser#dataColumn. + def enterDataColumn(self, ctx: FuncTestCaseParser.DataColumnContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#dataColumn. + def exitDataColumn(self, ctx: FuncTestCaseParser.DataColumnContext): + pass + + # Enter a parse tree produced by FuncTestCaseParser#literalValueList. + def enterLiteralValueList(self, ctx: FuncTestCaseParser.LiteralValueListContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#literalValueList. + def exitLiteralValueList(self, ctx: FuncTestCaseParser.LiteralValueListContext): + pass + + # Enter a parse tree produced by FuncTestCaseParser#literal. + def enterLiteral(self, ctx: FuncTestCaseParser.LiteralContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#literal. + def exitLiteral(self, ctx: FuncTestCaseParser.LiteralContext): + pass + + # Enter a parse tree produced by FuncTestCaseParser#qualifiedAggregateFuncArgs. + def enterQualifiedAggregateFuncArgs( + self, ctx: FuncTestCaseParser.QualifiedAggregateFuncArgsContext + ): + pass + + # Exit a parse tree produced by FuncTestCaseParser#qualifiedAggregateFuncArgs. + def exitQualifiedAggregateFuncArgs( + self, ctx: FuncTestCaseParser.QualifiedAggregateFuncArgsContext + ): + pass + + # Enter a parse tree produced by FuncTestCaseParser#aggregateFuncArgs. + def enterAggregateFuncArgs(self, ctx: FuncTestCaseParser.AggregateFuncArgsContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#aggregateFuncArgs. + def exitAggregateFuncArgs(self, ctx: FuncTestCaseParser.AggregateFuncArgsContext): + pass + + # Enter a parse tree produced by FuncTestCaseParser#qualifiedAggregateFuncArg. + def enterQualifiedAggregateFuncArg( + self, ctx: FuncTestCaseParser.QualifiedAggregateFuncArgContext + ): + pass + + # Exit a parse tree produced by FuncTestCaseParser#qualifiedAggregateFuncArg. + def exitQualifiedAggregateFuncArg( + self, ctx: FuncTestCaseParser.QualifiedAggregateFuncArgContext + ): + pass + + # Enter a parse tree produced by FuncTestCaseParser#aggregateFuncArg. + def enterAggregateFuncArg(self, ctx: FuncTestCaseParser.AggregateFuncArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#aggregateFuncArg. + def exitAggregateFuncArg(self, ctx: FuncTestCaseParser.AggregateFuncArgContext): + pass + # Enter a parse tree produced by FuncTestCaseParser#numericLiteral. def enterNumericLiteral(self, ctx: FuncTestCaseParser.NumericLiteralContext): pass @@ -236,19 +376,19 @@ def enterTimeInterval(self, ctx: FuncTestCaseParser.TimeIntervalContext): def exitTimeInterval(self, ctx: FuncTestCaseParser.TimeIntervalContext): pass - # Enter a parse tree produced by FuncTestCaseParser#datatype. - def enterDatatype(self, ctx: FuncTestCaseParser.DatatypeContext): + # Enter a parse tree produced by FuncTestCaseParser#dataType. + def enterDataType(self, ctx: FuncTestCaseParser.DataTypeContext): pass - # Exit a parse tree produced by FuncTestCaseParser#datatype. - def exitDatatype(self, ctx: FuncTestCaseParser.DatatypeContext): + # Exit a parse tree produced by FuncTestCaseParser#dataType. + def exitDataType(self, ctx: FuncTestCaseParser.DataTypeContext): pass - # Enter a parse tree produced by FuncTestCaseParser#Boolean. + # Enter a parse tree produced by FuncTestCaseParser#boolean. def enterBoolean(self, ctx: FuncTestCaseParser.BooleanContext): pass - # Exit a parse tree produced by FuncTestCaseParser#Boolean. + # Exit a parse tree produced by FuncTestCaseParser#boolean. def exitBoolean(self, ctx: FuncTestCaseParser.BooleanContext): pass diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py index 7895d9325..1f45e1c0c 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py @@ -37,8 +37,16 @@ def visitTestGroupDescription( def visitTestCase(self, ctx: FuncTestCaseParser.TestCaseContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#testGroup. - def visitTestGroup(self, ctx: FuncTestCaseParser.TestGroupContext): + # Visit a parse tree produced by FuncTestCaseParser#scalarFuncTestGroup. + def visitScalarFuncTestGroup( + self, ctx: FuncTestCaseParser.ScalarFuncTestGroupContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#aggregateFuncTestGroup. + def visitAggregateFuncTestGroup( + self, ctx: FuncTestCaseParser.AggregateFuncTestGroupContext + ): return self.visitChildren(ctx) # Visit a parse tree produced by FuncTestCaseParser#arguments. @@ -53,6 +61,68 @@ def visitResult(self, ctx: FuncTestCaseParser.ResultContext): def visitArgument(self, ctx: FuncTestCaseParser.ArgumentContext): return self.visitChildren(ctx) + # Visit a parse tree produced by FuncTestCaseParser#aggFuncTestCase. + def visitAggFuncTestCase(self, ctx: FuncTestCaseParser.AggFuncTestCaseContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#multiArgAggregateFuncCall. + def visitMultiArgAggregateFuncCall( + self, ctx: FuncTestCaseParser.MultiArgAggregateFuncCallContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#compactAggregateFuncCall. + def visitCompactAggregateFuncCall( + self, ctx: FuncTestCaseParser.CompactAggregateFuncCallContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#singleArgAggregateFuncCall. + def visitSingleArgAggregateFuncCall( + self, ctx: FuncTestCaseParser.SingleArgAggregateFuncCallContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#tableData. + def visitTableData(self, ctx: FuncTestCaseParser.TableDataContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#tableRows. + def visitTableRows(self, ctx: FuncTestCaseParser.TableRowsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#dataColumn. + def visitDataColumn(self, ctx: FuncTestCaseParser.DataColumnContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#literalValueList. + def visitLiteralValueList(self, ctx: FuncTestCaseParser.LiteralValueListContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#literal. + def visitLiteral(self, ctx: FuncTestCaseParser.LiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#qualifiedAggregateFuncArgs. + def visitQualifiedAggregateFuncArgs( + self, ctx: FuncTestCaseParser.QualifiedAggregateFuncArgsContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#aggregateFuncArgs. + def visitAggregateFuncArgs(self, ctx: FuncTestCaseParser.AggregateFuncArgsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#qualifiedAggregateFuncArg. + def visitQualifiedAggregateFuncArg( + self, ctx: FuncTestCaseParser.QualifiedAggregateFuncArgContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#aggregateFuncArg. + def visitAggregateFuncArg(self, ctx: FuncTestCaseParser.AggregateFuncArgContext): + return self.visitChildren(ctx) + # Visit a parse tree produced by FuncTestCaseParser#numericLiteral. def visitNumericLiteral(self, ctx: FuncTestCaseParser.NumericLiteralContext): return self.visitChildren(ctx) @@ -125,11 +195,11 @@ def visitIntervalDayLiteral( def visitTimeInterval(self, ctx: FuncTestCaseParser.TimeIntervalContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#datatype. - def visitDatatype(self, ctx: FuncTestCaseParser.DatatypeContext): + # Visit a parse tree produced by FuncTestCaseParser#dataType. + def visitDataType(self, ctx: FuncTestCaseParser.DataTypeContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#Boolean. + # Visit a parse tree produced by FuncTestCaseParser#boolean. def visitBoolean(self, ctx: FuncTestCaseParser.BooleanContext): return self.visitChildren(ctx) diff --git a/tests/coverage/case_file_parser.py b/tests/coverage/case_file_parser.py index bc0ad9fdf..9632c4fcb 100644 --- a/tests/coverage/case_file_parser.py +++ b/tests/coverage/case_file_parser.py @@ -6,13 +6,7 @@ from tests.coverage.antlr_parser.FuncTestCaseLexer import FuncTestCaseLexer from tests.coverage.antlr_parser.FuncTestCaseParser import FuncTestCaseParser -from tests.coverage.visitor import TestCaseVisitor - - -class ParseError(Exception): - def __init__(self, message="Parsing error occurred"): - self.message = message - super().__init__(self.message) +from tests.coverage.visitor import TestCaseVisitor, ParseError class ParseErrorListener(ErrorListener): diff --git a/tests/coverage/coverage.py b/tests/coverage/coverage.py index 4f5c50a3e..689a280f6 100755 --- a/tests/coverage/coverage.py +++ b/tests/coverage/coverage.py @@ -62,14 +62,14 @@ def to_dict(self): class TestCoverage: file_coverage: dict[str, FileTestCoverage] test_count: int - num_covered_variants: int - total_variants: int + num_covered_function_variants: int + total_function_variants: int def __init__(self, ext_uris): self.file_coverage = dict() self.test_count = 0 - self.num_covered_variants = 0 - self.total_variants = 0 + self.num_covered_function_variants = 0 + self.total_function_variants = 0 for ext_uri in ext_uris: self.file_coverage[ext_uri] = FileTestCoverage(ext_uri) @@ -84,8 +84,8 @@ def compute_coverage(self): for function_coverage in file_coverage.function_coverage.values(): for test_count in function_coverage.function_variant_coverage.values(): if test_count > 0: - self.num_covered_variants += 1 - self.total_variants += 1 + self.num_covered_function_variants += 1 + self.total_function_variants += 1 def to_dict(self): return { @@ -93,8 +93,8 @@ def to_dict(self): file_coverage.to_dict() for file_coverage in self.file_coverage.values() ], "test_count": self.test_count, - "num_covered_function_variants": self.num_covered_variants, - "total_function_variants": self.total_variants, + "num_covered_function_variants": self.num_covered_function_variants, + "total_function_variants": self.total_function_variants, } def to_json(self): @@ -113,7 +113,8 @@ def update_test_count(test_case_files: list, function_registry: FunctionRegistry and not test_case.is_return_type_error() ): error( - f"Return type mismatch in function {test_case.func_name}: {function_variant.return_type} != {test_case.get_return_type()}" + f"Return type mismatch in function {test_case.func_name}: " + f"{function_variant.return_type} != {test_case.get_return_type()}" ) continue function_variant.increment_test_count() @@ -121,11 +122,16 @@ def update_test_count(test_case_files: list, function_registry: FunctionRegistry error(f"Function not found: {test_case.func_name}({test_case.args})") -if __name__ == "__main__": - test_files = load_all_testcases("../cases") - function_registry = Extension.read_substrait_extensions("../../extensions") +def get_test_coverage(test_files, function_registry): coverage = TestCoverage(function_registry.get_extension_list()) update_test_count(test_files, function_registry) function_registry.fill_coverage(coverage) coverage.compute_coverage() - print(coverage.to_json()) + return coverage + + +if __name__ == "__main__": + all_test_files = load_all_testcases("../cases") + default_function_registry = Extension.read_substrait_extensions("../../extensions") + test_coverage = get_test_coverage(all_test_files, default_function_registry) + print(test_coverage.to_json()) diff --git a/tests/coverage/nodes.py b/tests/coverage/nodes.py index 9af5c51a0..c79d1463f 100644 --- a/tests/coverage/nodes.py +++ b/tests/coverage/nodes.py @@ -16,7 +16,7 @@ class SubstraitError: @dataclass class CaseLiteral: - value: str | int | float | list + value: str | int | float | list | None type: str def get_base_type(self): @@ -28,14 +28,23 @@ def get_base_type(self): return type_str +@dataclass +class AggregateArgument: + column_name: str + column_type: str + table_name: str + scalar_value: CaseLiteral | None + + @dataclass class TestCase: func_name: str base_uri: str - group: CaseGroup + group: CaseGroup | None options: dict - args: List[CaseLiteral] - result: CaseLiteral | str + rows: List[List] | None + args: List[CaseLiteral] | List[AggregateArgument] + result: CaseLiteral | str | SubstraitError comment: str def get_return_type(self): diff --git a/tests/coverage/test_coverage.py b/tests/coverage/test_coverage.py index 5e7896e95..48a73a02d 100644 --- a/tests/coverage/test_coverage.py +++ b/tests/coverage/test_coverage.py @@ -3,7 +3,8 @@ import pytest from antlr4 import InputStream -from tests.coverage.case_file_parser import parse_stream, parse_one_file, ParseError +from tests.coverage.case_file_parser import parse_stream, parse_one_file +from tests.coverage.visitor import ParseError from tests.coverage.nodes import CaseLiteral @@ -18,6 +19,13 @@ def make_header(version, include): """ +def make_aggregate_test_header(version, include): + return f"""### SUBSTRAIT_AGGREGATE_TEST: {version} +### SUBSTRAIT_INCLUDE: '{include}' + +""" + + def test_parse_basic_example(): header = make_header("v1.0", "/extensions/functions_arithmetic.yaml") tests = """# 'Basic examples without any special cases' @@ -89,6 +97,69 @@ def test_parse_decimal_example_with_nan(): assert test_file.testcases[0].args[1] == CaseLiteral("0.5", "dec<38,1>") +def test_parse_aggregate_func_test(): + header = make_aggregate_test_header("v1.0", "extensions/functions_arithmetic.yaml") + tests = """# basic +avg((1,2,3)::fp32) = 2::fp64 +""" + test_file = parse_string(header + tests) + assert len(test_file.testcases) == 1 + + +def test_parse_aggregate_func_test_compact(): + header = make_aggregate_test_header("v1.0", "extensions/functions_arithmetic.yaml") + tests = """# basic +((20, 20), (-3, -3), (1, 1), (10,10), (5,5)) corr(col0::fp32, col1::fp32) = 1::fp64 +""" + test_file = parse_string(header + tests) + assert len(test_file.testcases) == 1 + + +def test_parse_aggregate_func_test_multiple_args(): + header = make_aggregate_test_header("v1.0", "extensions/functions_arithmetic.yaml") + tests = """# basic +DEFINE t1(fp32, fp32) = ((20, 20), (-3, -3), (1, 1), (10,10), (5,5)) +corr(t1.col0, t1.col1) = 1::fp64 +""" + test_file = parse_string(header + tests) + assert len(test_file.testcases) == 1 + + +def test_parse_aggregate_func_test_compact_mixed_args(): + header = make_aggregate_test_header("v1.0", "extensions/functions_arithmetic.yaml") + tests = """# basic +((20), (-3), (1), (10)) LIST_AGG(col0::fp32, ','::string) = 1::fp64 +""" + test_file = parse_string(header + tests) + assert len(test_file.testcases) == 1 + + +def test_parse_aggregate_func_test_compact_string_agg(): + header = make_aggregate_test_header("v1.0", "extensions/functions_arithmetic.yaml") + tests = """# basic +(('ant'), ('bat'), ('cat')) string_agg(col0::str, ','::str) = 1::fp64 +(('ant'), ('bat'), ('cat')) string_agg(col0::string, ','::string) = 1::fp64 +""" + test_file = parse_string(header + tests) + assert len(test_file.testcases) == 2 + + +def test_parse_aggregate_func_max(): + header = make_aggregate_test_header("v1.0", "extensions/functions_arithmetic.yaml") + tests = """# basic +max((2.5, 0, 5.0, -2.5, -7.5)::fp32) = 5.0::fp32 +""" + test_file = parse_string(header + tests) + assert len(test_file.testcases) == 1 + assert test_file.testcases[0].func_name == "max" + assert test_file.testcases[0].base_uri == "extensions/functions_arithmetic.yaml" + assert test_file.testcases[0].group.name == "basic" + assert test_file.testcases[0].result == CaseLiteral("5.0", "fp32") + assert test_file.testcases[0].args == [ + CaseLiteral(value=["2.5", "0", "5.0", "-2.5", "-7.5"], type="fp32") + ] + + def test_parse_file_add(): test_file = parse_one_file("../cases/arithmetic/add.test") assert len(test_file.testcases) == 15 @@ -97,6 +168,14 @@ def test_parse_file_add(): assert test_file.include == "/extensions/functions_arithmetic.yaml" +def test_parse_file_max(): + test_file = parse_one_file("../cases/arithmetic/max.test") + assert len(test_file.testcases) == 12 + assert test_file.testcases[0].func_name == "max" + assert test_file.testcases[0].base_uri == "/extensions/functions_arithmetic.yaml" + assert test_file.include == "/extensions/functions_arithmetic.yaml" + + def test_parse_file_lt_datetime(): test_file = parse_one_file("../cases/datetime/lt_datetime.test") assert len(test_file.testcases) == 13 @@ -186,10 +265,78 @@ def test_parse_file_power_decimal(): ), ], ) -def test_parse_errors_with_bad_cases(input_func_test, position, expected_message): +def test_parse_errors_with_bad_scalar_testcases( + input_func_test, position, expected_message +): header = make_header("v1.0", "extensions/functions_arithmetic.yaml") + "# basic\n" with pytest.raises(ParseError) as pm: parse_string(header + input_func_test + "\n") assert f"Syntax error at line 5, column {position}: {expected_message}" in str( pm.value ) + + +@pytest.mark.parametrize( + "input_func_test, expected_message", + [ + ( + "max((-12, +5)::i8) = -7.0::i8", + "no viable alternative at input '-7.0::i8'", + ), + ( + "max((-12, 'arg')::str) = -7::i8", + "All values in a column must have the same type", + ), + ( + """DEFINE t1(fp32, fp32) = ((20, 20), (-3, -3), (1, 1), (10,10), (5,5)) + corr(t1.col0, t2.col1) = 1::fp64""", + "Table name in argument does not match the table name in the function call", + ), + ( + "((20, 20), (-3, -3), (1, 1), (10,10), (5,5)) corr(my_col::fp32, col0::fp32) = 1::fp64", + "mismatched input 'my_col'", + ), + ( + "((20, 20), (-3, -3), (1, 1), (10,10), (5,5)) corr(col0::fp32, column1::fp32) = 1::fp64", + "mismatched input 'column1'", + ), + ], +) +def test_parse_errors_with_bad_aggregate_testcases(input_func_test, expected_message): + header = ( + make_aggregate_test_header("v1.0", "extensions/functions_arithmetic.yaml") + + "# basic\n" + ) + with pytest.raises(ParseError) as pm: + parse_string(header + input_func_test + "\n") + assert expected_message in str(pm.value) + + +@pytest.mark.parametrize( + "input_func_test", + [ + "f1(1::i8, 2::i16, 3::i32, 4::i64) = -7.0::fp32", + "f2(1.0::fp32, 2.0::fp64) = -7.0::fp32", + "f3('a'::str, 'b'::string) = 'c'::str", + "f4(false::bool, true::boolean) = false::bool", + "f5(1.1::dec, 2.2::decimal) = 3.3::dec", + "f6(1.1::dec<38,10>, 2.2::dec<38,10>) = 3.3::dec<38,10>", + "f7(1.1::dec<38,10>, 2.2::decimal<38,10>) = 3.3::decimal<38,10>", + "f8('1991-01-01'::date) = '2001-01-01'::date", + "f8('13:01:01.2345678'::time) = '23:59:59.999'::time", + "f8('1991-01-01T01:02:03.456'::ts, '1991-01-01T00:00:00'::timestamp) = '1991-01-01T22:33:44'::ts", + "f8('1991-01-01T01:02:03.456+05:30'::tstz, '1991-01-01T00:00:00+15:30'::timestamp_tz) = 23::i32", + "f9('1991-01-01'::date, 5::i64) = '1991-01-01T00:00:00+15:30'::timestamp_tz", + "f10('P10Y5M'::interval_year, 5::i64) = 'P15Y5M'::interval_year", + "f10('P10Y5M'::iyear, 5::i64) = 'P15Y5M'::iyear", + "f11('P10DT5H6M7S2000F'::interval_day, 5::i64) = 'P10DT10H6M7S2000F'::interval_day", + "f11('P10DT6M7S2000F'::interval_day, 5::i64) = 'P10DT11M7S2000F'::interval_day", + ], +) +def test_parse_various_argument_types(input_func_test): + header = ( + make_aggregate_test_header("v1.0", "extensions/functions_arithmetic.yaml") + + "# basic\n" + ) + test_file = parse_string(header + input_func_test + "\n") + assert len(test_file.testcases) == 1 diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py index 6892bbf1b..eecb0666a 100644 --- a/tests/coverage/visitor.py +++ b/tests/coverage/visitor.py @@ -4,6 +4,7 @@ FuncTestCaseParserVisitor, ) from tests.coverage.nodes import ( + AggregateArgument, CaseGroup, TestFile, TestCase, @@ -20,7 +21,7 @@ def visitDoc(self, ctx: FuncTestCaseParser.DocContext): version, include = self.visitHeader(ctx.header()) testcases = [] for group in ctx.testGroup(): - _, group_tests = self.visitTestGroup(group) + _, group_tests = self.visit(group) for test_case in group_tests: test_case.base_uri = include testcases.extend(group_tests) @@ -45,7 +46,9 @@ def visitTestGroupDescription( group = ctx.DescriptionLine().getText().strip("#").strip() return CaseGroup(group, "") - def visitTestGroup(self, ctx: FuncTestCaseParser.TestGroupContext): + def visitScalarFuncTestGroup( + self, ctx: FuncTestCaseParser.ScalarFuncTestGroupContext + ): group = self.visitTestGroupDescription(ctx.testGroupDescription()) test_cases = [] for test_case in ctx.testCase(): @@ -54,6 +57,17 @@ def visitTestGroup(self, ctx: FuncTestCaseParser.TestGroupContext): test_cases.append(testcase) return group, test_cases + def visitAggregateFuncTestGroup( + self, ctx: FuncTestCaseParser.AggregateFuncTestGroupContext + ): + group = self.visitTestGroupDescription(ctx.testGroupDescription()) + test_cases = [] + for test_case in ctx.aggFuncTestCase(): + testcase = self.visitAggFuncTestCase(test_case) + testcase.group = group + test_cases.append(testcase) + return group, test_cases + def visitTestCase(self, ctx: FuncTestCaseParser.TestCaseContext): # TODO Implement this method args = self.visitArguments(ctx.arguments()) @@ -66,11 +80,161 @@ def visitTestCase(self, ctx: FuncTestCaseParser.TestCaseContext): base_uri="", group=None, options=options, + rows=None, args=args, result=result, comment="", ) + def visitAggFuncTestCase(self, ctx: FuncTestCaseParser.AggFuncTestCaseContext): + testcase = self.visit(ctx.aggFuncCall()) + testcase.result = self.visitResult(ctx.result()) + if ctx.func_options() is not None: + testcase.options = self.visitFunc_options(ctx.func_options()) + return testcase + + def visitSingleArgAggregateFuncCall( + self, ctx: FuncTestCaseParser.SingleArgAggregateFuncCallContext + ): + arg = self.visitDataColumn(ctx.dataColumn()) + return TestCase( + func_name=ctx.Identifier().getText(), + base_uri="", + group=None, + options=dict(), + rows=None, + args=[arg], + result=SubstraitError("uninitialized"), + comment="", + ) + + def visitCompactAggregateFuncCall( + self, ctx: FuncTestCaseParser.CompactAggregateFuncCallContext + ): + rows = self.visitTableRows(ctx.tableRows()) + args = self.visitAggregateFuncArgs(ctx.aggregateFuncArgs()) + return TestCase( + func_name=ctx.Identifier().getText(), + base_uri="", + group=None, + options=dict(), + rows=rows, + args=args, + result=SubstraitError("uninitialized"), + comment="", + ) + + def visitMultiArgAggregateFuncCall( + self, ctx: FuncTestCaseParser.MultiArgAggregateFuncCallContext + ): + table_name, column_types, rows = self.visitTableData(ctx.tableData()) + args = self.visitQualifiedAggregateFuncArgs(ctx.qualifiedAggregateFuncArgs()) + for arg in args: + if arg.scalar_value is None: + if arg.table_name != table_name: + raise ParseError( + "Table name in argument does not match the table name in the function call" + ) + column_index = int(arg.column_name[3:]) + arg.column_type = column_types[column_index] + + return TestCase( + func_name=ctx.Identifier().getText(), + base_uri="", + group=None, + options=dict(), + rows=rows, + args=args, + result=SubstraitError("uninitialized"), + comment="", + ) + + def visitAggregateFuncArgs(self, ctx: FuncTestCaseParser.AggregateFuncArgsContext): + args = [] + for arg in ctx.aggregateFuncArg(): + args.append(self.visitAggregateFuncArg(arg)) + return args + + def visitAggregateFuncArg(self, ctx: FuncTestCaseParser.AggregateFuncArgContext): + if ctx.argument() is not None: + return AggregateArgument("", "", "", self.visitArgument(ctx.argument())) + data_type = self.visitDataType(ctx.dataType()) + return AggregateArgument( + ctx.ColumnName().getText(), data_type, "", scalar_value=None + ) + + def visitQualifiedAggregateFuncArgs( + self, ctx: FuncTestCaseParser.QualifiedAggregateFuncArgsContext + ): + args = [] + for arg in ctx.qualifiedAggregateFuncArg(): + args.append(self.visitQualifiedAggregateFuncArg(arg)) + return args + + def visitQualifiedAggregateFuncArg( + self, ctx: FuncTestCaseParser.QualifiedAggregateFuncArgContext + ): + if ctx.argument() is not None: + return AggregateArgument("", "", "", self.visitArgument(ctx.argument())) + table_name = ctx.Identifier().getText() + return AggregateArgument( + ctx.ColumnName().getText(), "", table_name, scalar_value=None + ) + + def visitTableRows(self, ctx: FuncTestCaseParser.TableRowsContext): + rows = [] + for row in ctx.literalValueList(): + rows.append(self.visitLiteralValueList(row)) + return rows + + def visitTableData(self, ctx: FuncTestCaseParser.TableDataContext): + table_name = ctx.Identifier().getText() + rows = self.visitTableRows(ctx.tableRows()) + column_types = [] + for dataType in ctx.dataType(): + column_types.append(self.visitDataType(dataType)) + return table_name, column_types, rows + + def visitDataColumn(self, ctx: FuncTestCaseParser.DataColumnContext): + column = self.visitLiteralValueList(ctx.literalValueList()) + column_type = ctx.dataType().getText() + return CaseLiteral(value=column, type=column_type) + + def visitLiteralValueList(self, ctx: FuncTestCaseParser.LiteralValueListContext): + values = [] + type_str = "" + for literal in ctx.literal(): + value, curr_type = self.visitLiteral(literal) + if curr_type != "null": + if type_str == "": + type_str = curr_type + elif type_str != curr_type: + raise ParseError("All values in a column must have the same type") + values.append(value) + return values + + def visitLiteral(self, ctx: FuncTestCaseParser.LiteralContext): + if ctx.numericLiteral() is not None: + return self.visitNumericLiteral(ctx.numericLiteral()), "number" + if ctx.StringLiteral() is not None: + return ctx.getText(), "str" + if ctx.BooleanLiteral() is not None: + return ctx.getText(), "bool" + if ctx.DateLiteral() is not None: + return ctx.getText(), "date" + if ctx.TimeLiteral() is not None: + return ctx.getText(), "time" + if ctx.TimestampLiteral() is not None: + return ctx.getText(), "ts" + if ctx.TimestampTzLiteral() is not None: + return ctx.getText(), "tstz" + if ctx.IntervalDayLiteral() is not None: + return ctx.getText(), "iday" + if ctx.IntervalYearLiteral() is not None: + return ctx.getText(), "iyear" + if ctx.NullLiteral() is not None: + return ctx.getText(), "null" + def visitFunc_options(self, ctx: FuncTestCaseParser.Func_optionsContext): options = {} for option in ctx.func_option(): @@ -130,7 +294,7 @@ def visitFloatLiteral(self, ctx: FuncTestCaseParser.FloatLiteralContext): return ctx.NaN().getText() def visitNullArg(self, ctx: FuncTestCaseParser.NullArgContext): - datatype = ctx.datatype().getText() + datatype = ctx.dataType().getText() return CaseLiteral(value=None, type=datatype) def visitIntArg(self, ctx: FuncTestCaseParser.IntArgContext): @@ -199,3 +363,9 @@ def visitSubstraitError(self, ctx: FuncTestCaseParser.SubstraitErrorContext): if ctx.UndefineResult() is not None: return SubstraitError("undefined") return SubstraitError("unknown_error") + + +class ParseError(Exception): + def __init__(self, message="Parsing error occurred"): + self.message = message + super().__init__(self.message) diff --git a/tests/test_extensions.py b/tests/test_extensions.py index 3cb7e5294..bf0b9f2bc 100644 --- a/tests/test_extensions.py +++ b/tests/test_extensions.py @@ -1,15 +1,16 @@ # SPDX-License-Identifier: Apache-2.0 import os +from tests.coverage.case_file_parser import load_all_testcases +from tests.coverage.coverage import get_test_coverage from tests.coverage.extensions import build_type_to_short_type +from tests.coverage.extensions import Extension # NOTE: this test is run as part of pre-commit hook -def test_read_substrait_extensions(): - from tests.coverage.extensions import Extension - - current_dir = os.path.dirname(os.path.abspath(__file__)) - extensions_path = os.path.join(current_dir, "../extensions") +def test_substrait_extension_coverage(): + script_dir = os.path.dirname(os.path.abspath(__file__)) + extensions_path = os.path.join(script_dir, "../extensions") registry = Extension.read_substrait_extensions(extensions_path) assert len(registry.registry) >= 161 num_overloads = sum([len(f) for f in registry.registry.values()]) @@ -19,6 +20,17 @@ def test_read_substrait_extensions(): assert len(registry.aggregate_functions) >= 29 assert len(registry.window_functions) >= 0 + test_case_dir = os.path.join(script_dir, "./cases") + all_test_files = load_all_testcases(test_case_dir) + coverage = get_test_coverage(all_test_files, registry) + + assert coverage.test_count >= 49 + assert coverage.num_covered_function_variants >= 18 + assert coverage.total_function_variants >= 510 + assert ( + coverage.total_function_variants - coverage.num_covered_function_variants + ) <= 492 + def test_build_type_to_short_type(): long_to_short = build_type_to_short_type()