diff --git a/extensions/date_millis.yaml b/extensions/date_millis.yaml new file mode 100644 index 000000000..bc04e7a5f --- /dev/null +++ b/extensions/date_millis.yaml @@ -0,0 +1,9 @@ +%YAML 1.2 +--- +urn: "extension:io.substrait:date_millis" + +types: + - name: date_millis + description: "Date stored as milliseconds since epoch (64-bit)" + structure: + value: str diff --git a/extensions/fixed_size_list.yaml b/extensions/fixed_size_list.yaml new file mode 100644 index 000000000..85ef884fa --- /dev/null +++ b/extensions/fixed_size_list.yaml @@ -0,0 +1,14 @@ +%YAML 1.2 +--- +urn: "extension:io.substrait:fixed_size_list" + +types: + - name: fixed_size_list + description: List with a fixed number of elements + parameters: + - name: value_type + type: dataType + - name: dimension + type: integer + min: 0 + structure: {} diff --git a/extensions/large_containers.yaml b/extensions/large_containers.yaml new file mode 100644 index 000000000..efc67d309 --- /dev/null +++ b/extensions/large_containers.yaml @@ -0,0 +1,19 @@ +%YAML 1.2 +--- +urn: "extension:io.substrait:large_containers" + +types: + - name: large_string + description: "String with 64-bit offsets (max ~8EB)" + structure: + value: str + - name: large_binary + description: "Binary with 64-bit offsets (max ~8EB)" + structure: + value: str + - name: large_list + description: "List with 64-bit offsets" + parameters: + - name: value_type + type: dataType + structure: {} diff --git a/extensions/unsigned_integers.yaml b/extensions/unsigned_integers.yaml new file mode 100644 index 000000000..fb38399f3 --- /dev/null +++ b/extensions/unsigned_integers.yaml @@ -0,0 +1,364 @@ +%YAML 1.2 +--- +urn: "extension:io.substrait:unsigned_integers" + +types: + - name: u8 + description: Unsigned 8-bit integer (0 to 255) + structure: + value: str + - name: u16 + description: Unsigned 16-bit integer (0 to 65535) + structure: + value: str + - name: u32 + description: Unsigned 32-bit integer (0 to 4294967295) + structure: + value: str + - name: u64 + description: Unsigned 64-bit integer (0 to 18446744073709551615) + structure: + value: str + +scalar_functions: + - + name: "add" + description: "Add two unsigned integer values." + impls: + - args: + - name: x + value: u!u8 + - name: y + value: u!u8 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u8 + - args: + - name: x + value: u!u16 + - name: y + value: u!u16 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u16 + - args: + - name: x + value: u!u32 + - name: y + value: u!u32 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u32 + - args: + - name: x + value: u!u64 + - name: y + value: u!u64 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u64 + - + name: "subtract" + description: "Subtract one unsigned integer value from another." + impls: + - args: + - name: x + value: u!u8 + - name: y + value: u!u8 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u8 + - args: + - name: x + value: u!u16 + - name: y + value: u!u16 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u16 + - args: + - name: x + value: u!u32 + - name: y + value: u!u32 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u32 + - args: + - name: x + value: u!u64 + - name: y + value: u!u64 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u64 + - + name: "multiply" + description: "Multiply two unsigned integer values." + impls: + - args: + - name: x + value: u!u8 + - name: y + value: u!u8 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u8 + - args: + - name: x + value: u!u16 + - name: y + value: u!u16 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u16 + - args: + - name: x + value: u!u32 + - name: y + value: u!u32 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u32 + - args: + - name: x + value: u!u64 + - name: y + value: u!u64 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + return: u!u64 + - + name: "divide" + description: > + Divide x by y. Partial values are truncated (rounded towards 0). + impls: + - args: + - name: x + value: u!u8 + - name: y + value: u!u8 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + on_domain_error: + values: [ "NULL", ERROR ] + on_division_by_zero: + values: [ "NULL", ERROR ] + return: u!u8 + - args: + - name: x + value: u!u16 + - name: y + value: u!u16 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + on_domain_error: + values: [ "NULL", ERROR ] + on_division_by_zero: + values: [ "NULL", ERROR ] + return: u!u16 + - args: + - name: x + value: u!u32 + - name: y + value: u!u32 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + on_domain_error: + values: [ "NULL", ERROR ] + on_division_by_zero: + values: [ "NULL", ERROR ] + return: u!u32 + - args: + - name: x + value: u!u64 + - name: y + value: u!u64 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + on_domain_error: + values: [ "NULL", ERROR ] + on_division_by_zero: + values: [ "NULL", ERROR ] + return: u!u64 + - + name: "modulus" + description: > + Calculate the remainder when dividing dividend (x) by divisor (y). + impls: + - args: + - name: x + value: u!u8 + - name: y + value: u!u8 + options: + division_type: + values: [ TRUNCATE, FLOOR ] + overflow: + values: [ SILENT, SATURATE, ERROR ] + on_domain_error: + values: [ "NULL", ERROR ] + return: u!u8 + - args: + - name: x + value: u!u16 + - name: y + value: u!u16 + options: + division_type: + values: [ TRUNCATE, FLOOR ] + overflow: + values: [ SILENT, SATURATE, ERROR ] + on_domain_error: + values: [ "NULL", ERROR ] + return: u!u16 + - args: + - name: x + value: u!u32 + - name: y + value: u!u32 + options: + division_type: + values: [ TRUNCATE, FLOOR ] + overflow: + values: [ SILENT, SATURATE, ERROR ] + on_domain_error: + values: [ "NULL", ERROR ] + return: u!u32 + - args: + - name: x + value: u!u64 + - name: y + value: u!u64 + options: + division_type: + values: [ TRUNCATE, FLOOR ] + overflow: + values: [ SILENT, SATURATE, ERROR ] + on_domain_error: + values: [ "NULL", ERROR ] + return: u!u64 + +aggregate_functions: + - name: "sum" + description: Sum a set of unsigned integer values. The sum of zero elements yields null. + impls: + - args: + - name: x + value: u!u8 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - args: + - name: x + value: u!u16 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - args: + - name: x + value: u!u32 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - args: + - name: x + value: u!u64 + options: + overflow: + values: [ SILENT, SATURATE, ERROR ] + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - name: "min" + description: Min of a set of unsigned integer values. + impls: + - args: + - name: x + value: u!u8 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u8? + return: u!u8? + - args: + - name: x + value: u!u16 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u16? + return: u!u16? + - args: + - name: x + value: u!u32 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u32? + return: u!u32? + - args: + - name: x + value: u!u64 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? + - name: "max" + description: Max of a set of unsigned integer values. + impls: + - args: + - name: x + value: u!u8 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u8? + return: u!u8? + - args: + - name: x + value: u!u16 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u16? + return: u!u16? + - args: + - name: x + value: u!u32 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u32? + return: u!u32? + - args: + - name: x + value: u!u64 + nullability: DECLARED_OUTPUT + decomposable: MANY + intermediate: u!u64? + return: u!u64? diff --git a/grammar/FuncTestCaseParser.g4 b/grammar/FuncTestCaseParser.g4 index a83552bfa..b82ca929d 100644 --- a/grammar/FuncTestCaseParser.g4 +++ b/grammar/FuncTestCaseParser.g4 @@ -69,6 +69,7 @@ argument | precisionTimestampTZArg | listArg | lambdaArg + | udtArg | Identifier // Bare identifiers (for lambda parameters) ; @@ -211,6 +212,10 @@ lambdaArg : literalLambda DoubleColon funcType ; +udtArg + : literal DoubleColon UserDefined Identifier isnull=QMark? + ; + literalList : OBracket (literal (Comma literal)*)? CBracket ; diff --git a/site/docs/extensions/generate_function_docs.py b/site/docs/extensions/generate_function_docs.py index 5bb2171d7..567e06894 100644 --- a/site/docs/extensions/generate_function_docs.py +++ b/site/docs/extensions/generate_function_docs.py @@ -21,7 +21,7 @@ def write_markdown(file_obj: dict, file_name: str) -> None: mdFile.new_line(f"{key}: {value}") for function_classification, value in file_obj.items(): - if function_classification == "urn": + if function_classification in ("urn", "dependencies"): continue function_classification_str = function_classification.replace("_", " ").title() mdFile.new_header(level=2, title=f"{function_classification_str}") diff --git a/tests/baseline.json b/tests/baseline.json index 13e7fc08f..563fc9e4d 100644 --- a/tests/baseline.json +++ b/tests/baseline.json @@ -1,16 +1,16 @@ { "registry": { - "extension_count": 15, - "dependency_count": 15, + "extension_count": 16, + "dependency_count": 21, "function_count": 170, - "num_aggregate_functions": 29, - "num_scalar_functions": 166, + "num_aggregate_functions": 32, + "num_scalar_functions": 171, "num_window_functions": 11, - "num_function_overloads": 529 + "num_function_overloads": 561 }, "coverage": { - "total_test_count": 1136, - "num_function_variants": 529, - "num_covered_function_variants": 241 + "total_test_count": 1172, + "num_function_variants": 561, + "num_covered_function_variants": 273 } } diff --git a/tests/cases/arithmetic_unsigned/add.test b/tests/cases/arithmetic_unsigned/add.test new file mode 100644 index 000000000..72488adb4 --- /dev/null +++ b/tests/cases/arithmetic_unsigned/add.test @@ -0,0 +1,8 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +add('200'::u!u8, '50'::u!u8) = '250'::u!u8 +add('50000'::u!u16, '10000'::u!u16) = '60000'::u!u16 +add('3000000000'::u!u32, '1000000000'::u!u32) = '4000000000'::u!u32 +add('10000000000000000000'::u!u64, '1000000000000000000'::u!u64) = '11000000000000000000'::u!u64 diff --git a/tests/cases/arithmetic_unsigned/divide.test b/tests/cases/arithmetic_unsigned/divide.test new file mode 100644 index 000000000..a53c8ec6c --- /dev/null +++ b/tests/cases/arithmetic_unsigned/divide.test @@ -0,0 +1,8 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +divide('250'::u!u8, '5'::u!u8) = '50'::u!u8 +divide('60000'::u!u16, '100'::u!u16) = '600'::u!u16 +divide('4000000000'::u!u32, '200'::u!u32) = '20000000'::u!u32 +divide('10000000000000000000'::u!u64, '5000'::u!u64) = '2000000000000000'::u!u64 diff --git a/tests/cases/arithmetic_unsigned/max.test b/tests/cases/arithmetic_unsigned/max.test new file mode 100644 index 000000000..a8592109f --- /dev/null +++ b/tests/cases/arithmetic_unsigned/max.test @@ -0,0 +1,8 @@ +### SUBSTRAIT_AGGREGATE_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +max(('20', '3', '1', '10', '0', '5')::u!u8) = '20'::u!u8 +max(('32768', '32767', '20000', '30000')::u!u16) = '32768'::u!u16 +max(('214748648', '214748647', '21470048', '4000000')::u!u32) = '214748648'::u!u32 +max(('2000000000', '3217908979', '629000000', '100000000', '0', '987654321')::u!u64) = '3217908979'::u!u64 diff --git a/tests/cases/arithmetic_unsigned/min.test b/tests/cases/arithmetic_unsigned/min.test new file mode 100644 index 000000000..fbdd3ce15 --- /dev/null +++ b/tests/cases/arithmetic_unsigned/min.test @@ -0,0 +1,8 @@ +### SUBSTRAIT_AGGREGATE_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +min(('20', '3', '1', '10', '0', '5')::u!u8) = '0'::u!u8 +min(('32768', '32767', '20000', '30000')::u!u16) = '20000'::u!u16 +min(('214748648', '214748647', '21470048', '4000000')::u!u32) = '4000000'::u!u32 +min(('2000000000', '3217908979', '629000000', '100000000', '0', '987654321')::u!u64) = '0'::u!u64 diff --git a/tests/cases/arithmetic_unsigned/modulus.test b/tests/cases/arithmetic_unsigned/modulus.test new file mode 100644 index 000000000..d53824ba4 --- /dev/null +++ b/tests/cases/arithmetic_unsigned/modulus.test @@ -0,0 +1,8 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +modulus('250'::u!u8, '100'::u!u8) = '50'::u!u8 +modulus('60000'::u!u16, '7000'::u!u16) = '4000'::u!u16 +modulus('4000000000'::u!u32, '300000000'::u!u32) = '100000000'::u!u32 +modulus('10000000000000000000'::u!u64, '3000000000000000000'::u!u64) = '1000000000000000000'::u!u64 diff --git a/tests/cases/arithmetic_unsigned/multiply.test b/tests/cases/arithmetic_unsigned/multiply.test new file mode 100644 index 000000000..86898d183 --- /dev/null +++ b/tests/cases/arithmetic_unsigned/multiply.test @@ -0,0 +1,8 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +multiply('25'::u!u8, '5'::u!u8) = '125'::u!u8 +multiply('200'::u!u16, '100'::u!u16) = '20000'::u!u16 +multiply('300'::u!u32, '200'::u!u32) = '60000'::u!u32 +multiply('80000'::u!u64, '5000'::u!u64) = '400000000'::u!u64 diff --git a/tests/cases/arithmetic_unsigned/subtract.test b/tests/cases/arithmetic_unsigned/subtract.test new file mode 100644 index 000000000..60d46bd48 --- /dev/null +++ b/tests/cases/arithmetic_unsigned/subtract.test @@ -0,0 +1,8 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +subtract('250'::u!u8, '50'::u!u8) = '200'::u!u8 +subtract('60000'::u!u16, '10000'::u!u16) = '50000'::u!u16 +subtract('4000000000'::u!u32, '1000000000'::u!u32) = '3000000000'::u!u32 +subtract('11000000000000000000'::u!u64, '1000000000000000000'::u!u64) = '10000000000000000000'::u!u64 diff --git a/tests/cases/arithmetic_unsigned/sum.test b/tests/cases/arithmetic_unsigned/sum.test new file mode 100644 index 000000000..5cdcc2933 --- /dev/null +++ b/tests/cases/arithmetic_unsigned/sum.test @@ -0,0 +1,8 @@ +### SUBSTRAIT_AGGREGATE_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/unsigned_integers.yaml' + +# basic: Basic unsigned integer examples +sum(('0', '1', '2', '20')::u!u8) = '23'::u!u64 +sum(('100', '200', '50')::u!u16) = '350'::u!u64 +sum(('2000000', '3217908', '629000', '100000', '0', '987654')::u!u32) = '6934562'::u!u64 +sum(('1000000000000', '2000000000000', '3000000000000')::u!u64) = '6000000000000'::u!u64 diff --git a/tests/coverage/antlr_parser/FuncTestCaseParser.py b/tests/coverage/antlr_parser/FuncTestCaseParser.py index c9f18894e..108d877f0 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParser.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.py @@ -11,7 +11,7 @@ def serializedATN(): return [ - 4,1,125,711,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6, + 4,1,125,721,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6, 7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7, 13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2, 20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7, @@ -23,256 +23,260 @@ def serializedATN(): 59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7, 65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2, 72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7, - 78,2,79,7,79,1,0,1,0,4,0,163,8,0,11,0,12,0,164,1,0,1,0,1,1,1,1,1, - 1,5,1,172,8,1,10,1,12,1,175,9,1,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3, - 1,3,1,3,1,3,5,3,188,8,3,10,3,12,3,191,9,3,1,4,1,4,1,4,1,4,1,4,1, - 5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,208,8,6,1,6,1,6,1,6,1, - 7,3,7,214,8,7,1,7,4,7,217,8,7,11,7,12,7,218,1,7,3,7,222,8,7,1,7, - 4,7,225,8,7,11,7,12,7,226,3,7,229,8,7,1,8,1,8,1,8,5,8,234,8,8,10, - 8,12,8,237,9,8,1,9,1,9,3,9,241,8,9,1,10,1,10,1,10,1,10,1,10,1,10, - 1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10, - 1,10,1,10,3,10,264,8,10,1,11,1,11,1,11,1,11,1,11,3,11,271,8,11,1, - 11,1,11,1,11,1,12,1,12,1,12,1,12,3,12,280,8,12,1,12,1,12,1,12,1, - 12,1,12,1,12,3,12,288,8,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3, - 12,297,8,12,1,13,1,13,1,13,1,13,1,13,1,13,5,13,305,8,13,10,13,12, - 13,308,9,13,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,5,14,318,8,14, - 10,14,12,14,321,9,14,3,14,323,8,14,1,14,1,14,1,15,1,15,1,15,1,15, - 1,16,1,16,1,16,1,16,5,16,335,8,16,10,16,12,16,338,9,16,3,16,340, - 8,16,1,16,1,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17, - 3,17,354,8,17,1,18,1,18,1,18,5,18,359,8,18,10,18,12,18,362,9,18, - 1,19,1,19,1,19,5,19,367,8,19,10,19,12,19,370,9,19,1,20,1,20,1,20, - 1,20,3,20,376,8,20,1,21,1,21,1,21,1,21,3,21,382,8,21,1,22,1,22,1, - 22,3,22,387,8,22,1,23,1,23,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1, - 25,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,28,1,28,1,28,1,28,1, - 29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,32,1, - 32,1,32,1,32,1,33,1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,35,1,35,1, - 35,1,35,1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1, - 38,1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1, - 42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,5,44,475, - 8,44,10,44,12,44,478,9,44,3,44,480,8,44,1,44,1,44,1,45,1,45,1,45, - 1,45,1,45,1,45,1,46,1,46,1,46,1,46,1,46,4,46,495,8,46,11,46,12,46, - 496,1,46,3,46,500,8,46,1,47,1,47,1,47,1,47,1,47,1,48,1,48,3,48,509, - 8,48,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49, - 3,49,523,8,49,1,49,1,49,1,49,3,49,528,8,49,3,49,530,8,49,1,50,1, - 50,3,50,534,8,50,1,51,1,51,3,51,538,8,51,1,52,1,52,3,52,542,8,52, - 1,53,1,53,3,53,546,8,53,1,54,1,54,3,54,550,8,54,1,55,1,55,3,55,554, - 8,55,1,56,1,56,3,56,558,8,56,1,57,1,57,3,57,562,8,57,1,58,1,58,3, - 58,566,8,58,1,59,1,59,3,59,570,8,59,1,60,1,60,3,60,574,8,60,1,60, - 1,60,1,60,1,60,3,60,580,8,60,1,61,1,61,3,61,584,8,61,1,61,1,61,1, - 61,1,61,1,62,1,62,3,62,592,8,62,1,62,1,62,1,62,1,62,1,63,1,63,3, - 63,600,8,63,1,63,1,63,1,63,1,63,1,64,1,64,3,64,608,8,64,1,64,1,64, - 1,64,1,64,1,64,1,64,3,64,616,8,64,1,65,1,65,3,65,620,8,65,1,65,1, - 65,1,65,1,65,1,66,1,66,3,66,628,8,66,1,66,1,66,1,66,1,66,1,67,1, - 67,3,67,636,8,67,1,67,1,67,1,67,1,67,1,68,1,68,3,68,644,8,68,1,68, - 1,68,1,68,1,68,1,69,1,69,3,69,652,8,69,1,69,1,69,1,69,1,69,1,69, - 1,69,1,70,1,70,1,70,1,70,1,70,5,70,665,8,70,10,70,12,70,668,9,70, - 1,70,1,70,3,70,672,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,3,71,683,8,71,1,72,1,72,1,73,1,73,1,74,1,74,1,74,1,74,1,75, - 1,75,1,76,1,76,1,77,1,77,1,77,5,77,700,8,77,10,77,12,77,703,9,77, - 1,78,1,78,1,79,1,79,3,79,709,8,79,1,79,0,0,80,0,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,106,108,110,112,114,116,118,120,122,124,126,128,130,132, - 134,136,138,140,142,144,146,148,150,152,154,156,158,0,22,1,0,3,4, + 78,2,79,7,79,2,80,7,80,1,0,1,0,4,0,165,8,0,11,0,12,0,166,1,0,1,0, + 1,1,1,1,1,1,5,1,174,8,1,10,1,12,1,177,9,1,1,2,1,2,1,2,1,2,1,2,1, + 3,1,3,1,3,1,3,1,3,1,3,5,3,190,8,3,10,3,12,3,193,9,3,1,4,1,4,1,4, + 1,4,1,4,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,210,8,6,1,6, + 1,6,1,6,1,7,3,7,216,8,7,1,7,4,7,219,8,7,11,7,12,7,220,1,7,3,7,224, + 8,7,1,7,4,7,227,8,7,11,7,12,7,228,3,7,231,8,7,1,8,1,8,1,8,5,8,236, + 8,8,10,8,12,8,239,9,8,1,9,1,9,3,9,243,8,9,1,10,1,10,1,10,1,10,1, + 10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1, + 10,1,10,1,10,1,10,1,10,3,10,267,8,10,1,11,1,11,1,11,1,11,1,11,3, + 11,274,8,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,3,12,283,8,12,1,12, + 1,12,1,12,1,12,1,12,1,12,3,12,291,8,12,1,12,1,12,1,12,1,12,1,12, + 1,12,1,12,3,12,300,8,12,1,13,1,13,1,13,1,13,1,13,1,13,5,13,308,8, + 13,10,13,12,13,311,9,13,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14, + 5,14,321,8,14,10,14,12,14,324,9,14,3,14,326,8,14,1,14,1,14,1,15, + 1,15,1,15,1,15,1,16,1,16,1,16,1,16,5,16,338,8,16,10,16,12,16,341, + 9,16,3,16,343,8,16,1,16,1,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17, + 1,17,1,17,1,17,3,17,357,8,17,1,18,1,18,1,18,5,18,362,8,18,10,18, + 12,18,365,9,18,1,19,1,19,1,19,5,19,370,8,19,10,19,12,19,373,9,19, + 1,20,1,20,1,20,1,20,3,20,379,8,20,1,21,1,21,1,21,1,21,3,21,385,8, + 21,1,22,1,22,1,22,3,22,390,8,22,1,23,1,23,1,24,1,24,1,24,1,24,1, + 25,1,25,1,25,1,25,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,28,1, + 28,1,28,1,28,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,31,1,31,1, + 31,1,31,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,34,1,34,1,34,1, + 34,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,1, + 38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,41,1, + 41,1,41,1,41,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,44,1,44,1, + 44,1,44,1,44,3,44,479,8,44,1,45,1,45,1,45,1,45,5,45,485,8,45,10, + 45,12,45,488,9,45,3,45,490,8,45,1,45,1,45,1,46,1,46,1,46,1,46,1, + 46,1,46,1,47,1,47,1,47,1,47,1,47,4,47,505,8,47,11,47,12,47,506,1, + 47,3,47,510,8,47,1,48,1,48,1,48,1,48,1,48,1,49,1,49,3,49,519,8,49, + 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50, + 533,8,50,1,50,1,50,1,50,3,50,538,8,50,3,50,540,8,50,1,51,1,51,3, + 51,544,8,51,1,52,1,52,3,52,548,8,52,1,53,1,53,3,53,552,8,53,1,54, + 1,54,3,54,556,8,54,1,55,1,55,3,55,560,8,55,1,56,1,56,3,56,564,8, + 56,1,57,1,57,3,57,568,8,57,1,58,1,58,3,58,572,8,58,1,59,1,59,3,59, + 576,8,59,1,60,1,60,3,60,580,8,60,1,61,1,61,3,61,584,8,61,1,61,1, + 61,1,61,1,61,3,61,590,8,61,1,62,1,62,3,62,594,8,62,1,62,1,62,1,62, + 1,62,1,63,1,63,3,63,602,8,63,1,63,1,63,1,63,1,63,1,64,1,64,3,64, + 610,8,64,1,64,1,64,1,64,1,64,1,65,1,65,3,65,618,8,65,1,65,1,65,1, + 65,1,65,1,65,1,65,3,65,626,8,65,1,66,1,66,3,66,630,8,66,1,66,1,66, + 1,66,1,66,1,67,1,67,3,67,638,8,67,1,67,1,67,1,67,1,67,1,68,1,68, + 3,68,646,8,68,1,68,1,68,1,68,1,68,1,69,1,69,3,69,654,8,69,1,69,1, + 69,1,69,1,69,1,70,1,70,3,70,662,8,70,1,70,1,70,1,70,1,70,1,70,1, + 70,1,71,1,71,1,71,1,71,1,71,5,71,675,8,71,10,71,12,71,678,9,71,1, + 71,1,71,3,71,682,8,71,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1, + 72,3,72,693,8,72,1,73,1,73,1,74,1,74,1,75,1,75,1,75,1,75,1,76,1, + 76,1,77,1,77,1,78,1,78,1,78,5,78,710,8,78,10,78,12,78,713,9,78,1, + 79,1,79,1,80,1,80,3,80,719,8,80,1,80,0,0,81,0,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,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134, + 136,138,140,142,144,146,148,150,152,154,156,158,160,0,22,1,0,3,4, 2,0,18,18,26,26,2,0,53,53,81,81,2,0,60,60,82,82,2,0,61,61,83,83, 1,0,54,57,1,0,58,59,2,0,62,62,84,84,2,0,63,63,85,85,2,0,66,66,86, 86,2,0,67,67,87,87,2,0,73,73,92,92,2,0,74,74,93,93,2,0,75,75,94, 94,2,0,69,69,88,88,2,0,70,70,89,89,2,0,71,71,90,90,2,0,72,72,91, 91,1,0,10,11,3,0,12,13,21,22,124,124,5,0,14,20,23,23,27,27,44,44, - 124,124,2,0,23,23,119,120,738,0,160,1,0,0,0,2,168,1,0,0,0,4,176, - 1,0,0,0,6,181,1,0,0,0,8,192,1,0,0,0,10,197,1,0,0,0,12,199,1,0,0, - 0,14,228,1,0,0,0,16,230,1,0,0,0,18,240,1,0,0,0,20,263,1,0,0,0,22, - 265,1,0,0,0,24,296,1,0,0,0,26,298,1,0,0,0,28,313,1,0,0,0,30,326, - 1,0,0,0,32,330,1,0,0,0,34,353,1,0,0,0,36,355,1,0,0,0,38,363,1,0, - 0,0,40,375,1,0,0,0,42,381,1,0,0,0,44,386,1,0,0,0,46,388,1,0,0,0, - 48,390,1,0,0,0,50,394,1,0,0,0,52,398,1,0,0,0,54,402,1,0,0,0,56,406, - 1,0,0,0,58,410,1,0,0,0,60,414,1,0,0,0,62,418,1,0,0,0,64,422,1,0, - 0,0,66,426,1,0,0,0,68,430,1,0,0,0,70,434,1,0,0,0,72,438,1,0,0,0, - 74,442,1,0,0,0,76,446,1,0,0,0,78,450,1,0,0,0,80,454,1,0,0,0,82,458, - 1,0,0,0,84,462,1,0,0,0,86,466,1,0,0,0,88,470,1,0,0,0,90,483,1,0, - 0,0,92,499,1,0,0,0,94,501,1,0,0,0,96,508,1,0,0,0,98,529,1,0,0,0, - 100,531,1,0,0,0,102,535,1,0,0,0,104,539,1,0,0,0,106,543,1,0,0,0, - 108,547,1,0,0,0,110,551,1,0,0,0,112,555,1,0,0,0,114,559,1,0,0,0, - 116,563,1,0,0,0,118,567,1,0,0,0,120,571,1,0,0,0,122,581,1,0,0,0, - 124,589,1,0,0,0,126,597,1,0,0,0,128,605,1,0,0,0,130,617,1,0,0,0, - 132,625,1,0,0,0,134,633,1,0,0,0,136,641,1,0,0,0,138,649,1,0,0,0, - 140,671,1,0,0,0,142,682,1,0,0,0,144,684,1,0,0,0,146,686,1,0,0,0, - 148,688,1,0,0,0,150,692,1,0,0,0,152,694,1,0,0,0,154,696,1,0,0,0, - 156,704,1,0,0,0,158,708,1,0,0,0,160,162,3,2,1,0,161,163,3,14,7,0, - 162,161,1,0,0,0,163,164,1,0,0,0,164,162,1,0,0,0,164,165,1,0,0,0, - 165,166,1,0,0,0,166,167,5,0,0,1,167,1,1,0,0,0,168,169,3,4,2,0,169, - 173,3,6,3,0,170,172,3,8,4,0,171,170,1,0,0,0,172,175,1,0,0,0,173, - 171,1,0,0,0,173,174,1,0,0,0,174,3,1,0,0,0,175,173,1,0,0,0,176,177, - 5,2,0,0,177,178,7,0,0,0,178,179,5,115,0,0,179,180,5,7,0,0,180,5, - 1,0,0,0,181,182,5,2,0,0,182,183,5,5,0,0,183,184,5,115,0,0,184,189, - 5,45,0,0,185,186,5,114,0,0,186,188,5,45,0,0,187,185,1,0,0,0,188, - 191,1,0,0,0,189,187,1,0,0,0,189,190,1,0,0,0,190,7,1,0,0,0,191,189, - 1,0,0,0,192,193,5,2,0,0,193,194,5,6,0,0,194,195,5,115,0,0,195,196, - 5,45,0,0,196,9,1,0,0,0,197,198,5,8,0,0,198,11,1,0,0,0,199,200,3, - 158,79,0,200,201,5,110,0,0,201,202,3,16,8,0,202,207,5,111,0,0,203, - 204,5,112,0,0,204,205,3,154,77,0,205,206,5,113,0,0,206,208,1,0,0, - 0,207,203,1,0,0,0,207,208,1,0,0,0,208,209,1,0,0,0,209,210,5,103, - 0,0,210,211,3,18,9,0,211,13,1,0,0,0,212,214,3,10,5,0,213,212,1,0, - 0,0,213,214,1,0,0,0,214,216,1,0,0,0,215,217,3,12,6,0,216,215,1,0, - 0,0,217,218,1,0,0,0,218,216,1,0,0,0,218,219,1,0,0,0,219,229,1,0, - 0,0,220,222,3,10,5,0,221,220,1,0,0,0,221,222,1,0,0,0,222,224,1,0, - 0,0,223,225,3,22,11,0,224,223,1,0,0,0,225,226,1,0,0,0,226,224,1, - 0,0,0,226,227,1,0,0,0,227,229,1,0,0,0,228,213,1,0,0,0,228,221,1, - 0,0,0,229,15,1,0,0,0,230,235,3,20,10,0,231,232,5,114,0,0,232,234, - 3,20,10,0,233,231,1,0,0,0,234,237,1,0,0,0,235,233,1,0,0,0,235,236, - 1,0,0,0,236,17,1,0,0,0,237,235,1,0,0,0,238,241,3,20,10,0,239,241, - 3,146,73,0,240,238,1,0,0,0,240,239,1,0,0,0,241,19,1,0,0,0,242,264, - 3,48,24,0,243,264,3,50,25,0,244,264,3,52,26,0,245,264,3,56,28,0, - 246,264,3,58,29,0,247,264,3,54,27,0,248,264,3,60,30,0,249,264,3, - 62,31,0,250,264,3,64,32,0,251,264,3,66,33,0,252,264,3,68,34,0,253, - 264,3,70,35,0,254,264,3,72,36,0,255,264,3,74,37,0,256,264,3,76,38, - 0,257,264,3,78,39,0,258,264,3,80,40,0,259,264,3,82,41,0,260,264, - 3,84,42,0,261,264,3,86,43,0,262,264,5,124,0,0,263,242,1,0,0,0,263, - 243,1,0,0,0,263,244,1,0,0,0,263,245,1,0,0,0,263,246,1,0,0,0,263, - 247,1,0,0,0,263,248,1,0,0,0,263,249,1,0,0,0,263,250,1,0,0,0,263, - 251,1,0,0,0,263,252,1,0,0,0,263,253,1,0,0,0,263,254,1,0,0,0,263, - 255,1,0,0,0,263,256,1,0,0,0,263,257,1,0,0,0,263,258,1,0,0,0,263, - 259,1,0,0,0,263,260,1,0,0,0,263,261,1,0,0,0,263,262,1,0,0,0,264, - 21,1,0,0,0,265,270,3,24,12,0,266,267,5,112,0,0,267,268,3,154,77, - 0,268,269,5,113,0,0,269,271,1,0,0,0,270,266,1,0,0,0,270,271,1,0, - 0,0,271,272,1,0,0,0,272,273,5,103,0,0,273,274,3,18,9,0,274,23,1, - 0,0,0,275,276,3,26,13,0,276,277,3,158,79,0,277,279,5,110,0,0,278, - 280,3,36,18,0,279,278,1,0,0,0,279,280,1,0,0,0,280,281,1,0,0,0,281, - 282,5,111,0,0,282,297,1,0,0,0,283,284,3,28,14,0,284,285,3,158,79, - 0,285,287,5,110,0,0,286,288,3,38,19,0,287,286,1,0,0,0,287,288,1, - 0,0,0,288,289,1,0,0,0,289,290,5,111,0,0,290,297,1,0,0,0,291,292, - 3,158,79,0,292,293,5,110,0,0,293,294,3,30,15,0,294,295,5,111,0,0, - 295,297,1,0,0,0,296,275,1,0,0,0,296,283,1,0,0,0,296,291,1,0,0,0, - 297,25,1,0,0,0,298,299,5,9,0,0,299,300,5,124,0,0,300,301,5,110,0, - 0,301,306,3,96,48,0,302,303,5,114,0,0,303,305,3,96,48,0,304,302, - 1,0,0,0,305,308,1,0,0,0,306,304,1,0,0,0,306,307,1,0,0,0,307,309, - 1,0,0,0,308,306,1,0,0,0,309,310,5,111,0,0,310,311,5,103,0,0,311, - 312,3,28,14,0,312,27,1,0,0,0,313,322,5,110,0,0,314,319,3,32,16,0, - 315,316,5,114,0,0,316,318,3,32,16,0,317,315,1,0,0,0,318,321,1,0, - 0,0,319,317,1,0,0,0,319,320,1,0,0,0,320,323,1,0,0,0,321,319,1,0, - 0,0,322,314,1,0,0,0,322,323,1,0,0,0,323,324,1,0,0,0,324,325,5,111, - 0,0,325,29,1,0,0,0,326,327,3,32,16,0,327,328,5,97,0,0,328,329,3, - 96,48,0,329,31,1,0,0,0,330,339,5,110,0,0,331,336,3,34,17,0,332,333, - 5,114,0,0,333,335,3,34,17,0,334,332,1,0,0,0,335,338,1,0,0,0,336, - 334,1,0,0,0,336,337,1,0,0,0,337,340,1,0,0,0,338,336,1,0,0,0,339, - 331,1,0,0,0,339,340,1,0,0,0,340,341,1,0,0,0,341,342,5,111,0,0,342, - 33,1,0,0,0,343,354,5,44,0,0,344,354,3,44,22,0,345,354,5,27,0,0,346, - 354,5,45,0,0,347,354,5,31,0,0,348,354,5,30,0,0,349,354,5,29,0,0, - 350,354,5,28,0,0,351,354,5,42,0,0,352,354,5,43,0,0,353,343,1,0,0, - 0,353,344,1,0,0,0,353,345,1,0,0,0,353,346,1,0,0,0,353,347,1,0,0, - 0,353,348,1,0,0,0,353,349,1,0,0,0,353,350,1,0,0,0,353,351,1,0,0, - 0,353,352,1,0,0,0,354,35,1,0,0,0,355,360,3,40,20,0,356,357,5,114, - 0,0,357,359,3,40,20,0,358,356,1,0,0,0,359,362,1,0,0,0,360,358,1, - 0,0,0,360,361,1,0,0,0,361,37,1,0,0,0,362,360,1,0,0,0,363,368,3,42, - 21,0,364,365,5,114,0,0,365,367,3,42,21,0,366,364,1,0,0,0,367,370, - 1,0,0,0,368,366,1,0,0,0,368,369,1,0,0,0,369,39,1,0,0,0,370,368,1, - 0,0,0,371,372,5,124,0,0,372,373,5,118,0,0,373,376,5,46,0,0,374,376, - 3,20,10,0,375,371,1,0,0,0,375,374,1,0,0,0,376,41,1,0,0,0,377,378, - 5,46,0,0,378,379,5,97,0,0,379,382,3,96,48,0,380,382,3,20,10,0,381, - 377,1,0,0,0,381,380,1,0,0,0,382,43,1,0,0,0,383,387,5,25,0,0,384, - 387,5,24,0,0,385,387,3,46,23,0,386,383,1,0,0,0,386,384,1,0,0,0,386, - 385,1,0,0,0,387,45,1,0,0,0,388,389,7,1,0,0,389,47,1,0,0,0,390,391, - 5,44,0,0,391,392,5,97,0,0,392,393,3,96,48,0,393,49,1,0,0,0,394,395, - 5,24,0,0,395,396,5,97,0,0,396,397,3,106,53,0,397,51,1,0,0,0,398, - 399,3,44,22,0,399,400,5,97,0,0,400,401,3,108,54,0,401,53,1,0,0,0, - 402,403,3,44,22,0,403,404,5,97,0,0,404,405,3,128,64,0,405,55,1,0, - 0,0,406,407,5,27,0,0,407,408,5,97,0,0,408,409,3,100,50,0,409,57, - 1,0,0,0,410,411,5,45,0,0,411,412,5,97,0,0,412,413,3,102,51,0,413, - 59,1,0,0,0,414,415,5,31,0,0,415,416,5,97,0,0,416,417,3,110,55,0, - 417,61,1,0,0,0,418,419,5,30,0,0,419,420,5,97,0,0,420,421,3,112,56, - 0,421,63,1,0,0,0,422,423,5,29,0,0,423,424,5,97,0,0,424,425,3,114, - 57,0,425,65,1,0,0,0,426,427,5,28,0,0,427,428,5,97,0,0,428,429,3, - 116,58,0,429,67,1,0,0,0,430,431,5,42,0,0,431,432,5,97,0,0,432,433, - 3,118,59,0,433,69,1,0,0,0,434,435,5,43,0,0,435,436,5,97,0,0,436, - 437,3,120,60,0,437,71,1,0,0,0,438,439,5,45,0,0,439,440,5,97,0,0, - 440,441,3,122,61,0,441,73,1,0,0,0,442,443,5,45,0,0,443,444,5,97, - 0,0,444,445,3,124,62,0,445,75,1,0,0,0,446,447,5,45,0,0,447,448,5, - 97,0,0,448,449,3,126,63,0,449,77,1,0,0,0,450,451,5,30,0,0,451,452, - 5,97,0,0,452,453,3,130,65,0,453,79,1,0,0,0,454,455,5,29,0,0,455, - 456,5,97,0,0,456,457,3,132,66,0,457,81,1,0,0,0,458,459,5,28,0,0, - 459,460,5,97,0,0,460,461,3,134,67,0,461,83,1,0,0,0,462,463,3,88, - 44,0,463,464,5,97,0,0,464,465,3,136,68,0,465,85,1,0,0,0,466,467, - 3,90,45,0,467,468,5,97,0,0,468,469,3,138,69,0,469,87,1,0,0,0,470, - 479,5,112,0,0,471,476,3,34,17,0,472,473,5,114,0,0,473,475,3,34,17, - 0,474,472,1,0,0,0,475,478,1,0,0,0,476,474,1,0,0,0,476,477,1,0,0, - 0,477,480,1,0,0,0,478,476,1,0,0,0,479,471,1,0,0,0,479,480,1,0,0, - 0,480,481,1,0,0,0,481,482,5,113,0,0,482,89,1,0,0,0,483,484,5,110, - 0,0,484,485,3,92,46,0,485,486,5,122,0,0,486,487,3,94,47,0,487,488, - 5,111,0,0,488,91,1,0,0,0,489,500,5,124,0,0,490,491,5,110,0,0,491, - 494,5,124,0,0,492,493,5,114,0,0,493,495,5,124,0,0,494,492,1,0,0, - 0,495,496,1,0,0,0,496,494,1,0,0,0,496,497,1,0,0,0,497,498,1,0,0, - 0,498,500,5,111,0,0,499,489,1,0,0,0,499,490,1,0,0,0,500,93,1,0,0, - 0,501,502,3,158,79,0,502,503,5,110,0,0,503,504,3,16,8,0,504,505, - 5,111,0,0,505,95,1,0,0,0,506,509,3,98,49,0,507,509,3,142,71,0,508, - 506,1,0,0,0,508,507,1,0,0,0,509,97,1,0,0,0,510,530,3,100,50,0,511, - 530,3,106,53,0,512,530,3,108,54,0,513,530,3,102,51,0,514,530,3,104, - 52,0,515,530,3,114,57,0,516,530,3,116,58,0,517,530,3,110,55,0,518, - 530,3,112,56,0,519,530,3,118,59,0,520,522,5,68,0,0,521,523,5,116, - 0,0,522,521,1,0,0,0,522,523,1,0,0,0,523,530,1,0,0,0,524,525,5,80, - 0,0,525,527,5,124,0,0,526,528,5,116,0,0,527,526,1,0,0,0,527,528, - 1,0,0,0,528,530,1,0,0,0,529,510,1,0,0,0,529,511,1,0,0,0,529,512, - 1,0,0,0,529,513,1,0,0,0,529,514,1,0,0,0,529,515,1,0,0,0,529,516, - 1,0,0,0,529,517,1,0,0,0,529,518,1,0,0,0,529,519,1,0,0,0,529,520, - 1,0,0,0,529,524,1,0,0,0,530,99,1,0,0,0,531,533,7,2,0,0,532,534,5, - 116,0,0,533,532,1,0,0,0,533,534,1,0,0,0,534,101,1,0,0,0,535,537, - 7,3,0,0,536,538,5,116,0,0,537,536,1,0,0,0,537,538,1,0,0,0,538,103, - 1,0,0,0,539,541,7,4,0,0,540,542,5,116,0,0,541,540,1,0,0,0,541,542, - 1,0,0,0,542,105,1,0,0,0,543,545,7,5,0,0,544,546,5,116,0,0,545,544, - 1,0,0,0,545,546,1,0,0,0,546,107,1,0,0,0,547,549,7,6,0,0,548,550, - 5,116,0,0,549,548,1,0,0,0,549,550,1,0,0,0,550,109,1,0,0,0,551,553, - 5,64,0,0,552,554,5,116,0,0,553,552,1,0,0,0,553,554,1,0,0,0,554,111, - 1,0,0,0,555,557,5,65,0,0,556,558,5,116,0,0,557,556,1,0,0,0,557,558, - 1,0,0,0,558,113,1,0,0,0,559,561,7,7,0,0,560,562,5,116,0,0,561,560, - 1,0,0,0,561,562,1,0,0,0,562,115,1,0,0,0,563,565,7,8,0,0,564,566, - 5,116,0,0,565,564,1,0,0,0,565,566,1,0,0,0,566,117,1,0,0,0,567,569, - 7,9,0,0,568,570,5,116,0,0,569,568,1,0,0,0,569,570,1,0,0,0,570,119, - 1,0,0,0,571,573,7,10,0,0,572,574,5,116,0,0,573,572,1,0,0,0,573,574, - 1,0,0,0,574,579,1,0,0,0,575,576,5,40,0,0,576,577,3,144,72,0,577, - 578,5,41,0,0,578,580,1,0,0,0,579,575,1,0,0,0,579,580,1,0,0,0,580, - 121,1,0,0,0,581,583,7,11,0,0,582,584,5,116,0,0,583,582,1,0,0,0,583, - 584,1,0,0,0,584,585,1,0,0,0,585,586,5,40,0,0,586,587,3,144,72,0, - 587,588,5,41,0,0,588,123,1,0,0,0,589,591,7,12,0,0,590,592,5,116, - 0,0,591,590,1,0,0,0,591,592,1,0,0,0,592,593,1,0,0,0,593,594,5,40, - 0,0,594,595,3,144,72,0,595,596,5,41,0,0,596,125,1,0,0,0,597,599, - 7,13,0,0,598,600,5,116,0,0,599,598,1,0,0,0,599,600,1,0,0,0,600,601, - 1,0,0,0,601,602,5,40,0,0,602,603,3,144,72,0,603,604,5,41,0,0,604, - 127,1,0,0,0,605,607,7,14,0,0,606,608,5,116,0,0,607,606,1,0,0,0,607, - 608,1,0,0,0,608,615,1,0,0,0,609,610,5,40,0,0,610,611,3,144,72,0, - 611,612,5,114,0,0,612,613,3,144,72,0,613,614,5,41,0,0,614,616,1, - 0,0,0,615,609,1,0,0,0,615,616,1,0,0,0,616,129,1,0,0,0,617,619,7, - 15,0,0,618,620,5,116,0,0,619,618,1,0,0,0,619,620,1,0,0,0,620,621, - 1,0,0,0,621,622,5,40,0,0,622,623,3,144,72,0,623,624,5,41,0,0,624, - 131,1,0,0,0,625,627,7,16,0,0,626,628,5,116,0,0,627,626,1,0,0,0,627, - 628,1,0,0,0,628,629,1,0,0,0,629,630,5,40,0,0,630,631,3,144,72,0, - 631,632,5,41,0,0,632,133,1,0,0,0,633,635,7,17,0,0,634,636,5,116, - 0,0,635,634,1,0,0,0,635,636,1,0,0,0,636,637,1,0,0,0,637,638,5,40, - 0,0,638,639,3,144,72,0,639,640,5,41,0,0,640,135,1,0,0,0,641,643, - 5,78,0,0,642,644,5,116,0,0,643,642,1,0,0,0,643,644,1,0,0,0,644,645, - 1,0,0,0,645,646,5,40,0,0,646,647,3,96,48,0,647,648,5,41,0,0,648, - 137,1,0,0,0,649,651,5,52,0,0,650,652,5,116,0,0,651,650,1,0,0,0,651, - 652,1,0,0,0,652,653,1,0,0,0,653,654,5,40,0,0,654,655,3,140,70,0, - 655,656,5,122,0,0,656,657,3,96,48,0,657,658,5,41,0,0,658,139,1,0, - 0,0,659,672,3,96,48,0,660,661,5,110,0,0,661,666,3,96,48,0,662,663, - 5,114,0,0,663,665,3,96,48,0,664,662,1,0,0,0,665,668,1,0,0,0,666, - 664,1,0,0,0,666,667,1,0,0,0,667,669,1,0,0,0,668,666,1,0,0,0,669, - 670,5,111,0,0,670,672,1,0,0,0,671,659,1,0,0,0,671,660,1,0,0,0,672, - 141,1,0,0,0,673,683,3,122,61,0,674,683,3,124,62,0,675,683,3,126, - 63,0,676,683,3,128,64,0,677,683,3,120,60,0,678,683,3,130,65,0,679, - 683,3,132,66,0,680,683,3,134,67,0,681,683,3,138,69,0,682,673,1,0, - 0,0,682,674,1,0,0,0,682,675,1,0,0,0,682,676,1,0,0,0,682,677,1,0, - 0,0,682,678,1,0,0,0,682,679,1,0,0,0,682,680,1,0,0,0,682,681,1,0, - 0,0,683,143,1,0,0,0,684,685,5,24,0,0,685,145,1,0,0,0,686,687,7,18, - 0,0,687,147,1,0,0,0,688,689,3,150,75,0,689,690,5,115,0,0,690,691, - 3,152,76,0,691,149,1,0,0,0,692,693,7,19,0,0,693,151,1,0,0,0,694, - 695,7,20,0,0,695,153,1,0,0,0,696,701,3,148,74,0,697,698,5,114,0, - 0,698,700,3,148,74,0,699,697,1,0,0,0,700,703,1,0,0,0,701,699,1,0, - 0,0,701,702,1,0,0,0,702,155,1,0,0,0,703,701,1,0,0,0,704,705,7,21, - 0,0,705,157,1,0,0,0,706,709,3,156,78,0,707,709,5,124,0,0,708,706, - 1,0,0,0,708,707,1,0,0,0,709,159,1,0,0,0,62,164,173,189,207,213,218, - 221,226,228,235,240,263,270,279,287,296,306,319,322,336,339,353, - 360,368,375,381,386,476,479,496,499,508,522,527,529,533,537,541, - 545,549,553,557,561,565,569,573,579,583,591,599,607,615,619,627, - 635,643,651,666,671,682,701,708 + 124,124,2,0,23,23,119,120,749,0,162,1,0,0,0,2,170,1,0,0,0,4,178, + 1,0,0,0,6,183,1,0,0,0,8,194,1,0,0,0,10,199,1,0,0,0,12,201,1,0,0, + 0,14,230,1,0,0,0,16,232,1,0,0,0,18,242,1,0,0,0,20,266,1,0,0,0,22, + 268,1,0,0,0,24,299,1,0,0,0,26,301,1,0,0,0,28,316,1,0,0,0,30,329, + 1,0,0,0,32,333,1,0,0,0,34,356,1,0,0,0,36,358,1,0,0,0,38,366,1,0, + 0,0,40,378,1,0,0,0,42,384,1,0,0,0,44,389,1,0,0,0,46,391,1,0,0,0, + 48,393,1,0,0,0,50,397,1,0,0,0,52,401,1,0,0,0,54,405,1,0,0,0,56,409, + 1,0,0,0,58,413,1,0,0,0,60,417,1,0,0,0,62,421,1,0,0,0,64,425,1,0, + 0,0,66,429,1,0,0,0,68,433,1,0,0,0,70,437,1,0,0,0,72,441,1,0,0,0, + 74,445,1,0,0,0,76,449,1,0,0,0,78,453,1,0,0,0,80,457,1,0,0,0,82,461, + 1,0,0,0,84,465,1,0,0,0,86,469,1,0,0,0,88,473,1,0,0,0,90,480,1,0, + 0,0,92,493,1,0,0,0,94,509,1,0,0,0,96,511,1,0,0,0,98,518,1,0,0,0, + 100,539,1,0,0,0,102,541,1,0,0,0,104,545,1,0,0,0,106,549,1,0,0,0, + 108,553,1,0,0,0,110,557,1,0,0,0,112,561,1,0,0,0,114,565,1,0,0,0, + 116,569,1,0,0,0,118,573,1,0,0,0,120,577,1,0,0,0,122,581,1,0,0,0, + 124,591,1,0,0,0,126,599,1,0,0,0,128,607,1,0,0,0,130,615,1,0,0,0, + 132,627,1,0,0,0,134,635,1,0,0,0,136,643,1,0,0,0,138,651,1,0,0,0, + 140,659,1,0,0,0,142,681,1,0,0,0,144,692,1,0,0,0,146,694,1,0,0,0, + 148,696,1,0,0,0,150,698,1,0,0,0,152,702,1,0,0,0,154,704,1,0,0,0, + 156,706,1,0,0,0,158,714,1,0,0,0,160,718,1,0,0,0,162,164,3,2,1,0, + 163,165,3,14,7,0,164,163,1,0,0,0,165,166,1,0,0,0,166,164,1,0,0,0, + 166,167,1,0,0,0,167,168,1,0,0,0,168,169,5,0,0,1,169,1,1,0,0,0,170, + 171,3,4,2,0,171,175,3,6,3,0,172,174,3,8,4,0,173,172,1,0,0,0,174, + 177,1,0,0,0,175,173,1,0,0,0,175,176,1,0,0,0,176,3,1,0,0,0,177,175, + 1,0,0,0,178,179,5,2,0,0,179,180,7,0,0,0,180,181,5,115,0,0,181,182, + 5,7,0,0,182,5,1,0,0,0,183,184,5,2,0,0,184,185,5,5,0,0,185,186,5, + 115,0,0,186,191,5,45,0,0,187,188,5,114,0,0,188,190,5,45,0,0,189, + 187,1,0,0,0,190,193,1,0,0,0,191,189,1,0,0,0,191,192,1,0,0,0,192, + 7,1,0,0,0,193,191,1,0,0,0,194,195,5,2,0,0,195,196,5,6,0,0,196,197, + 5,115,0,0,197,198,5,45,0,0,198,9,1,0,0,0,199,200,5,8,0,0,200,11, + 1,0,0,0,201,202,3,160,80,0,202,203,5,110,0,0,203,204,3,16,8,0,204, + 209,5,111,0,0,205,206,5,112,0,0,206,207,3,156,78,0,207,208,5,113, + 0,0,208,210,1,0,0,0,209,205,1,0,0,0,209,210,1,0,0,0,210,211,1,0, + 0,0,211,212,5,103,0,0,212,213,3,18,9,0,213,13,1,0,0,0,214,216,3, + 10,5,0,215,214,1,0,0,0,215,216,1,0,0,0,216,218,1,0,0,0,217,219,3, + 12,6,0,218,217,1,0,0,0,219,220,1,0,0,0,220,218,1,0,0,0,220,221,1, + 0,0,0,221,231,1,0,0,0,222,224,3,10,5,0,223,222,1,0,0,0,223,224,1, + 0,0,0,224,226,1,0,0,0,225,227,3,22,11,0,226,225,1,0,0,0,227,228, + 1,0,0,0,228,226,1,0,0,0,228,229,1,0,0,0,229,231,1,0,0,0,230,215, + 1,0,0,0,230,223,1,0,0,0,231,15,1,0,0,0,232,237,3,20,10,0,233,234, + 5,114,0,0,234,236,3,20,10,0,235,233,1,0,0,0,236,239,1,0,0,0,237, + 235,1,0,0,0,237,238,1,0,0,0,238,17,1,0,0,0,239,237,1,0,0,0,240,243, + 3,20,10,0,241,243,3,148,74,0,242,240,1,0,0,0,242,241,1,0,0,0,243, + 19,1,0,0,0,244,267,3,48,24,0,245,267,3,50,25,0,246,267,3,52,26,0, + 247,267,3,56,28,0,248,267,3,58,29,0,249,267,3,54,27,0,250,267,3, + 60,30,0,251,267,3,62,31,0,252,267,3,64,32,0,253,267,3,66,33,0,254, + 267,3,68,34,0,255,267,3,70,35,0,256,267,3,72,36,0,257,267,3,74,37, + 0,258,267,3,76,38,0,259,267,3,78,39,0,260,267,3,80,40,0,261,267, + 3,82,41,0,262,267,3,84,42,0,263,267,3,86,43,0,264,267,3,88,44,0, + 265,267,5,124,0,0,266,244,1,0,0,0,266,245,1,0,0,0,266,246,1,0,0, + 0,266,247,1,0,0,0,266,248,1,0,0,0,266,249,1,0,0,0,266,250,1,0,0, + 0,266,251,1,0,0,0,266,252,1,0,0,0,266,253,1,0,0,0,266,254,1,0,0, + 0,266,255,1,0,0,0,266,256,1,0,0,0,266,257,1,0,0,0,266,258,1,0,0, + 0,266,259,1,0,0,0,266,260,1,0,0,0,266,261,1,0,0,0,266,262,1,0,0, + 0,266,263,1,0,0,0,266,264,1,0,0,0,266,265,1,0,0,0,267,21,1,0,0,0, + 268,273,3,24,12,0,269,270,5,112,0,0,270,271,3,156,78,0,271,272,5, + 113,0,0,272,274,1,0,0,0,273,269,1,0,0,0,273,274,1,0,0,0,274,275, + 1,0,0,0,275,276,5,103,0,0,276,277,3,18,9,0,277,23,1,0,0,0,278,279, + 3,26,13,0,279,280,3,160,80,0,280,282,5,110,0,0,281,283,3,36,18,0, + 282,281,1,0,0,0,282,283,1,0,0,0,283,284,1,0,0,0,284,285,5,111,0, + 0,285,300,1,0,0,0,286,287,3,28,14,0,287,288,3,160,80,0,288,290,5, + 110,0,0,289,291,3,38,19,0,290,289,1,0,0,0,290,291,1,0,0,0,291,292, + 1,0,0,0,292,293,5,111,0,0,293,300,1,0,0,0,294,295,3,160,80,0,295, + 296,5,110,0,0,296,297,3,30,15,0,297,298,5,111,0,0,298,300,1,0,0, + 0,299,278,1,0,0,0,299,286,1,0,0,0,299,294,1,0,0,0,300,25,1,0,0,0, + 301,302,5,9,0,0,302,303,5,124,0,0,303,304,5,110,0,0,304,309,3,98, + 49,0,305,306,5,114,0,0,306,308,3,98,49,0,307,305,1,0,0,0,308,311, + 1,0,0,0,309,307,1,0,0,0,309,310,1,0,0,0,310,312,1,0,0,0,311,309, + 1,0,0,0,312,313,5,111,0,0,313,314,5,103,0,0,314,315,3,28,14,0,315, + 27,1,0,0,0,316,325,5,110,0,0,317,322,3,32,16,0,318,319,5,114,0,0, + 319,321,3,32,16,0,320,318,1,0,0,0,321,324,1,0,0,0,322,320,1,0,0, + 0,322,323,1,0,0,0,323,326,1,0,0,0,324,322,1,0,0,0,325,317,1,0,0, + 0,325,326,1,0,0,0,326,327,1,0,0,0,327,328,5,111,0,0,328,29,1,0,0, + 0,329,330,3,32,16,0,330,331,5,97,0,0,331,332,3,98,49,0,332,31,1, + 0,0,0,333,342,5,110,0,0,334,339,3,34,17,0,335,336,5,114,0,0,336, + 338,3,34,17,0,337,335,1,0,0,0,338,341,1,0,0,0,339,337,1,0,0,0,339, + 340,1,0,0,0,340,343,1,0,0,0,341,339,1,0,0,0,342,334,1,0,0,0,342, + 343,1,0,0,0,343,344,1,0,0,0,344,345,5,111,0,0,345,33,1,0,0,0,346, + 357,5,44,0,0,347,357,3,44,22,0,348,357,5,27,0,0,349,357,5,45,0,0, + 350,357,5,31,0,0,351,357,5,30,0,0,352,357,5,29,0,0,353,357,5,28, + 0,0,354,357,5,42,0,0,355,357,5,43,0,0,356,346,1,0,0,0,356,347,1, + 0,0,0,356,348,1,0,0,0,356,349,1,0,0,0,356,350,1,0,0,0,356,351,1, + 0,0,0,356,352,1,0,0,0,356,353,1,0,0,0,356,354,1,0,0,0,356,355,1, + 0,0,0,357,35,1,0,0,0,358,363,3,40,20,0,359,360,5,114,0,0,360,362, + 3,40,20,0,361,359,1,0,0,0,362,365,1,0,0,0,363,361,1,0,0,0,363,364, + 1,0,0,0,364,37,1,0,0,0,365,363,1,0,0,0,366,371,3,42,21,0,367,368, + 5,114,0,0,368,370,3,42,21,0,369,367,1,0,0,0,370,373,1,0,0,0,371, + 369,1,0,0,0,371,372,1,0,0,0,372,39,1,0,0,0,373,371,1,0,0,0,374,375, + 5,124,0,0,375,376,5,118,0,0,376,379,5,46,0,0,377,379,3,20,10,0,378, + 374,1,0,0,0,378,377,1,0,0,0,379,41,1,0,0,0,380,381,5,46,0,0,381, + 382,5,97,0,0,382,385,3,98,49,0,383,385,3,20,10,0,384,380,1,0,0,0, + 384,383,1,0,0,0,385,43,1,0,0,0,386,390,5,25,0,0,387,390,5,24,0,0, + 388,390,3,46,23,0,389,386,1,0,0,0,389,387,1,0,0,0,389,388,1,0,0, + 0,390,45,1,0,0,0,391,392,7,1,0,0,392,47,1,0,0,0,393,394,5,44,0,0, + 394,395,5,97,0,0,395,396,3,98,49,0,396,49,1,0,0,0,397,398,5,24,0, + 0,398,399,5,97,0,0,399,400,3,108,54,0,400,51,1,0,0,0,401,402,3,44, + 22,0,402,403,5,97,0,0,403,404,3,110,55,0,404,53,1,0,0,0,405,406, + 3,44,22,0,406,407,5,97,0,0,407,408,3,130,65,0,408,55,1,0,0,0,409, + 410,5,27,0,0,410,411,5,97,0,0,411,412,3,102,51,0,412,57,1,0,0,0, + 413,414,5,45,0,0,414,415,5,97,0,0,415,416,3,104,52,0,416,59,1,0, + 0,0,417,418,5,31,0,0,418,419,5,97,0,0,419,420,3,112,56,0,420,61, + 1,0,0,0,421,422,5,30,0,0,422,423,5,97,0,0,423,424,3,114,57,0,424, + 63,1,0,0,0,425,426,5,29,0,0,426,427,5,97,0,0,427,428,3,116,58,0, + 428,65,1,0,0,0,429,430,5,28,0,0,430,431,5,97,0,0,431,432,3,118,59, + 0,432,67,1,0,0,0,433,434,5,42,0,0,434,435,5,97,0,0,435,436,3,120, + 60,0,436,69,1,0,0,0,437,438,5,43,0,0,438,439,5,97,0,0,439,440,3, + 122,61,0,440,71,1,0,0,0,441,442,5,45,0,0,442,443,5,97,0,0,443,444, + 3,124,62,0,444,73,1,0,0,0,445,446,5,45,0,0,446,447,5,97,0,0,447, + 448,3,126,63,0,448,75,1,0,0,0,449,450,5,45,0,0,450,451,5,97,0,0, + 451,452,3,128,64,0,452,77,1,0,0,0,453,454,5,30,0,0,454,455,5,97, + 0,0,455,456,3,132,66,0,456,79,1,0,0,0,457,458,5,29,0,0,458,459,5, + 97,0,0,459,460,3,134,67,0,460,81,1,0,0,0,461,462,5,28,0,0,462,463, + 5,97,0,0,463,464,3,136,68,0,464,83,1,0,0,0,465,466,3,90,45,0,466, + 467,5,97,0,0,467,468,3,138,69,0,468,85,1,0,0,0,469,470,3,92,46,0, + 470,471,5,97,0,0,471,472,3,140,70,0,472,87,1,0,0,0,473,474,3,34, + 17,0,474,475,5,97,0,0,475,476,5,80,0,0,476,478,5,124,0,0,477,479, + 5,116,0,0,478,477,1,0,0,0,478,479,1,0,0,0,479,89,1,0,0,0,480,489, + 5,112,0,0,481,486,3,34,17,0,482,483,5,114,0,0,483,485,3,34,17,0, + 484,482,1,0,0,0,485,488,1,0,0,0,486,484,1,0,0,0,486,487,1,0,0,0, + 487,490,1,0,0,0,488,486,1,0,0,0,489,481,1,0,0,0,489,490,1,0,0,0, + 490,491,1,0,0,0,491,492,5,113,0,0,492,91,1,0,0,0,493,494,5,110,0, + 0,494,495,3,94,47,0,495,496,5,122,0,0,496,497,3,96,48,0,497,498, + 5,111,0,0,498,93,1,0,0,0,499,510,5,124,0,0,500,501,5,110,0,0,501, + 504,5,124,0,0,502,503,5,114,0,0,503,505,5,124,0,0,504,502,1,0,0, + 0,505,506,1,0,0,0,506,504,1,0,0,0,506,507,1,0,0,0,507,508,1,0,0, + 0,508,510,5,111,0,0,509,499,1,0,0,0,509,500,1,0,0,0,510,95,1,0,0, + 0,511,512,3,160,80,0,512,513,5,110,0,0,513,514,3,16,8,0,514,515, + 5,111,0,0,515,97,1,0,0,0,516,519,3,100,50,0,517,519,3,144,72,0,518, + 516,1,0,0,0,518,517,1,0,0,0,519,99,1,0,0,0,520,540,3,102,51,0,521, + 540,3,108,54,0,522,540,3,110,55,0,523,540,3,104,52,0,524,540,3,106, + 53,0,525,540,3,116,58,0,526,540,3,118,59,0,527,540,3,112,56,0,528, + 540,3,114,57,0,529,540,3,120,60,0,530,532,5,68,0,0,531,533,5,116, + 0,0,532,531,1,0,0,0,532,533,1,0,0,0,533,540,1,0,0,0,534,535,5,80, + 0,0,535,537,5,124,0,0,536,538,5,116,0,0,537,536,1,0,0,0,537,538, + 1,0,0,0,538,540,1,0,0,0,539,520,1,0,0,0,539,521,1,0,0,0,539,522, + 1,0,0,0,539,523,1,0,0,0,539,524,1,0,0,0,539,525,1,0,0,0,539,526, + 1,0,0,0,539,527,1,0,0,0,539,528,1,0,0,0,539,529,1,0,0,0,539,530, + 1,0,0,0,539,534,1,0,0,0,540,101,1,0,0,0,541,543,7,2,0,0,542,544, + 5,116,0,0,543,542,1,0,0,0,543,544,1,0,0,0,544,103,1,0,0,0,545,547, + 7,3,0,0,546,548,5,116,0,0,547,546,1,0,0,0,547,548,1,0,0,0,548,105, + 1,0,0,0,549,551,7,4,0,0,550,552,5,116,0,0,551,550,1,0,0,0,551,552, + 1,0,0,0,552,107,1,0,0,0,553,555,7,5,0,0,554,556,5,116,0,0,555,554, + 1,0,0,0,555,556,1,0,0,0,556,109,1,0,0,0,557,559,7,6,0,0,558,560, + 5,116,0,0,559,558,1,0,0,0,559,560,1,0,0,0,560,111,1,0,0,0,561,563, + 5,64,0,0,562,564,5,116,0,0,563,562,1,0,0,0,563,564,1,0,0,0,564,113, + 1,0,0,0,565,567,5,65,0,0,566,568,5,116,0,0,567,566,1,0,0,0,567,568, + 1,0,0,0,568,115,1,0,0,0,569,571,7,7,0,0,570,572,5,116,0,0,571,570, + 1,0,0,0,571,572,1,0,0,0,572,117,1,0,0,0,573,575,7,8,0,0,574,576, + 5,116,0,0,575,574,1,0,0,0,575,576,1,0,0,0,576,119,1,0,0,0,577,579, + 7,9,0,0,578,580,5,116,0,0,579,578,1,0,0,0,579,580,1,0,0,0,580,121, + 1,0,0,0,581,583,7,10,0,0,582,584,5,116,0,0,583,582,1,0,0,0,583,584, + 1,0,0,0,584,589,1,0,0,0,585,586,5,40,0,0,586,587,3,146,73,0,587, + 588,5,41,0,0,588,590,1,0,0,0,589,585,1,0,0,0,589,590,1,0,0,0,590, + 123,1,0,0,0,591,593,7,11,0,0,592,594,5,116,0,0,593,592,1,0,0,0,593, + 594,1,0,0,0,594,595,1,0,0,0,595,596,5,40,0,0,596,597,3,146,73,0, + 597,598,5,41,0,0,598,125,1,0,0,0,599,601,7,12,0,0,600,602,5,116, + 0,0,601,600,1,0,0,0,601,602,1,0,0,0,602,603,1,0,0,0,603,604,5,40, + 0,0,604,605,3,146,73,0,605,606,5,41,0,0,606,127,1,0,0,0,607,609, + 7,13,0,0,608,610,5,116,0,0,609,608,1,0,0,0,609,610,1,0,0,0,610,611, + 1,0,0,0,611,612,5,40,0,0,612,613,3,146,73,0,613,614,5,41,0,0,614, + 129,1,0,0,0,615,617,7,14,0,0,616,618,5,116,0,0,617,616,1,0,0,0,617, + 618,1,0,0,0,618,625,1,0,0,0,619,620,5,40,0,0,620,621,3,146,73,0, + 621,622,5,114,0,0,622,623,3,146,73,0,623,624,5,41,0,0,624,626,1, + 0,0,0,625,619,1,0,0,0,625,626,1,0,0,0,626,131,1,0,0,0,627,629,7, + 15,0,0,628,630,5,116,0,0,629,628,1,0,0,0,629,630,1,0,0,0,630,631, + 1,0,0,0,631,632,5,40,0,0,632,633,3,146,73,0,633,634,5,41,0,0,634, + 133,1,0,0,0,635,637,7,16,0,0,636,638,5,116,0,0,637,636,1,0,0,0,637, + 638,1,0,0,0,638,639,1,0,0,0,639,640,5,40,0,0,640,641,3,146,73,0, + 641,642,5,41,0,0,642,135,1,0,0,0,643,645,7,17,0,0,644,646,5,116, + 0,0,645,644,1,0,0,0,645,646,1,0,0,0,646,647,1,0,0,0,647,648,5,40, + 0,0,648,649,3,146,73,0,649,650,5,41,0,0,650,137,1,0,0,0,651,653, + 5,78,0,0,652,654,5,116,0,0,653,652,1,0,0,0,653,654,1,0,0,0,654,655, + 1,0,0,0,655,656,5,40,0,0,656,657,3,98,49,0,657,658,5,41,0,0,658, + 139,1,0,0,0,659,661,5,52,0,0,660,662,5,116,0,0,661,660,1,0,0,0,661, + 662,1,0,0,0,662,663,1,0,0,0,663,664,5,40,0,0,664,665,3,142,71,0, + 665,666,5,122,0,0,666,667,3,98,49,0,667,668,5,41,0,0,668,141,1,0, + 0,0,669,682,3,98,49,0,670,671,5,110,0,0,671,676,3,98,49,0,672,673, + 5,114,0,0,673,675,3,98,49,0,674,672,1,0,0,0,675,678,1,0,0,0,676, + 674,1,0,0,0,676,677,1,0,0,0,677,679,1,0,0,0,678,676,1,0,0,0,679, + 680,5,111,0,0,680,682,1,0,0,0,681,669,1,0,0,0,681,670,1,0,0,0,682, + 143,1,0,0,0,683,693,3,124,62,0,684,693,3,126,63,0,685,693,3,128, + 64,0,686,693,3,130,65,0,687,693,3,122,61,0,688,693,3,132,66,0,689, + 693,3,134,67,0,690,693,3,136,68,0,691,693,3,140,70,0,692,683,1,0, + 0,0,692,684,1,0,0,0,692,685,1,0,0,0,692,686,1,0,0,0,692,687,1,0, + 0,0,692,688,1,0,0,0,692,689,1,0,0,0,692,690,1,0,0,0,692,691,1,0, + 0,0,693,145,1,0,0,0,694,695,5,24,0,0,695,147,1,0,0,0,696,697,7,18, + 0,0,697,149,1,0,0,0,698,699,3,152,76,0,699,700,5,115,0,0,700,701, + 3,154,77,0,701,151,1,0,0,0,702,703,7,19,0,0,703,153,1,0,0,0,704, + 705,7,20,0,0,705,155,1,0,0,0,706,711,3,150,75,0,707,708,5,114,0, + 0,708,710,3,150,75,0,709,707,1,0,0,0,710,713,1,0,0,0,711,709,1,0, + 0,0,711,712,1,0,0,0,712,157,1,0,0,0,713,711,1,0,0,0,714,715,7,21, + 0,0,715,159,1,0,0,0,716,719,3,158,79,0,717,719,5,124,0,0,718,716, + 1,0,0,0,718,717,1,0,0,0,719,161,1,0,0,0,63,166,175,191,209,215,220, + 223,228,230,237,242,266,273,282,290,299,309,322,325,339,342,356, + 363,371,378,384,389,478,486,489,506,509,518,532,537,539,543,547, + 551,555,559,563,567,571,575,579,583,589,593,601,609,617,625,629, + 637,645,653,661,676,681,692,711,718 ] class FuncTestCaseParser ( Parser ): @@ -383,42 +387,43 @@ class FuncTestCaseParser ( Parser ): RULE_precisionTimestampTZArg = 41 RULE_listArg = 42 RULE_lambdaArg = 43 - RULE_literalList = 44 - RULE_literalLambda = 45 - RULE_lambdaParameters = 46 - RULE_lambdaBody = 47 - RULE_dataType = 48 - RULE_scalarType = 49 - RULE_booleanType = 50 - RULE_stringType = 51 - RULE_binaryType = 52 - RULE_intType = 53 - RULE_floatType = 54 - RULE_dateType = 55 - RULE_timeType = 56 - RULE_timestampType = 57 - RULE_timestampTZType = 58 - RULE_intervalYearType = 59 - RULE_intervalDayType = 60 - RULE_fixedCharType = 61 - RULE_varCharType = 62 - RULE_fixedBinaryType = 63 - RULE_decimalType = 64 - RULE_precisionTimeType = 65 - RULE_precisionTimestampType = 66 - RULE_precisionTimestampTZType = 67 - RULE_listType = 68 - RULE_funcType = 69 - RULE_funcParameters = 70 - RULE_parameterizedType = 71 - RULE_numericParameter = 72 - RULE_substraitError = 73 - RULE_funcOption = 74 - RULE_optionName = 75 - RULE_optionValue = 76 - RULE_funcOptions = 77 - RULE_nonReserved = 78 - RULE_identifier = 79 + RULE_udtArg = 44 + RULE_literalList = 45 + RULE_literalLambda = 46 + RULE_lambdaParameters = 47 + RULE_lambdaBody = 48 + RULE_dataType = 49 + RULE_scalarType = 50 + RULE_booleanType = 51 + RULE_stringType = 52 + RULE_binaryType = 53 + RULE_intType = 54 + RULE_floatType = 55 + RULE_dateType = 56 + RULE_timeType = 57 + RULE_timestampType = 58 + RULE_timestampTZType = 59 + RULE_intervalYearType = 60 + RULE_intervalDayType = 61 + RULE_fixedCharType = 62 + RULE_varCharType = 63 + RULE_fixedBinaryType = 64 + RULE_decimalType = 65 + RULE_precisionTimeType = 66 + RULE_precisionTimestampType = 67 + RULE_precisionTimestampTZType = 68 + RULE_listType = 69 + RULE_funcType = 70 + RULE_funcParameters = 71 + RULE_parameterizedType = 72 + RULE_numericParameter = 73 + RULE_substraitError = 74 + RULE_funcOption = 75 + RULE_optionName = 76 + RULE_optionValue = 77 + RULE_funcOptions = 78 + RULE_nonReserved = 79 + RULE_identifier = 80 ruleNames = [ "doc", "header", "version", "include", "dependency", "testGroupDescription", "testCase", "testGroup", "arguments", @@ -431,16 +436,16 @@ class FuncTestCaseParser ( Parser ): "timestampTzArg", "intervalYearArg", "intervalDayArg", "fixedCharArg", "varCharArg", "fixedBinaryArg", "precisionTimeArg", "precisionTimestampArg", "precisionTimestampTZArg", "listArg", - "lambdaArg", "literalList", "literalLambda", "lambdaParameters", - "lambdaBody", "dataType", "scalarType", "booleanType", - "stringType", "binaryType", "intType", "floatType", "dateType", - "timeType", "timestampType", "timestampTZType", "intervalYearType", - "intervalDayType", "fixedCharType", "varCharType", "fixedBinaryType", - "decimalType", "precisionTimeType", "precisionTimestampType", - "precisionTimestampTZType", "listType", "funcType", "funcParameters", - "parameterizedType", "numericParameter", "substraitError", - "funcOption", "optionName", "optionValue", "funcOptions", - "nonReserved", "identifier" ] + "lambdaArg", "udtArg", "literalList", "literalLambda", + "lambdaParameters", "lambdaBody", "dataType", "scalarType", + "booleanType", "stringType", "binaryType", "intType", + "floatType", "dateType", "timeType", "timestampType", + "timestampTZType", "intervalYearType", "intervalDayType", + "fixedCharType", "varCharType", "fixedBinaryType", "decimalType", + "precisionTimeType", "precisionTimestampType", "precisionTimestampTZType", + "listType", "funcType", "funcParameters", "parameterizedType", + "numericParameter", "substraitError", "funcOption", "optionName", + "optionValue", "funcOptions", "nonReserved", "identifier" ] EOF = Token.EOF Whitespace=1 @@ -626,21 +631,21 @@ def doc(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 160 + self.state = 162 self.header() - self.state = 162 + self.state = 164 self._errHandler.sync(self) _la = self._input.LA(1) while True: - self.state = 161 + self.state = 163 self.testGroup() - self.state = 164 + self.state = 166 self._errHandler.sync(self) _la = self._input.LA(1) if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 8389376) != 0) or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & 17921) != 0)): break - self.state = 166 + self.state = 168 self.match(FuncTestCaseParser.EOF) except RecognitionException as re: localctx.exception = re @@ -700,17 +705,17 @@ def header(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 168 + self.state = 170 self.version() - self.state = 169 + self.state = 171 self.include() - self.state = 173 + self.state = 175 self._errHandler.sync(self) _la = self._input.LA(1) while _la==2: - self.state = 170 + self.state = 172 self.dependency() - self.state = 175 + self.state = 177 self._errHandler.sync(self) _la = self._input.LA(1) @@ -772,18 +777,18 @@ def version(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 176 + self.state = 178 self.match(FuncTestCaseParser.TripleHash) - self.state = 177 + self.state = 179 _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 = 178 + self.state = 180 self.match(FuncTestCaseParser.Colon) - self.state = 179 + self.state = 181 self.match(FuncTestCaseParser.FormatVersion) except RecognitionException as re: localctx.exception = re @@ -849,23 +854,23 @@ def include(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 181 + self.state = 183 self.match(FuncTestCaseParser.TripleHash) - self.state = 182 + self.state = 184 self.match(FuncTestCaseParser.SubstraitInclude) - self.state = 183 + self.state = 185 self.match(FuncTestCaseParser.Colon) - self.state = 184 + self.state = 186 self.match(FuncTestCaseParser.StringLiteral) - self.state = 189 + self.state = 191 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 185 + self.state = 187 self.match(FuncTestCaseParser.Comma) - self.state = 186 + self.state = 188 self.match(FuncTestCaseParser.StringLiteral) - self.state = 191 + self.state = 193 self._errHandler.sync(self) _la = self._input.LA(1) @@ -923,13 +928,13 @@ def dependency(self): self.enterRule(localctx, 8, self.RULE_dependency) try: self.enterOuterAlt(localctx, 1) - self.state = 192 + self.state = 194 self.match(FuncTestCaseParser.TripleHash) - self.state = 193 + self.state = 195 self.match(FuncTestCaseParser.SubstraitDependency) - self.state = 194 + self.state = 196 self.match(FuncTestCaseParser.Colon) - self.state = 195 + self.state = 197 self.match(FuncTestCaseParser.StringLiteral) except RecognitionException as re: localctx.exception = re @@ -976,7 +981,7 @@ def testGroupDescription(self): self.enterRule(localctx, 10, self.RULE_testGroupDescription) try: self.enterOuterAlt(localctx, 1) - self.state = 197 + self.state = 199 self.match(FuncTestCaseParser.DescriptionLine) except RecognitionException as re: localctx.exception = re @@ -1053,29 +1058,29 @@ def testCase(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 199 + self.state = 201 localctx.functionName = self.identifier() - self.state = 200 + self.state = 202 self.match(FuncTestCaseParser.OParen) - self.state = 201 + self.state = 203 self.arguments() - self.state = 202 + self.state = 204 self.match(FuncTestCaseParser.CParen) - self.state = 207 + self.state = 209 self._errHandler.sync(self) _la = self._input.LA(1) if _la==112: - self.state = 203 + self.state = 205 self.match(FuncTestCaseParser.OBracket) - self.state = 204 + self.state = 206 self.funcOptions() - self.state = 205 + self.state = 207 self.match(FuncTestCaseParser.CBracket) - self.state = 209 + self.state = 211 self.match(FuncTestCaseParser.Eq) - self.state = 210 + self.state = 212 self.result() except RecognitionException as re: localctx.exception = re @@ -1172,31 +1177,31 @@ def testGroup(self): self.enterRule(localctx, 14, self.RULE_testGroup) self._la = 0 # Token type try: - self.state = 228 + self.state = 230 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,8,self._ctx) if la_ == 1: localctx = FuncTestCaseParser.ScalarFuncTestGroupContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 213 + self.state = 215 self._errHandler.sync(self) _la = self._input.LA(1) if _la==8: - self.state = 212 + self.state = 214 self.testGroupDescription() - self.state = 216 + self.state = 218 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: - self.state = 215 + self.state = 217 self.testCase() else: raise NoViableAltException(self) - self.state = 218 + self.state = 220 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,5,self._ctx) @@ -1205,25 +1210,25 @@ def testGroup(self): elif la_ == 2: localctx = FuncTestCaseParser.AggregateFuncTestGroupContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 221 + self.state = 223 self._errHandler.sync(self) _la = self._input.LA(1) if _la==8: - self.state = 220 + self.state = 222 self.testGroupDescription() - self.state = 224 + self.state = 226 self._errHandler.sync(self) _alt = 1 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: if _alt == 1: - self.state = 223 + self.state = 225 self.aggFuncTestCase() else: raise NoViableAltException(self) - self.state = 226 + self.state = 228 self._errHandler.sync(self) _alt = self._interp.adaptivePredict(self._input,7,self._ctx) @@ -1286,17 +1291,17 @@ def arguments(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 230 + self.state = 232 self.argument() - self.state = 235 + self.state = 237 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 231 + self.state = 233 self.match(FuncTestCaseParser.Comma) - self.state = 232 + self.state = 234 self.argument() - self.state = 237 + self.state = 239 self._errHandler.sync(self) _la = self._input.LA(1) @@ -1349,17 +1354,17 @@ def result(self): localctx = FuncTestCaseParser.ResultContext(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_result) try: - self.state = 240 + self.state = 242 self._errHandler.sync(self) token = self._input.LA(1) if token in [18, 24, 25, 26, 27, 28, 29, 30, 31, 42, 43, 44, 45, 110, 112, 124]: self.enterOuterAlt(localctx, 1) - self.state = 238 + self.state = 240 self.argument() pass elif token in [10, 11]: self.enterOuterAlt(localctx, 2) - self.state = 239 + self.state = 241 self.substraitError() pass else: @@ -1461,6 +1466,10 @@ def lambdaArg(self): return self.getTypedRuleContext(FuncTestCaseParser.LambdaArgContext,0) + def udtArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.UdtArgContext,0) + + def Identifier(self): return self.getToken(FuncTestCaseParser.Identifier, 0) @@ -1489,132 +1498,138 @@ def argument(self): localctx = FuncTestCaseParser.ArgumentContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_argument) try: - self.state = 263 + self.state = 266 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,11,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 242 + self.state = 244 self.nullArg() pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 243 + self.state = 245 self.intArg() pass elif la_ == 3: self.enterOuterAlt(localctx, 3) - self.state = 244 + self.state = 246 self.floatArg() pass elif la_ == 4: self.enterOuterAlt(localctx, 4) - self.state = 245 + self.state = 247 self.booleanArg() pass elif la_ == 5: self.enterOuterAlt(localctx, 5) - self.state = 246 + self.state = 248 self.stringArg() pass elif la_ == 6: self.enterOuterAlt(localctx, 6) - self.state = 247 + self.state = 249 self.decimalArg() pass elif la_ == 7: self.enterOuterAlt(localctx, 7) - self.state = 248 + self.state = 250 self.dateArg() pass elif la_ == 8: self.enterOuterAlt(localctx, 8) - self.state = 249 + self.state = 251 self.timeArg() pass elif la_ == 9: self.enterOuterAlt(localctx, 9) - self.state = 250 + self.state = 252 self.timestampArg() pass elif la_ == 10: self.enterOuterAlt(localctx, 10) - self.state = 251 + self.state = 253 self.timestampTzArg() pass elif la_ == 11: self.enterOuterAlt(localctx, 11) - self.state = 252 + self.state = 254 self.intervalYearArg() pass elif la_ == 12: self.enterOuterAlt(localctx, 12) - self.state = 253 + self.state = 255 self.intervalDayArg() pass elif la_ == 13: self.enterOuterAlt(localctx, 13) - self.state = 254 + self.state = 256 self.fixedCharArg() pass elif la_ == 14: self.enterOuterAlt(localctx, 14) - self.state = 255 + self.state = 257 self.varCharArg() pass elif la_ == 15: self.enterOuterAlt(localctx, 15) - self.state = 256 + self.state = 258 self.fixedBinaryArg() pass elif la_ == 16: self.enterOuterAlt(localctx, 16) - self.state = 257 + self.state = 259 self.precisionTimeArg() pass elif la_ == 17: self.enterOuterAlt(localctx, 17) - self.state = 258 + self.state = 260 self.precisionTimestampArg() pass elif la_ == 18: self.enterOuterAlt(localctx, 18) - self.state = 259 + self.state = 261 self.precisionTimestampTZArg() pass elif la_ == 19: self.enterOuterAlt(localctx, 19) - self.state = 260 + self.state = 262 self.listArg() pass elif la_ == 20: self.enterOuterAlt(localctx, 20) - self.state = 261 + self.state = 263 self.lambdaArg() pass elif la_ == 21: self.enterOuterAlt(localctx, 21) - self.state = 262 + self.state = 264 + self.udtArg() + pass + + elif la_ == 22: + self.enterOuterAlt(localctx, 22) + self.state = 265 self.match(FuncTestCaseParser.Identifier) pass @@ -1683,23 +1698,23 @@ def aggFuncTestCase(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 265 + self.state = 268 self.aggFuncCall() - self.state = 270 + self.state = 273 self._errHandler.sync(self) _la = self._input.LA(1) if _la==112: - self.state = 266 + self.state = 269 self.match(FuncTestCaseParser.OBracket) - self.state = 267 + self.state = 270 self.funcOptions() - self.state = 268 + self.state = 271 self.match(FuncTestCaseParser.CBracket) - self.state = 272 + self.state = 275 self.match(FuncTestCaseParser.Eq) - self.state = 273 + self.state = 276 self.result() except RecognitionException as re: localctx.exception = re @@ -1839,59 +1854,59 @@ def aggFuncCall(self): self.enterRule(localctx, 24, self.RULE_aggFuncCall) self._la = 0 # Token type try: - self.state = 296 + self.state = 299 self._errHandler.sync(self) token = self._input.LA(1) if token in [9]: localctx = FuncTestCaseParser.MultiArgAggregateFuncCallContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 275 + self.state = 278 self.tableData() - self.state = 276 + self.state = 279 localctx.funcName = self.identifier() - self.state = 277 + self.state = 280 self.match(FuncTestCaseParser.OParen) - self.state = 279 + self.state = 282 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 65974976118784) != 0) or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & 16389) != 0): - self.state = 278 + self.state = 281 self.qualifiedAggregateFuncArgs() - self.state = 281 + self.state = 284 self.match(FuncTestCaseParser.CParen) pass elif token in [110]: localctx = FuncTestCaseParser.CompactAggregateFuncCallContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 283 + self.state = 286 self.tableRows() - self.state = 284 + self.state = 287 localctx.functName = self.identifier() - self.state = 285 + self.state = 288 self.match(FuncTestCaseParser.OParen) - self.state = 287 + self.state = 290 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 136343720296448) != 0) or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & 16389) != 0): - self.state = 286 + self.state = 289 self.aggregateFuncArgs() - self.state = 289 + self.state = 292 self.match(FuncTestCaseParser.CParen) pass elif token in [23, 119, 120, 124]: localctx = FuncTestCaseParser.SingleArgAggregateFuncCallContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 291 + self.state = 294 localctx.functName = self.identifier() - self.state = 292 + self.state = 295 self.match(FuncTestCaseParser.OParen) - self.state = 293 + self.state = 296 self.dataColumn() - self.state = 294 + self.state = 297 self.match(FuncTestCaseParser.CParen) pass else: @@ -1973,31 +1988,31 @@ def tableData(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 298 + self.state = 301 self.match(FuncTestCaseParser.Define) - self.state = 299 + self.state = 302 localctx.tableName = self.match(FuncTestCaseParser.Identifier) - self.state = 300 + self.state = 303 self.match(FuncTestCaseParser.OParen) - self.state = 301 + self.state = 304 self.dataType() - self.state = 306 + self.state = 309 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 302 + self.state = 305 self.match(FuncTestCaseParser.Comma) - self.state = 303 + self.state = 306 self.dataType() - self.state = 308 + self.state = 311 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 309 + self.state = 312 self.match(FuncTestCaseParser.CParen) - self.state = 310 + self.state = 313 self.match(FuncTestCaseParser.Eq) - self.state = 311 + self.state = 314 self.tableRows() except RecognitionException as re: localctx.exception = re @@ -2061,29 +2076,29 @@ def tableRows(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 313 + self.state = 316 self.match(FuncTestCaseParser.OParen) - self.state = 322 + self.state = 325 self._errHandler.sync(self) _la = self._input.LA(1) if _la==110: - self.state = 314 + self.state = 317 self.columnValues() - self.state = 319 + self.state = 322 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 315 + self.state = 318 self.match(FuncTestCaseParser.Comma) - self.state = 316 + self.state = 319 self.columnValues() - self.state = 321 + self.state = 324 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 324 + self.state = 327 self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re @@ -2138,11 +2153,11 @@ def dataColumn(self): self.enterRule(localctx, 30, self.RULE_dataColumn) try: self.enterOuterAlt(localctx, 1) - self.state = 326 + self.state = 329 self.columnValues() - self.state = 327 + self.state = 330 self.match(FuncTestCaseParser.DoubleColon) - self.state = 328 + self.state = 331 self.dataType() except RecognitionException as re: localctx.exception = re @@ -2206,29 +2221,29 @@ def columnValues(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 330 + self.state = 333 self.match(FuncTestCaseParser.OParen) - self.state = 339 + self.state = 342 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 65974976118784) != 0): - self.state = 331 + self.state = 334 self.literal() - self.state = 336 + self.state = 339 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 332 + self.state = 335 self.match(FuncTestCaseParser.Comma) - self.state = 333 + self.state = 336 self.literal() - self.state = 338 + self.state = 341 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 341 + self.state = 344 self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re @@ -2302,57 +2317,57 @@ def literal(self): localctx = FuncTestCaseParser.LiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 34, self.RULE_literal) try: - self.state = 353 + self.state = 356 self._errHandler.sync(self) token = self._input.LA(1) if token in [44]: self.enterOuterAlt(localctx, 1) - self.state = 343 + self.state = 346 self.match(FuncTestCaseParser.NullLiteral) pass elif token in [18, 24, 25, 26]: self.enterOuterAlt(localctx, 2) - self.state = 344 + self.state = 347 self.numericLiteral() pass elif token in [27]: self.enterOuterAlt(localctx, 3) - self.state = 345 + self.state = 348 self.match(FuncTestCaseParser.BooleanLiteral) pass elif token in [45]: self.enterOuterAlt(localctx, 4) - self.state = 346 + self.state = 349 self.match(FuncTestCaseParser.StringLiteral) pass elif token in [31]: self.enterOuterAlt(localctx, 5) - self.state = 347 + self.state = 350 self.match(FuncTestCaseParser.DateLiteral) pass elif token in [30]: self.enterOuterAlt(localctx, 6) - self.state = 348 + self.state = 351 self.match(FuncTestCaseParser.TimeLiteral) pass elif token in [29]: self.enterOuterAlt(localctx, 7) - self.state = 349 + self.state = 352 self.match(FuncTestCaseParser.TimestampLiteral) pass elif token in [28]: self.enterOuterAlt(localctx, 8) - self.state = 350 + self.state = 353 self.match(FuncTestCaseParser.TimestampTzLiteral) pass elif token in [42]: self.enterOuterAlt(localctx, 9) - self.state = 351 + self.state = 354 self.match(FuncTestCaseParser.IntervalYearLiteral) pass elif token in [43]: self.enterOuterAlt(localctx, 10) - self.state = 352 + self.state = 355 self.match(FuncTestCaseParser.IntervalDayLiteral) pass else: @@ -2414,17 +2429,17 @@ def qualifiedAggregateFuncArgs(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 355 + self.state = 358 self.qualifiedAggregateFuncArg() - self.state = 360 + self.state = 363 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 356 + self.state = 359 self.match(FuncTestCaseParser.Comma) - self.state = 357 + self.state = 360 self.qualifiedAggregateFuncArg() - self.state = 362 + self.state = 365 self._errHandler.sync(self) _la = self._input.LA(1) @@ -2484,17 +2499,17 @@ def aggregateFuncArgs(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 363 + self.state = 366 self.aggregateFuncArg() - self.state = 368 + self.state = 371 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 364 + self.state = 367 self.match(FuncTestCaseParser.Comma) - self.state = 365 + self.state = 368 self.aggregateFuncArg() - self.state = 370 + self.state = 373 self._errHandler.sync(self) _la = self._input.LA(1) @@ -2553,22 +2568,22 @@ def qualifiedAggregateFuncArg(self): localctx = FuncTestCaseParser.QualifiedAggregateFuncArgContext(self, self._ctx, self.state) self.enterRule(localctx, 40, self.RULE_qualifiedAggregateFuncArg) try: - self.state = 375 + self.state = 378 self._errHandler.sync(self) la_ = self._interp.adaptivePredict(self._input,24,self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 371 + self.state = 374 localctx.tableName = self.match(FuncTestCaseParser.Identifier) - self.state = 372 + self.state = 375 self.match(FuncTestCaseParser.Dot) - self.state = 373 + self.state = 376 self.match(FuncTestCaseParser.ColumnName) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 374 + self.state = 377 self.argument() pass @@ -2628,21 +2643,21 @@ def aggregateFuncArg(self): localctx = FuncTestCaseParser.AggregateFuncArgContext(self, self._ctx, self.state) self.enterRule(localctx, 42, self.RULE_aggregateFuncArg) try: - self.state = 381 + self.state = 384 self._errHandler.sync(self) token = self._input.LA(1) if token in [46]: self.enterOuterAlt(localctx, 1) - self.state = 377 + self.state = 380 self.match(FuncTestCaseParser.ColumnName) - self.state = 378 + self.state = 381 self.match(FuncTestCaseParser.DoubleColon) - self.state = 379 + self.state = 382 self.dataType() pass elif token in [18, 24, 25, 26, 27, 28, 29, 30, 31, 42, 43, 44, 45, 110, 112, 124]: self.enterOuterAlt(localctx, 2) - self.state = 380 + self.state = 383 self.argument() pass else: @@ -2699,22 +2714,22 @@ def numericLiteral(self): localctx = FuncTestCaseParser.NumericLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 44, self.RULE_numericLiteral) try: - self.state = 386 + self.state = 389 self._errHandler.sync(self) token = self._input.LA(1) if token in [25]: self.enterOuterAlt(localctx, 1) - self.state = 383 + self.state = 386 self.match(FuncTestCaseParser.DecimalLiteral) pass elif token in [24]: self.enterOuterAlt(localctx, 2) - self.state = 384 + self.state = 387 self.match(FuncTestCaseParser.IntegerLiteral) pass elif token in [18, 26]: self.enterOuterAlt(localctx, 3) - self.state = 385 + self.state = 388 self.floatLiteral() pass else: @@ -2769,7 +2784,7 @@ def floatLiteral(self): self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 388 + self.state = 391 _la = self._input.LA(1) if not(_la==18 or _la==26): self._errHandler.recoverInline(self) @@ -2828,11 +2843,11 @@ def nullArg(self): self.enterRule(localctx, 48, self.RULE_nullArg) try: self.enterOuterAlt(localctx, 1) - self.state = 390 + self.state = 393 self.match(FuncTestCaseParser.NullLiteral) - self.state = 391 + self.state = 394 self.match(FuncTestCaseParser.DoubleColon) - self.state = 392 + self.state = 395 self.dataType() except RecognitionException as re: localctx.exception = re @@ -2886,11 +2901,11 @@ def intArg(self): self.enterRule(localctx, 50, self.RULE_intArg) try: self.enterOuterAlt(localctx, 1) - self.state = 394 + self.state = 397 self.match(FuncTestCaseParser.IntegerLiteral) - self.state = 395 + self.state = 398 self.match(FuncTestCaseParser.DoubleColon) - self.state = 396 + self.state = 399 self.intType() except RecognitionException as re: localctx.exception = re @@ -2945,11 +2960,11 @@ def floatArg(self): self.enterRule(localctx, 52, self.RULE_floatArg) try: self.enterOuterAlt(localctx, 1) - self.state = 398 + self.state = 401 self.numericLiteral() - self.state = 399 + self.state = 402 self.match(FuncTestCaseParser.DoubleColon) - self.state = 400 + self.state = 403 self.floatType() except RecognitionException as re: localctx.exception = re @@ -3004,11 +3019,11 @@ def decimalArg(self): self.enterRule(localctx, 54, self.RULE_decimalArg) try: self.enterOuterAlt(localctx, 1) - self.state = 402 + self.state = 405 self.numericLiteral() - self.state = 403 + self.state = 406 self.match(FuncTestCaseParser.DoubleColon) - self.state = 404 + self.state = 407 self.decimalType() except RecognitionException as re: localctx.exception = re @@ -3062,11 +3077,11 @@ def booleanArg(self): self.enterRule(localctx, 56, self.RULE_booleanArg) try: self.enterOuterAlt(localctx, 1) - self.state = 406 + self.state = 409 self.match(FuncTestCaseParser.BooleanLiteral) - self.state = 407 + self.state = 410 self.match(FuncTestCaseParser.DoubleColon) - self.state = 408 + self.state = 411 self.booleanType() except RecognitionException as re: localctx.exception = re @@ -3120,11 +3135,11 @@ def stringArg(self): self.enterRule(localctx, 58, self.RULE_stringArg) try: self.enterOuterAlt(localctx, 1) - self.state = 410 + self.state = 413 self.match(FuncTestCaseParser.StringLiteral) - self.state = 411 + self.state = 414 self.match(FuncTestCaseParser.DoubleColon) - self.state = 412 + self.state = 415 self.stringType() except RecognitionException as re: localctx.exception = re @@ -3178,11 +3193,11 @@ def dateArg(self): self.enterRule(localctx, 60, self.RULE_dateArg) try: self.enterOuterAlt(localctx, 1) - self.state = 414 + self.state = 417 self.match(FuncTestCaseParser.DateLiteral) - self.state = 415 + self.state = 418 self.match(FuncTestCaseParser.DoubleColon) - self.state = 416 + self.state = 419 self.dateType() except RecognitionException as re: localctx.exception = re @@ -3236,11 +3251,11 @@ def timeArg(self): self.enterRule(localctx, 62, self.RULE_timeArg) try: self.enterOuterAlt(localctx, 1) - self.state = 418 + self.state = 421 self.match(FuncTestCaseParser.TimeLiteral) - self.state = 419 + self.state = 422 self.match(FuncTestCaseParser.DoubleColon) - self.state = 420 + self.state = 423 self.timeType() except RecognitionException as re: localctx.exception = re @@ -3294,11 +3309,11 @@ def timestampArg(self): self.enterRule(localctx, 64, self.RULE_timestampArg) try: self.enterOuterAlt(localctx, 1) - self.state = 422 + self.state = 425 self.match(FuncTestCaseParser.TimestampLiteral) - self.state = 423 + self.state = 426 self.match(FuncTestCaseParser.DoubleColon) - self.state = 424 + self.state = 427 self.timestampType() except RecognitionException as re: localctx.exception = re @@ -3352,11 +3367,11 @@ def timestampTzArg(self): self.enterRule(localctx, 66, self.RULE_timestampTzArg) try: self.enterOuterAlt(localctx, 1) - self.state = 426 + self.state = 429 self.match(FuncTestCaseParser.TimestampTzLiteral) - self.state = 427 + self.state = 430 self.match(FuncTestCaseParser.DoubleColon) - self.state = 428 + self.state = 431 self.timestampTZType() except RecognitionException as re: localctx.exception = re @@ -3410,11 +3425,11 @@ def intervalYearArg(self): self.enterRule(localctx, 68, self.RULE_intervalYearArg) try: self.enterOuterAlt(localctx, 1) - self.state = 430 + self.state = 433 self.match(FuncTestCaseParser.IntervalYearLiteral) - self.state = 431 + self.state = 434 self.match(FuncTestCaseParser.DoubleColon) - self.state = 432 + self.state = 435 self.intervalYearType() except RecognitionException as re: localctx.exception = re @@ -3468,11 +3483,11 @@ def intervalDayArg(self): self.enterRule(localctx, 70, self.RULE_intervalDayArg) try: self.enterOuterAlt(localctx, 1) - self.state = 434 + self.state = 437 self.match(FuncTestCaseParser.IntervalDayLiteral) - self.state = 435 + self.state = 438 self.match(FuncTestCaseParser.DoubleColon) - self.state = 436 + self.state = 439 self.intervalDayType() except RecognitionException as re: localctx.exception = re @@ -3526,11 +3541,11 @@ def fixedCharArg(self): self.enterRule(localctx, 72, self.RULE_fixedCharArg) try: self.enterOuterAlt(localctx, 1) - self.state = 438 + self.state = 441 self.match(FuncTestCaseParser.StringLiteral) - self.state = 439 + self.state = 442 self.match(FuncTestCaseParser.DoubleColon) - self.state = 440 + self.state = 443 self.fixedCharType() except RecognitionException as re: localctx.exception = re @@ -3584,11 +3599,11 @@ def varCharArg(self): self.enterRule(localctx, 74, self.RULE_varCharArg) try: self.enterOuterAlt(localctx, 1) - self.state = 442 + self.state = 445 self.match(FuncTestCaseParser.StringLiteral) - self.state = 443 + self.state = 446 self.match(FuncTestCaseParser.DoubleColon) - self.state = 444 + self.state = 447 self.varCharType() except RecognitionException as re: localctx.exception = re @@ -3642,11 +3657,11 @@ def fixedBinaryArg(self): self.enterRule(localctx, 76, self.RULE_fixedBinaryArg) try: self.enterOuterAlt(localctx, 1) - self.state = 446 + self.state = 449 self.match(FuncTestCaseParser.StringLiteral) - self.state = 447 + self.state = 450 self.match(FuncTestCaseParser.DoubleColon) - self.state = 448 + self.state = 451 self.fixedBinaryType() except RecognitionException as re: localctx.exception = re @@ -3700,11 +3715,11 @@ def precisionTimeArg(self): self.enterRule(localctx, 78, self.RULE_precisionTimeArg) try: self.enterOuterAlt(localctx, 1) - self.state = 450 + self.state = 453 self.match(FuncTestCaseParser.TimeLiteral) - self.state = 451 + self.state = 454 self.match(FuncTestCaseParser.DoubleColon) - self.state = 452 + self.state = 455 self.precisionTimeType() except RecognitionException as re: localctx.exception = re @@ -3758,11 +3773,11 @@ def precisionTimestampArg(self): self.enterRule(localctx, 80, self.RULE_precisionTimestampArg) try: self.enterOuterAlt(localctx, 1) - self.state = 454 + self.state = 457 self.match(FuncTestCaseParser.TimestampLiteral) - self.state = 455 + self.state = 458 self.match(FuncTestCaseParser.DoubleColon) - self.state = 456 + self.state = 459 self.precisionTimestampType() except RecognitionException as re: localctx.exception = re @@ -3816,11 +3831,11 @@ def precisionTimestampTZArg(self): self.enterRule(localctx, 82, self.RULE_precisionTimestampTZArg) try: self.enterOuterAlt(localctx, 1) - self.state = 458 + self.state = 461 self.match(FuncTestCaseParser.TimestampTzLiteral) - self.state = 459 + self.state = 462 self.match(FuncTestCaseParser.DoubleColon) - self.state = 460 + self.state = 463 self.precisionTimestampTZType() except RecognitionException as re: localctx.exception = re @@ -3875,11 +3890,11 @@ def listArg(self): self.enterRule(localctx, 84, self.RULE_listArg) try: self.enterOuterAlt(localctx, 1) - self.state = 462 + self.state = 465 self.literalList() - self.state = 463 + self.state = 466 self.match(FuncTestCaseParser.DoubleColon) - self.state = 464 + self.state = 467 self.listType() except RecognitionException as re: localctx.exception = re @@ -3934,11 +3949,11 @@ def lambdaArg(self): self.enterRule(localctx, 86, self.RULE_lambdaArg) try: self.enterOuterAlt(localctx, 1) - self.state = 466 + self.state = 469 self.literalLambda() - self.state = 467 + self.state = 470 self.match(FuncTestCaseParser.DoubleColon) - self.state = 468 + self.state = 471 self.funcType() except RecognitionException as re: localctx.exception = re @@ -3949,6 +3964,82 @@ def lambdaArg(self): return localctx + class UdtArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.isnull = None # Token + + def literal(self): + return self.getTypedRuleContext(FuncTestCaseParser.LiteralContext,0) + + + def DoubleColon(self): + return self.getToken(FuncTestCaseParser.DoubleColon, 0) + + def UserDefined(self): + return self.getToken(FuncTestCaseParser.UserDefined, 0) + + def Identifier(self): + return self.getToken(FuncTestCaseParser.Identifier, 0) + + def QMark(self): + return self.getToken(FuncTestCaseParser.QMark, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_udtArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUdtArg" ): + listener.enterUdtArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUdtArg" ): + listener.exitUdtArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUdtArg" ): + return visitor.visitUdtArg(self) + else: + return visitor.visitChildren(self) + + + + + def udtArg(self): + + localctx = FuncTestCaseParser.UdtArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 88, self.RULE_udtArg) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 473 + self.literal() + self.state = 474 + self.match(FuncTestCaseParser.DoubleColon) + self.state = 475 + self.match(FuncTestCaseParser.UserDefined) + self.state = 476 + self.match(FuncTestCaseParser.Identifier) + self.state = 478 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==116: + self.state = 477 + localctx.isnull = self.match(FuncTestCaseParser.QMark) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class LiteralListContext(ParserRuleContext): __slots__ = 'parser' @@ -3998,33 +4089,33 @@ def accept(self, visitor:ParseTreeVisitor): def literalList(self): localctx = FuncTestCaseParser.LiteralListContext(self, self._ctx, self.state) - self.enterRule(localctx, 88, self.RULE_literalList) + self.enterRule(localctx, 90, self.RULE_literalList) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 470 + self.state = 480 self.match(FuncTestCaseParser.OBracket) - self.state = 479 + self.state = 489 self._errHandler.sync(self) _la = self._input.LA(1) if (((_la) & ~0x3f) == 0 and ((1 << _la) & 65974976118784) != 0): - self.state = 471 + self.state = 481 self.literal() - self.state = 476 + self.state = 486 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 472 + self.state = 482 self.match(FuncTestCaseParser.Comma) - self.state = 473 + self.state = 483 self.literal() - self.state = 478 + self.state = 488 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 481 + self.state = 491 self.match(FuncTestCaseParser.CBracket) except RecognitionException as re: localctx.exception = re @@ -4082,18 +4173,18 @@ def accept(self, visitor:ParseTreeVisitor): def literalLambda(self): localctx = FuncTestCaseParser.LiteralLambdaContext(self, self._ctx, self.state) - self.enterRule(localctx, 90, self.RULE_literalLambda) + self.enterRule(localctx, 92, self.RULE_literalLambda) try: self.enterOuterAlt(localctx, 1) - self.state = 483 + self.state = 493 self.match(FuncTestCaseParser.OParen) - self.state = 484 + self.state = 494 self.lambdaParameters() - self.state = 485 + self.state = 495 self.match(FuncTestCaseParser.Arrow) - self.state = 486 + self.state = 496 self.lambdaBody() - self.state = 487 + self.state = 497 self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re @@ -4185,40 +4276,40 @@ def accept(self, visitor:ParseTreeVisitor): def lambdaParameters(self): localctx = FuncTestCaseParser.LambdaParametersContext(self, self._ctx, self.state) - self.enterRule(localctx, 92, self.RULE_lambdaParameters) + self.enterRule(localctx, 94, self.RULE_lambdaParameters) self._la = 0 # Token type try: - self.state = 499 + self.state = 509 self._errHandler.sync(self) token = self._input.LA(1) if token in [124]: localctx = FuncTestCaseParser.SingleParamContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 489 + self.state = 499 self.match(FuncTestCaseParser.Identifier) pass elif token in [110]: localctx = FuncTestCaseParser.TupleParamsContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 490 + self.state = 500 self.match(FuncTestCaseParser.OParen) - self.state = 491 + self.state = 501 self.match(FuncTestCaseParser.Identifier) - self.state = 494 + self.state = 504 self._errHandler.sync(self) _la = self._input.LA(1) while True: - self.state = 492 + self.state = 502 self.match(FuncTestCaseParser.Comma) - self.state = 493 + self.state = 503 self.match(FuncTestCaseParser.Identifier) - self.state = 496 + self.state = 506 self._errHandler.sync(self) _la = self._input.LA(1) if not (_la==114): break - self.state = 498 + self.state = 508 self.match(FuncTestCaseParser.CParen) pass else: @@ -4277,16 +4368,16 @@ def accept(self, visitor:ParseTreeVisitor): def lambdaBody(self): localctx = FuncTestCaseParser.LambdaBodyContext(self, self._ctx, self.state) - self.enterRule(localctx, 94, self.RULE_lambdaBody) + self.enterRule(localctx, 96, self.RULE_lambdaBody) try: self.enterOuterAlt(localctx, 1) - self.state = 501 + self.state = 511 self.identifier() - self.state = 502 + self.state = 512 self.match(FuncTestCaseParser.OParen) - self.state = 503 + self.state = 513 self.arguments() - self.state = 504 + self.state = 514 self.match(FuncTestCaseParser.CParen) except RecognitionException as re: localctx.exception = re @@ -4335,19 +4426,19 @@ def accept(self, visitor:ParseTreeVisitor): def dataType(self): localctx = FuncTestCaseParser.DataTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 96, self.RULE_dataType) + self.enterRule(localctx, 98, self.RULE_dataType) try: - self.state = 508 + self.state = 518 self._errHandler.sync(self) token = self._input.LA(1) if token in [53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 68, 80, 81, 82, 83, 84, 85, 86]: self.enterOuterAlt(localctx, 1) - self.state = 506 + self.state = 516 self.scalarType() pass elif token in [52, 67, 69, 70, 71, 72, 73, 74, 75, 87, 88, 89, 90, 91, 92, 93, 94]: self.enterOuterAlt(localctx, 2) - self.state = 507 + self.state = 517 self.parameterizedType() pass else: @@ -4689,82 +4780,82 @@ def accept(self, visitor:ParseTreeVisitor): def scalarType(self): localctx = FuncTestCaseParser.ScalarTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 98, self.RULE_scalarType) + self.enterRule(localctx, 100, self.RULE_scalarType) self._la = 0 # Token type try: - self.state = 529 + self.state = 539 self._errHandler.sync(self) token = self._input.LA(1) if token in [53, 81]: localctx = FuncTestCaseParser.BooleanContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 510 + self.state = 520 self.booleanType() pass elif token in [54, 55, 56, 57]: localctx = FuncTestCaseParser.IntContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 511 + self.state = 521 self.intType() pass elif token in [58, 59]: localctx = FuncTestCaseParser.FloatContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 512 + self.state = 522 self.floatType() pass elif token in [60, 82]: localctx = FuncTestCaseParser.StringContext(self, localctx) self.enterOuterAlt(localctx, 4) - self.state = 513 + self.state = 523 self.stringType() pass elif token in [61, 83]: localctx = FuncTestCaseParser.BinaryContext(self, localctx) self.enterOuterAlt(localctx, 5) - self.state = 514 + self.state = 524 self.binaryType() pass elif token in [62, 84]: localctx = FuncTestCaseParser.TimestampContext(self, localctx) self.enterOuterAlt(localctx, 6) - self.state = 515 + self.state = 525 self.timestampType() pass elif token in [63, 85]: localctx = FuncTestCaseParser.TimestampTzContext(self, localctx) self.enterOuterAlt(localctx, 7) - self.state = 516 + self.state = 526 self.timestampTZType() pass elif token in [64]: localctx = FuncTestCaseParser.DateContext(self, localctx) self.enterOuterAlt(localctx, 8) - self.state = 517 + self.state = 527 self.dateType() pass elif token in [65]: localctx = FuncTestCaseParser.TimeContext(self, localctx) self.enterOuterAlt(localctx, 9) - self.state = 518 + self.state = 528 self.timeType() pass elif token in [66, 86]: localctx = FuncTestCaseParser.IntervalYearContext(self, localctx) self.enterOuterAlt(localctx, 10) - self.state = 519 + self.state = 529 self.intervalYearType() pass elif token in [68]: localctx = FuncTestCaseParser.UuidContext(self, localctx) self.enterOuterAlt(localctx, 11) - self.state = 520 + self.state = 530 self.match(FuncTestCaseParser.UUID) - self.state = 522 + self.state = 532 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 521 + self.state = 531 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -4772,15 +4863,15 @@ def scalarType(self): elif token in [80]: localctx = FuncTestCaseParser.UserDefinedContext(self, localctx) self.enterOuterAlt(localctx, 12) - self.state = 524 + self.state = 534 self.match(FuncTestCaseParser.UserDefined) - self.state = 525 + self.state = 535 self.match(FuncTestCaseParser.Identifier) - self.state = 527 + self.state = 537 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 526 + self.state = 536 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -4837,22 +4928,22 @@ def accept(self, visitor:ParseTreeVisitor): def booleanType(self): localctx = FuncTestCaseParser.BooleanTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 100, self.RULE_booleanType) + self.enterRule(localctx, 102, self.RULE_booleanType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 531 + self.state = 541 _la = self._input.LA(1) if not(_la==53 or _la==81): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 533 + self.state = 543 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 532 + self.state = 542 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -4905,22 +4996,22 @@ def accept(self, visitor:ParseTreeVisitor): def stringType(self): localctx = FuncTestCaseParser.StringTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 102, self.RULE_stringType) + self.enterRule(localctx, 104, self.RULE_stringType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 535 + self.state = 545 _la = self._input.LA(1) if not(_la==60 or _la==82): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 537 + self.state = 547 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 536 + self.state = 546 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -4973,22 +5064,22 @@ def accept(self, visitor:ParseTreeVisitor): def binaryType(self): localctx = FuncTestCaseParser.BinaryTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 104, self.RULE_binaryType) + self.enterRule(localctx, 106, self.RULE_binaryType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 539 + self.state = 549 _la = self._input.LA(1) if not(_la==61 or _la==83): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 541 + self.state = 551 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 540 + self.state = 550 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5047,22 +5138,22 @@ def accept(self, visitor:ParseTreeVisitor): def intType(self): localctx = FuncTestCaseParser.IntTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 106, self.RULE_intType) + self.enterRule(localctx, 108, self.RULE_intType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 543 + self.state = 553 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 270215977642229760) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 545 + self.state = 555 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 544 + self.state = 554 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5115,22 +5206,22 @@ def accept(self, visitor:ParseTreeVisitor): def floatType(self): localctx = FuncTestCaseParser.FloatTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 108, self.RULE_floatType) + self.enterRule(localctx, 110, self.RULE_floatType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 547 + self.state = 557 _la = self._input.LA(1) if not(_la==58 or _la==59): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 549 + self.state = 559 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 548 + self.state = 558 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5180,17 +5271,17 @@ def accept(self, visitor:ParseTreeVisitor): def dateType(self): localctx = FuncTestCaseParser.DateTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 110, self.RULE_dateType) + self.enterRule(localctx, 112, self.RULE_dateType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 551 + self.state = 561 self.match(FuncTestCaseParser.Date) - self.state = 553 + self.state = 563 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 552 + self.state = 562 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5240,17 +5331,17 @@ def accept(self, visitor:ParseTreeVisitor): def timeType(self): localctx = FuncTestCaseParser.TimeTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 112, self.RULE_timeType) + self.enterRule(localctx, 114, self.RULE_timeType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 555 + self.state = 565 self.match(FuncTestCaseParser.Time) - self.state = 557 + self.state = 567 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 556 + self.state = 566 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5303,22 +5394,22 @@ def accept(self, visitor:ParseTreeVisitor): def timestampType(self): localctx = FuncTestCaseParser.TimestampTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 114, self.RULE_timestampType) + self.enterRule(localctx, 116, self.RULE_timestampType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 559 + self.state = 569 _la = self._input.LA(1) if not(_la==62 or _la==84): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 561 + self.state = 571 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 560 + self.state = 570 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5371,22 +5462,22 @@ def accept(self, visitor:ParseTreeVisitor): def timestampTZType(self): localctx = FuncTestCaseParser.TimestampTZTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 116, self.RULE_timestampTZType) + self.enterRule(localctx, 118, self.RULE_timestampTZType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 563 + self.state = 573 _la = self._input.LA(1) if not(_la==63 or _la==85): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 565 + self.state = 575 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 564 + self.state = 574 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5439,22 +5530,22 @@ def accept(self, visitor:ParseTreeVisitor): def intervalYearType(self): localctx = FuncTestCaseParser.IntervalYearTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 118, self.RULE_intervalYearType) + self.enterRule(localctx, 120, self.RULE_intervalYearType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 567 + self.state = 577 _la = self._input.LA(1) if not(_la==66 or _la==86): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 569 + self.state = 579 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 568 + self.state = 578 localctx.isnull = self.match(FuncTestCaseParser.QMark) @@ -5518,34 +5609,34 @@ def accept(self, visitor:ParseTreeVisitor): def intervalDayType(self): localctx = FuncTestCaseParser.IntervalDayTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 120, self.RULE_intervalDayType) + self.enterRule(localctx, 122, self.RULE_intervalDayType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 571 + self.state = 581 _la = self._input.LA(1) if not(_la==67 or _la==87): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 573 + self.state = 583 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 572 + self.state = 582 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 579 + self.state = 589 self._errHandler.sync(self) _la = self._input.LA(1) if _la==40: - self.state = 575 + self.state = 585 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 576 + self.state = 586 localctx.len_ = self.numericParameter() - self.state = 577 + self.state = 587 self.match(FuncTestCaseParser.CAngleBracket) @@ -5609,30 +5700,30 @@ def accept(self, visitor:ParseTreeVisitor): def fixedCharType(self): localctx = FuncTestCaseParser.FixedCharTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 122, self.RULE_fixedCharType) + self.enterRule(localctx, 124, self.RULE_fixedCharType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 581 + self.state = 591 _la = self._input.LA(1) if not(_la==73 or _la==92): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 583 + self.state = 593 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 582 + self.state = 592 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 585 + self.state = 595 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 586 + self.state = 596 localctx.len_ = self.numericParameter() - self.state = 587 + self.state = 597 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -5694,30 +5785,30 @@ def accept(self, visitor:ParseTreeVisitor): def varCharType(self): localctx = FuncTestCaseParser.VarCharTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 124, self.RULE_varCharType) + self.enterRule(localctx, 126, self.RULE_varCharType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 589 + self.state = 599 _la = self._input.LA(1) if not(_la==74 or _la==93): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 591 + self.state = 601 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 590 + self.state = 600 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 593 + self.state = 603 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 594 + self.state = 604 localctx.len_ = self.numericParameter() - self.state = 595 + self.state = 605 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -5779,30 +5870,30 @@ def accept(self, visitor:ParseTreeVisitor): def fixedBinaryType(self): localctx = FuncTestCaseParser.FixedBinaryTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 126, self.RULE_fixedBinaryType) + self.enterRule(localctx, 128, self.RULE_fixedBinaryType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 597 + self.state = 607 _la = self._input.LA(1) if not(_la==75 or _la==94): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 599 + self.state = 609 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 598 + self.state = 608 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 601 + self.state = 611 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 602 + self.state = 612 localctx.len_ = self.numericParameter() - self.state = 603 + self.state = 613 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -5871,38 +5962,38 @@ def accept(self, visitor:ParseTreeVisitor): def decimalType(self): localctx = FuncTestCaseParser.DecimalTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 128, self.RULE_decimalType) + self.enterRule(localctx, 130, self.RULE_decimalType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 605 + self.state = 615 _la = self._input.LA(1) if not(_la==69 or _la==88): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 607 + self.state = 617 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 606 + self.state = 616 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 615 + self.state = 625 self._errHandler.sync(self) _la = self._input.LA(1) if _la==40: - self.state = 609 + self.state = 619 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 610 + self.state = 620 localctx.precision = self.numericParameter() - self.state = 611 + self.state = 621 self.match(FuncTestCaseParser.Comma) - self.state = 612 + self.state = 622 localctx.scale = self.numericParameter() - self.state = 613 + self.state = 623 self.match(FuncTestCaseParser.CAngleBracket) @@ -5966,30 +6057,30 @@ def accept(self, visitor:ParseTreeVisitor): def precisionTimeType(self): localctx = FuncTestCaseParser.PrecisionTimeTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 130, self.RULE_precisionTimeType) + self.enterRule(localctx, 132, self.RULE_precisionTimeType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 617 + self.state = 627 _la = self._input.LA(1) if not(_la==70 or _la==89): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 619 + self.state = 629 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 618 + self.state = 628 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 621 + self.state = 631 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 622 + self.state = 632 localctx.precision = self.numericParameter() - self.state = 623 + self.state = 633 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6051,30 +6142,30 @@ def accept(self, visitor:ParseTreeVisitor): def precisionTimestampType(self): localctx = FuncTestCaseParser.PrecisionTimestampTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 132, self.RULE_precisionTimestampType) + self.enterRule(localctx, 134, self.RULE_precisionTimestampType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 625 + self.state = 635 _la = self._input.LA(1) if not(_la==71 or _la==90): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 627 + self.state = 637 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 626 + self.state = 636 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 629 + self.state = 639 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 630 + self.state = 640 localctx.precision = self.numericParameter() - self.state = 631 + self.state = 641 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6136,30 +6227,30 @@ def accept(self, visitor:ParseTreeVisitor): def precisionTimestampTZType(self): localctx = FuncTestCaseParser.PrecisionTimestampTZTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 134, self.RULE_precisionTimestampTZType) + self.enterRule(localctx, 136, self.RULE_precisionTimestampTZType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 633 + self.state = 643 _la = self._input.LA(1) if not(_la==72 or _la==91): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 635 + self.state = 645 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 634 + self.state = 644 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 637 + self.state = 647 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 638 + self.state = 648 localctx.precision = self.numericParameter() - self.state = 639 + self.state = 649 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6226,26 +6317,26 @@ def accept(self, visitor:ParseTreeVisitor): def listType(self): localctx = FuncTestCaseParser.ListTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 136, self.RULE_listType) + self.enterRule(localctx, 138, self.RULE_listType) self._la = 0 # Token type try: localctx = FuncTestCaseParser.ListContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 641 + self.state = 651 self.match(FuncTestCaseParser.List) - self.state = 643 + self.state = 653 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 642 + self.state = 652 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 645 + self.state = 655 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 646 + self.state = 656 localctx.elemType = self.dataType() - self.state = 647 + self.state = 657 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6312,29 +6403,29 @@ def accept(self, visitor:ParseTreeVisitor): def funcType(self): localctx = FuncTestCaseParser.FuncTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 138, self.RULE_funcType) + self.enterRule(localctx, 140, self.RULE_funcType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 649 + self.state = 659 self.match(FuncTestCaseParser.Func) - self.state = 651 + self.state = 661 self._errHandler.sync(self) _la = self._input.LA(1) if _la==116: - self.state = 650 + self.state = 660 localctx.isnull = self.match(FuncTestCaseParser.QMark) - self.state = 653 + self.state = 663 self.match(FuncTestCaseParser.OAngleBracket) - self.state = 654 + self.state = 664 localctx.params = self.funcParameters() - self.state = 655 + self.state = 665 self.match(FuncTestCaseParser.Arrow) - self.state = 656 + self.state = 666 localctx.returnType = self.dataType() - self.state = 657 + self.state = 667 self.match(FuncTestCaseParser.CAngleBracket) except RecognitionException as re: localctx.exception = re @@ -6428,38 +6519,38 @@ def accept(self, visitor:ParseTreeVisitor): def funcParameters(self): localctx = FuncTestCaseParser.FuncParametersContext(self, self._ctx, self.state) - self.enterRule(localctx, 140, self.RULE_funcParameters) + self.enterRule(localctx, 142, self.RULE_funcParameters) self._la = 0 # Token type try: - self.state = 671 + self.state = 681 self._errHandler.sync(self) token = self._input.LA(1) if token in [52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94]: localctx = FuncTestCaseParser.SingleFuncParamContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 659 + self.state = 669 self.dataType() pass elif token in [110]: localctx = FuncTestCaseParser.FuncParamsWithParensContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 660 + self.state = 670 self.match(FuncTestCaseParser.OParen) - self.state = 661 + self.state = 671 self.dataType() - self.state = 666 + self.state = 676 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 662 + self.state = 672 self.match(FuncTestCaseParser.Comma) - self.state = 663 + self.state = 673 self.dataType() - self.state = 668 + self.state = 678 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 669 + self.state = 679 self.match(FuncTestCaseParser.CParen) pass else: @@ -6540,54 +6631,54 @@ def accept(self, visitor:ParseTreeVisitor): def parameterizedType(self): localctx = FuncTestCaseParser.ParameterizedTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 142, self.RULE_parameterizedType) + self.enterRule(localctx, 144, self.RULE_parameterizedType) try: - self.state = 682 + self.state = 692 self._errHandler.sync(self) token = self._input.LA(1) if token in [73, 92]: self.enterOuterAlt(localctx, 1) - self.state = 673 + self.state = 683 self.fixedCharType() pass elif token in [74, 93]: self.enterOuterAlt(localctx, 2) - self.state = 674 + self.state = 684 self.varCharType() pass elif token in [75, 94]: self.enterOuterAlt(localctx, 3) - self.state = 675 + self.state = 685 self.fixedBinaryType() pass elif token in [69, 88]: self.enterOuterAlt(localctx, 4) - self.state = 676 + self.state = 686 self.decimalType() pass elif token in [67, 87]: self.enterOuterAlt(localctx, 5) - self.state = 677 + self.state = 687 self.intervalDayType() pass elif token in [70, 89]: self.enterOuterAlt(localctx, 6) - self.state = 678 + self.state = 688 self.precisionTimeType() pass elif token in [71, 90]: self.enterOuterAlt(localctx, 7) - self.state = 679 + self.state = 689 self.precisionTimestampType() pass elif token in [72, 91]: self.enterOuterAlt(localctx, 8) - self.state = 680 + self.state = 690 self.precisionTimestampTZType() pass elif token in [52]: self.enterOuterAlt(localctx, 9) - self.state = 681 + self.state = 691 self.funcType() pass else: @@ -6647,11 +6738,11 @@ def accept(self, visitor:ParseTreeVisitor): def numericParameter(self): localctx = FuncTestCaseParser.NumericParameterContext(self, self._ctx, self.state) - self.enterRule(localctx, 144, self.RULE_numericParameter) + self.enterRule(localctx, 146, self.RULE_numericParameter) try: localctx = FuncTestCaseParser.IntegerLiteralContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 684 + self.state = 694 self.match(FuncTestCaseParser.IntegerLiteral) except RecognitionException as re: localctx.exception = re @@ -6698,11 +6789,11 @@ def accept(self, visitor:ParseTreeVisitor): def substraitError(self): localctx = FuncTestCaseParser.SubstraitErrorContext(self, self._ctx, self.state) - self.enterRule(localctx, 146, self.RULE_substraitError) + self.enterRule(localctx, 148, self.RULE_substraitError) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 686 + self.state = 696 _la = self._input.LA(1) if not(_la==10 or _la==11): self._errHandler.recoverInline(self) @@ -6759,14 +6850,14 @@ def accept(self, visitor:ParseTreeVisitor): def funcOption(self): localctx = FuncTestCaseParser.FuncOptionContext(self, self._ctx, self.state) - self.enterRule(localctx, 148, self.RULE_funcOption) + self.enterRule(localctx, 150, self.RULE_funcOption) try: self.enterOuterAlt(localctx, 1) - self.state = 688 + self.state = 698 self.optionName() - self.state = 689 + self.state = 699 self.match(FuncTestCaseParser.Colon) - self.state = 690 + self.state = 700 self.optionValue() except RecognitionException as re: localctx.exception = re @@ -6822,11 +6913,11 @@ def accept(self, visitor:ParseTreeVisitor): def optionName(self): localctx = FuncTestCaseParser.OptionNameContext(self, self._ctx, self.state) - self.enterRule(localctx, 150, self.RULE_optionName) + self.enterRule(localctx, 152, self.RULE_optionName) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 692 + self.state = 702 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 6303744) != 0) or _la==124): self._errHandler.recoverInline(self) @@ -6905,11 +6996,11 @@ def accept(self, visitor:ParseTreeVisitor): def optionValue(self): localctx = FuncTestCaseParser.OptionValueContext(self, self._ctx, self.state) - self.enterRule(localctx, 152, self.RULE_optionValue) + self.enterRule(localctx, 154, self.RULE_optionValue) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 694 + self.state = 704 _la = self._input.LA(1) if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 17592330731520) != 0) or _la==124): self._errHandler.recoverInline(self) @@ -6968,21 +7059,21 @@ def accept(self, visitor:ParseTreeVisitor): def funcOptions(self): localctx = FuncTestCaseParser.FuncOptionsContext(self, self._ctx, self.state) - self.enterRule(localctx, 154, self.RULE_funcOptions) + self.enterRule(localctx, 156, self.RULE_funcOptions) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 696 + self.state = 706 self.funcOption() - self.state = 701 + self.state = 711 self._errHandler.sync(self) _la = self._input.LA(1) while _la==114: - self.state = 697 + self.state = 707 self.match(FuncTestCaseParser.Comma) - self.state = 698 + self.state = 708 self.funcOption() - self.state = 703 + self.state = 713 self._errHandler.sync(self) _la = self._input.LA(1) @@ -7034,11 +7125,11 @@ def accept(self, visitor:ParseTreeVisitor): def nonReserved(self): localctx = FuncTestCaseParser.NonReservedContext(self, self._ctx, self.state) - self.enterRule(localctx, 156, self.RULE_nonReserved) + self.enterRule(localctx, 158, self.RULE_nonReserved) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 704 + self.state = 714 _la = self._input.LA(1) if not(_la==23 or _la==119 or _la==120): self._errHandler.recoverInline(self) @@ -7091,19 +7182,19 @@ def accept(self, visitor:ParseTreeVisitor): def identifier(self): localctx = FuncTestCaseParser.IdentifierContext(self, self._ctx, self.state) - self.enterRule(localctx, 158, self.RULE_identifier) + self.enterRule(localctx, 160, self.RULE_identifier) try: - self.state = 708 + self.state = 718 self._errHandler.sync(self) token = self._input.LA(1) if token in [23, 119, 120]: self.enterOuterAlt(localctx, 1) - self.state = 706 + self.state = 716 self.nonReserved() pass elif token in [124]: self.enterOuterAlt(localctx, 2) - self.state = 707 + self.state = 717 self.match(FuncTestCaseParser.Identifier) pass else: diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py index 7531b452a..e00e95153 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py @@ -432,6 +432,15 @@ def exitLambdaArg(self, ctx:FuncTestCaseParser.LambdaArgContext): pass + # Enter a parse tree produced by FuncTestCaseParser#udtArg. + def enterUdtArg(self, ctx:FuncTestCaseParser.UdtArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#udtArg. + def exitUdtArg(self, ctx:FuncTestCaseParser.UdtArgContext): + pass + + # Enter a parse tree produced by FuncTestCaseParser#literalList. def enterLiteralList(self, ctx:FuncTestCaseParser.LiteralListContext): pass diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py index 5b759586e..9b19a4548 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py @@ -245,6 +245,11 @@ def visitLambdaArg(self, ctx:FuncTestCaseParser.LambdaArgContext): return self.visitChildren(ctx) + # Visit a parse tree produced by FuncTestCaseParser#udtArg. + def visitUdtArg(self, ctx:FuncTestCaseParser.UdtArgContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by FuncTestCaseParser#literalList. def visitLiteralList(self, ctx:FuncTestCaseParser.LiteralListContext): return self.visitChildren(ctx) diff --git a/tests/coverage/extensions.py b/tests/coverage/extensions.py index 208be9b5e..4432dc14a 100644 --- a/tests/coverage/extensions.py +++ b/tests/coverage/extensions.py @@ -149,7 +149,7 @@ def read_substrait_extensions(dir_path: str): extensions = [] for root, dirs, files in os.walk(dir_path): for file in files: - if file.endswith(".yaml") and file.startswith("functions_"): + if file.endswith(".yaml") and file != "unknown.yaml": extensions.append(os.path.join(root, file)) extensions.sort() diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py index 3cb17cf75..5c37675c5 100644 --- a/tests/coverage/visitor.py +++ b/tests/coverage/visitor.py @@ -297,6 +297,8 @@ def visitArgument(self, ctx: FuncTestCaseParser.ArgumentContext): return self.visitListArg(ctx.listArg()) if ctx.lambdaArg() is not None: return self.visitLambdaArg(ctx.lambdaArg()) + if ctx.udtArg() is not None: + return self.visitUdtArg(ctx.udtArg()) return CaseLiteral(value="unknown_value", type="unknown_type") @@ -381,6 +383,14 @@ def visitLambdaArg(self, ctx: FuncTestCaseParser.LambdaArgContext): lambda_type = ctx.funcType().getText() return CaseLiteral(value="lambda", type=lambda_type) + def visitUdtArg(self, ctx: FuncTestCaseParser.UdtArgContext): + value, _ = self.visitLiteral(ctx.literal()) + # Type is "u!" + identifier, e.g., "u!u8" + type_str = "u!" + ctx.Identifier().getText().lower() + if ctx.isnull is not None: + type_str += "?" + return CaseLiteral(value=value, type=type_str) + def visitResult(self, ctx: FuncTestCaseParser.ResultContext): if ctx.argument() is not None: return self.visitArgument(ctx.argument())