From 2f35db061d39986f8d47ec8e019fbed2b5459e9b Mon Sep 17 00:00:00 2001 From: Henrik Barthels <25176271+hbarthels@users.noreply.github.com> Date: Wed, 22 Jul 2026 21:07:54 +0200 Subject: [PATCH 1/3] Support synthetic keys in the (relations ...) CSV loading form Add a `(keys :synthetic_key)` form as an alternative to the explicit `(keys (column ...) ...)` clause. This tells the loader to synthesize the shared key instead of drawing it from CSV columns. It works with both plain and CDC loading, and any marker other than `:synthetic_key` is a hard error. Source-of-truth changes (all SDK code is regenerated from these): - proto: add `bool synthetic_key = 4` to `TargetRelations`, mutually exclusive with `keys` (additive field, so `buf breaking` passes). - grammar: add the `(keys :synthetic_key)` alternative to `relation_keys`, carry the flag through `construct_relations`, and reject unknown markers. Regenerated the Python, Go, and Julia protobuf bindings, parsers, and pretty printers, and added round-trip fixtures plus parser unit tests. Co-Authored-By: Claude Opus 4.8 --- meta/src/meta/grammar.y | 31 +- proto/relationalai/lqp/v1/logic.proto | 5 +- sdks/go/src/lqp/v1/logic.pb.go | 567 +- sdks/go/src/parser.go | 5904 +++++++++-------- sdks/go/src/pretty.go | 4127 ++++++------ .../src/gen/relationalai/lqp/v1/logic_pb.jl | 14 +- .../LogicalQueryProtocol.jl/src/parser.jl | 4975 +++++++------- .../LogicalQueryProtocol.jl/src/pretty.jl | 4174 ++++++------ sdks/python/src/lqp/gen/parser.py | 4912 +++++++------- sdks/python/src/lqp/gen/pretty.py | 4723 ++++++------- sdks/python/src/lqp/proto/v1/logic_pb2.py | 132 +- sdks/python/src/lqp/proto/v1/logic_pb2.pyi | 6 +- sdks/python/tests/test_parser.py | 33 + tests/bin/relations_synthetic_key.bin | Bin 0 -> 304 bytes tests/bin/relations_synthetic_key_cdc.bin | Bin 0 -> 319 bytes tests/lqp/relations_synthetic_key.lqp | 23 + tests/lqp/relations_synthetic_key_cdc.lqp | 25 + tests/pretty/relations_synthetic_key.lqp | 25 + tests/pretty/relations_synthetic_key_cdc.lqp | 25 + .../pretty_debug/relations_synthetic_key.lqp | 33 + .../relations_synthetic_key_cdc.lqp | 33 + 21 files changed, 15128 insertions(+), 14639 deletions(-) create mode 100644 tests/bin/relations_synthetic_key.bin create mode 100644 tests/bin/relations_synthetic_key_cdc.bin create mode 100644 tests/lqp/relations_synthetic_key.lqp create mode 100644 tests/lqp/relations_synthetic_key_cdc.lqp create mode 100644 tests/pretty/relations_synthetic_key.lqp create mode 100644 tests/pretty/relations_synthetic_key_cdc.lqp create mode 100644 tests/pretty_debug/relations_synthetic_key.lqp create mode 100644 tests/pretty_debug/relations_synthetic_key_cdc.lqp diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index f5ef184d..578fd3dd 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -88,7 +88,7 @@ %nonterm gnf_column_path Sequence[String] %nonterm gnf_columns Sequence[logic.GNFColumn] %nonterm named_column logic.NamedColumn -%nonterm relation_keys Sequence[logic.NamedColumn] +%nonterm relation_keys Tuple[Sequence[logic.NamedColumn], Boolean] %nonterm target_relation logic.TargetRelation %nonterm non_cdc_relations Sequence[logic.TargetRelation] %nonterm cdc_inserts Sequence[logic.TargetRelation] @@ -1134,6 +1134,13 @@ named_column relation_keys : "(" "keys" named_column* ")" + construct: $$ = builtin.tuple($3, False) + deconstruct if not $$[1]: + $3: Sequence[logic.NamedColumn] = $$[0] + | "(" "keys" ":" SYMBOL ")" + construct: $$ = construct_synthetic_keys($4) + deconstruct if $$[1]: + $4: String = "synthetic_key" target_relation : "(" "relation" relation_id named_column* ")" @@ -1166,7 +1173,7 @@ target_relations : "(" "relations" relation_keys relation_body ")" construct: $$ = construct_relations($3, $4) deconstruct: - $3: Sequence[logic.NamedColumn] = $$.keys + $3: Tuple[Sequence[logic.NamedColumn], Boolean] = deconstruct_relation_keys($$) $4: logic.TargetRelations = $$ csv_locator_paths @@ -1558,13 +1565,27 @@ def construct_cdc_relations( ) +def construct_synthetic_keys( + marker: String, +) -> Tuple[Sequence[logic.NamedColumn], Boolean]: + if marker != "synthetic_key": + builtin.error("expected the `:synthetic_key` marker in the relation keys clause") + return builtin.tuple(list[logic.NamedColumn](), True) + + +def deconstruct_relation_keys( + msg: logic.TargetRelations, +) -> Tuple[Sequence[logic.NamedColumn], Boolean]: + return builtin.tuple(msg.keys, msg.synthetic_key) + + def construct_relations( - keys: Sequence[logic.NamedColumn], + keys: Tuple[Sequence[logic.NamedColumn], Boolean], body: logic.TargetRelations, ) -> logic.TargetRelations: if builtin.has_proto_field(body, "plain"): - return logic.TargetRelations(keys=keys, plain=body.plain) - return logic.TargetRelations(keys=keys, cdc=body.cdc) + return logic.TargetRelations(keys=keys[0], synthetic_key=keys[1], plain=body.plain) + return logic.TargetRelations(keys=keys[0], synthetic_key=keys[1], cdc=body.cdc) def construct_csv_data( diff --git a/proto/relationalai/lqp/v1/logic.proto b/proto/relationalai/lqp/v1/logic.proto index 16a45990..c1eeb495 100644 --- a/proto/relationalai/lqp/v1/logic.proto +++ b/proto/relationalai/lqp/v1/logic.proto @@ -315,11 +315,14 @@ message CDCTargets { // Generalized loading: shared key columns plus the target relations, loaded either as a // plain snapshot or as CDC insert/delete deltas. The two modes are mutually exclusive. message TargetRelations { - repeated NamedColumn keys = 1; // Shared key columns + repeated NamedColumn keys = 1; // Shared key columns; must be empty when synthetic_key is set oneof body { PlainTargets plain = 2; CDCTargets cdc = 3; } + // If true, the shared key is synthesized by the loader (e.g. a generated row key) + // instead of being drawn from CSV columns. Mutually exclusive with `keys`. + bool synthetic_key = 4; } message CSVData { diff --git a/sdks/go/src/lqp/v1/logic.pb.go b/sdks/go/src/lqp/v1/logic.pb.go index 44f5c9db..edd776c8 100644 --- a/sdks/go/src/lqp/v1/logic.pb.go +++ b/sdks/go/src/lqp/v1/logic.pb.go @@ -3223,12 +3223,15 @@ func (x *CDCTargets) GetDeletes() []*TargetRelation { // plain snapshot or as CDC insert/delete deltas. The two modes are mutually exclusive. type TargetRelations struct { state protoimpl.MessageState `protogen:"open.v1"` - Keys []*NamedColumn `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` // Shared key columns + Keys []*NamedColumn `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` // Shared key columns; must be empty when synthetic_key is set // Types that are valid to be assigned to Body: // // *TargetRelations_Plain // *TargetRelations_Cdc - Body isTargetRelations_Body `protobuf_oneof:"body"` + Body isTargetRelations_Body `protobuf_oneof:"body"` + // If true, the shared key is synthesized by the loader (e.g. a generated row key) + // instead of being drawn from CSV columns. Mutually exclusive with `keys`. + SyntheticKey bool `protobuf:"varint,4,opt,name=synthetic_key,json=syntheticKey,proto3" json:"synthetic_key,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -3295,6 +3298,13 @@ func (x *TargetRelations) GetCdc() *CDCTargets { return nil } +func (x *TargetRelations) GetSyntheticKey() bool { + if x != nil { + return x.SyntheticKey + } + return false +} + type isTargetRelations_Body interface { isTargetRelations_Body() } @@ -5781,7 +5791,7 @@ var file_relationalai_lqp_v1_logic_proto_rawDesc = string([]byte{ 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x73, 0x22, 0xbf, 0x01, 0x0a, + 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x73, 0x22, 0xe4, 0x01, 0x0a, 0x0f, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x34, 0x0a, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, @@ -5793,290 +5803,293 @@ var file_relationalai_lqp_v1_logic_proto_rawDesc = string([]byte{ 0x6e, 0x12, 0x33, 0x0a, 0x03, 0x63, 0x64, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x44, 0x43, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x48, - 0x00, 0x52, 0x03, 0x63, 0x64, 0x63, 0x42, 0x06, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x22, 0xa1, - 0x02, 0x0a, 0x07, 0x43, 0x53, 0x56, 0x44, 0x61, 0x74, 0x61, 0x12, 0x39, 0x0a, 0x07, 0x6c, 0x6f, - 0x63, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, - 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, - 0x31, 0x2e, 0x43, 0x53, 0x56, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x6c, 0x6f, - 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x36, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x43, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x38, 0x0a, - 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, - 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, - 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x4e, 0x46, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, - 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x61, 0x73, 0x6f, 0x66, 0x12, 0x47, 0x0a, 0x09, 0x72, - 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, - 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, - 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x48, 0x00, 0x52, 0x09, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x88, 0x01, 0x01, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x22, 0x43, 0x0a, 0x0a, 0x43, 0x53, 0x56, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, - 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, - 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x69, 0x6e, 0x6c, - 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x22, 0x86, 0x04, 0x0a, 0x09, 0x43, 0x53, 0x56, 0x43, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, - 0x72, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x68, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x52, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, - 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4c, - 0x69, 0x6e, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, - 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x12, - 0x1e, 0x0a, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x12, - 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x69, 0x73, - 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x08, 0x20, 0x03, - 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, - 0x67, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x73, 0x65, - 0x70, 0x61, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x64, - 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x53, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, - 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x0a, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x20, 0x0a, 0x0b, 0x63, - 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, - 0x11, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, - 0x6d, 0x62, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x4d, 0x62, 0x12, 0x5d, 0x0a, 0x13, 0x73, 0x74, 0x6f, - 0x72, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, - 0x72, 0x61, 0x67, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, - 0x00, 0x52, 0x12, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x42, 0x16, 0x0a, 0x14, 0x5f, 0x73, 0x74, 0x6f, - 0x72, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x22, 0xe0, 0x02, 0x0a, 0x0b, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x44, 0x61, 0x74, 0x61, - 0x12, 0x3d, 0x0a, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, - 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x4c, - 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, - 0x41, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x29, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, - 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x61, 0x74, - 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, + 0x00, 0x52, 0x03, 0x63, 0x64, 0x63, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x79, 0x6e, 0x74, 0x68, 0x65, + 0x74, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x73, + 0x79, 0x6e, 0x74, 0x68, 0x65, 0x74, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, 0x06, 0x0a, 0x04, 0x62, + 0x6f, 0x64, 0x79, 0x22, 0xa1, 0x02, 0x0a, 0x07, 0x43, 0x53, 0x56, 0x44, 0x61, 0x74, 0x61, 0x12, + 0x39, 0x0a, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, + 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x53, 0x56, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, + 0x72, 0x52, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x36, 0x0a, 0x06, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x38, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x4e, 0x46, 0x43, 0x6f, 0x6c, - 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x28, 0x0a, 0x0d, - 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x6d, 0x53, 0x6e, 0x61, 0x70, 0x73, - 0x68, 0x6f, 0x74, 0x88, 0x01, 0x01, 0x12, 0x24, 0x0a, 0x0b, 0x74, 0x6f, 0x5f, 0x73, 0x6e, 0x61, - 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0a, 0x74, - 0x6f, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x88, 0x01, 0x01, 0x12, 0x23, 0x0a, 0x0d, - 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x44, 0x65, 0x6c, 0x74, - 0x61, 0x42, 0x10, 0x0a, 0x0e, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, - 0x68, 0x6f, 0x74, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x74, 0x6f, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, - 0x68, 0x6f, 0x74, 0x22, 0x6b, 0x0a, 0x0e, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x4c, 0x6f, - 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x61, 0x62, 0x6c, 0x65, - 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x77, 0x61, 0x72, 0x65, 0x68, 0x6f, 0x75, 0x73, 0x65, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x77, 0x61, 0x72, 0x65, 0x68, 0x6f, 0x75, 0x73, 0x65, - 0x22, 0xa1, 0x03, 0x0a, 0x14, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x61, 0x74, 0x61, - 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x61, 0x74, - 0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, - 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x55, 0x72, 0x69, 0x12, 0x19, 0x0a, 0x05, 0x73, 0x63, - 0x6f, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x05, 0x73, 0x63, 0x6f, - 0x70, 0x65, 0x88, 0x01, 0x01, 0x12, 0x59, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, - 0x69, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x72, 0x65, 0x6c, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, - 0x12, 0x66, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, - 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x72, 0x65, 0x6c, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x41, 0x75, 0x74, 0x68, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, - 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x61, 0x75, 0x74, 0x68, 0x50, 0x72, - 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x50, 0x72, 0x6f, 0x70, - 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, - 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x41, 0x75, 0x74, 0x68, 0x50, - 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, - 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, - 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x08, 0x0a, 0x06, 0x5f, 0x73, - 0x63, 0x6f, 0x70, 0x65, 0x22, 0xae, 0x01, 0x0a, 0x09, 0x47, 0x4e, 0x46, 0x43, 0x6f, 0x6c, 0x75, - 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x70, 0x61, 0x74, - 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x50, - 0x61, 0x74, 0x68, 0x12, 0x41, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x64, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x48, 0x00, 0x52, 0x08, 0x74, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x49, 0x64, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, - 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x79, 0x70, 0x65, - 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x74, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x5f, 0x69, 0x64, 0x22, 0x3c, 0x0a, 0x0a, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x49, 0x64, 0x12, 0x15, 0x0a, 0x06, 0x69, 0x64, 0x5f, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x06, 0x52, 0x05, 0x69, 0x64, 0x4c, 0x6f, 0x77, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x64, - 0x5f, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x06, 0x69, 0x64, 0x48, - 0x69, 0x67, 0x68, 0x22, 0xd5, 0x07, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x51, 0x0a, 0x10, - 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e, 0x73, - 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0f, - 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x42, 0x0a, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, - 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, - 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x39, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x54, - 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, - 0x0a, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, - 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, - 0x70, 0x65, 0x48, 0x00, 0x52, 0x09, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x45, 0x0a, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, - 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x31, - 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, - 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, + 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x12, 0x0a, 0x04, + 0x61, 0x73, 0x6f, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x61, 0x73, 0x6f, 0x66, + 0x12, 0x47, 0x0a, 0x09, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x48, 0x00, 0x52, 0x09, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x88, 0x01, 0x01, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x43, 0x0a, 0x0a, 0x43, 0x53, 0x56, 0x4c, 0x6f, + 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x69, + 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x0a, 0x69, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x44, 0x61, 0x74, 0x61, 0x22, 0x86, 0x04, 0x0a, + 0x09, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x68, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x6b, 0x69, + 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x12, 0x19, 0x0a, + 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x6c, 0x69, + 0x6d, 0x69, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x6c, + 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, + 0x68, 0x61, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x71, 0x75, 0x6f, 0x74, 0x65, + 0x63, 0x68, 0x61, 0x72, 0x12, 0x1e, 0x0a, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, + 0x61, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, + 0x63, 0x68, 0x61, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x27, + 0x0a, 0x0f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x65, 0x63, 0x69, 0x6d, + 0x61, 0x6c, 0x5f, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x10, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x53, 0x65, 0x70, 0x61, 0x72, + 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, + 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, + 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x11, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x6d, 0x62, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x70, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x4d, 0x62, 0x12, 0x5d, + 0x0a, 0x13, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, - 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, - 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3c, 0x0a, 0x09, 0x64, 0x61, - 0x74, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, - 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x08, - 0x64, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x61, 0x74, 0x65, - 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, - 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x79, - 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4d, - 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x69, - 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x64, 0x65, 0x63, - 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, - 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, - 0x65, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x45, 0x0a, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x6f, - 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x6f, 0x6f, 0x6c, - 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x69, 0x6e, 0x74, 0x33, 0x32, - 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, - 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, - 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x09, 0x69, - 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x66, 0x6c, 0x6f, 0x61, - 0x74, 0x33, 0x32, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x12, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x49, + 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x42, 0x16, 0x0a, + 0x14, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xe0, 0x02, 0x0a, 0x0b, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, + 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x3d, 0x0a, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x63, 0x65, + 0x62, 0x65, 0x72, 0x67, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x6c, 0x6f, 0x63, + 0x61, 0x74, 0x6f, 0x72, 0x12, 0x41, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x63, 0x65, 0x62, 0x65, + 0x72, 0x67, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, + 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x38, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, + 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x4e, 0x46, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, + 0x73, 0x12, 0x28, 0x0a, 0x0d, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, + 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x6d, + 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x88, 0x01, 0x01, 0x12, 0x24, 0x0a, 0x0b, 0x74, + 0x6f, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x48, 0x01, 0x52, 0x0a, 0x74, 0x6f, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x88, 0x01, + 0x01, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x5f, 0x64, 0x65, 0x6c, + 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, + 0x73, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x42, 0x10, 0x0a, 0x0e, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, + 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x74, 0x6f, 0x5f, + 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x22, 0x6b, 0x0a, 0x0e, 0x49, 0x63, 0x65, 0x62, + 0x65, 0x72, 0x67, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, + 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, + 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x77, 0x61, 0x72, 0x65, 0x68, + 0x6f, 0x75, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x77, 0x61, 0x72, 0x65, + 0x68, 0x6f, 0x75, 0x73, 0x65, 0x22, 0xa1, 0x03, 0x0a, 0x14, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, + 0x67, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1f, + 0x0a, 0x0b, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x55, 0x72, 0x69, 0x12, + 0x19, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, + 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x88, 0x01, 0x01, 0x12, 0x59, 0x0a, 0x0a, 0x70, 0x72, + 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, + 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, + 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, + 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, + 0x72, 0x74, 0x69, 0x65, 0x73, 0x12, 0x66, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x70, 0x72, + 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, - 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, - 0x48, 0x00, 0x52, 0x0b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x42, 0x0a, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0e, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, - 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33, - 0x32, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x54, - 0x79, 0x70, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x11, 0x0a, 0x0f, 0x55, - 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0c, - 0x0a, 0x0a, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x22, 0x09, 0x0a, 0x07, - 0x49, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0b, 0x0a, 0x09, 0x46, 0x6c, 0x6f, 0x61, 0x74, - 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, - 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, - 0x65, 0x22, 0x0a, 0x0a, 0x08, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0e, 0x0a, - 0x0c, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, - 0x0b, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x22, 0x41, 0x0a, 0x0b, - 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, - 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, - 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, - 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x22, - 0x0d, 0x0a, 0x0b, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0b, - 0x0a, 0x09, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x46, - 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x55, 0x49, - 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, 0xc0, 0x05, 0x0a, 0x05, 0x56, 0x61, 0x6c, - 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, - 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x74, 0x5f, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x08, 0x69, 0x6e, - 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0a, 0x66, - 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x75, 0x69, 0x6e, - 0x74, 0x31, 0x32, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, - 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, + 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x41, 0x75, 0x74, 0x68, 0x50, 0x72, + 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x61, + 0x75, 0x74, 0x68, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x1a, 0x3d, 0x0a, + 0x0f, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, + 0x41, 0x75, 0x74, 0x68, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, + 0x08, 0x0a, 0x06, 0x5f, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x22, 0xae, 0x01, 0x0a, 0x09, 0x47, 0x4e, + 0x46, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, + 0x6e, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x50, 0x61, 0x74, 0x68, 0x12, 0x41, 0x0a, 0x09, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, + 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x48, 0x00, 0x52, 0x08, + 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x49, 0x64, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x05, 0x74, + 0x79, 0x70, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x42, 0x0c, 0x0a, 0x0a, + 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x22, 0x3c, 0x0a, 0x0a, 0x52, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x15, 0x0a, 0x06, 0x69, 0x64, 0x5f, 0x6c, + 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x69, 0x64, 0x4c, 0x6f, 0x77, 0x12, + 0x17, 0x0a, 0x07, 0x69, 0x64, 0x5f, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, + 0x52, 0x06, 0x69, 0x64, 0x48, 0x69, 0x67, 0x68, 0x22, 0xd5, 0x07, 0x0a, 0x04, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x51, 0x0a, 0x10, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, + 0x31, 0x2e, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, 0x79, 0x70, + 0x65, 0x48, 0x00, 0x52, 0x0f, 0x75, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x69, - 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x6d, 0x69, - 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, - 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, - 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x09, 0x64, 0x61, 0x74, 0x65, - 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x4b, 0x0a, 0x0e, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, - 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x12, 0x39, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x49, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x07, 0x69, 0x6e, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6c, + 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x09, 0x66, 0x6c, 0x6f, 0x61, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, + 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, + 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x69, + 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, + 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, + 0x65, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x3c, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, + 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x48, 0x00, 0x52, 0x08, 0x64, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x48, 0x0a, + 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, + 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x64, 0x61, 0x74, 0x65, 0x74, + 0x69, 0x6d, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x6d, 0x69, 0x73, 0x73, 0x69, + 0x6e, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, - 0x65, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, - 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, + 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x48, + 0x00, 0x52, 0x0b, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, + 0x0a, 0x0c, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, + 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, + 0x6c, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, + 0x31, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, + 0x0b, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, 0x0a, 0x0a, + 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, + 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, + 0x48, 0x00, 0x52, 0x09, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, + 0x0c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0d, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, + 0x32, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x42, 0x0a, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, - 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, - 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, - 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0a, 0x20, - 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x33, - 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, - 0x32, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x02, 0x48, 0x00, 0x52, - 0x0c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, - 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0d, 0x20, - 0x01, 0x28, 0x0d, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, - 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x34, 0x0a, 0x0c, 0x55, - 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6c, - 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a, - 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x04, 0x68, 0x69, 0x67, - 0x68, 0x22, 0x33, 0x0a, 0x0b, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x75, 0x69, + 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x22, 0x11, 0x0a, 0x0f, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x54, + 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, + 0x65, 0x22, 0x09, 0x0a, 0x07, 0x49, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0b, 0x0a, 0x09, + 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x55, 0x49, 0x6e, + 0x74, 0x31, 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0c, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x31, + 0x32, 0x38, 0x54, 0x79, 0x70, 0x65, 0x22, 0x0a, 0x0a, 0x08, 0x44, 0x61, 0x74, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x22, 0x0e, 0x0a, 0x0c, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x79, 0x70, + 0x65, 0x22, 0x41, 0x0a, 0x0b, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, + 0x0a, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, + 0x63, 0x61, 0x6c, 0x65, 0x22, 0x0d, 0x0a, 0x0b, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x54, + 0x79, 0x70, 0x65, 0x22, 0x0b, 0x0a, 0x09, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, + 0x22, 0x0d, 0x0a, 0x0b, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, + 0x0c, 0x0a, 0x0a, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x79, 0x70, 0x65, 0x22, 0xc0, 0x05, + 0x0a, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, + 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09, + 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48, + 0x00, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x66, + 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, + 0x48, 0x00, 0x52, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, + 0x0a, 0x0d, 0x75, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x49, 0x6e, 0x74, + 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x75, 0x69, 0x6e, 0x74, + 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x31, + 0x32, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, + 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x48, 0x00, 0x52, 0x0b, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x48, 0x0a, 0x0d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x73, + 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x6d, 0x69, 0x73, + 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3f, 0x0a, 0x0a, 0x64, 0x61, 0x74, + 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, + 0x09, 0x64, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x4b, 0x0a, 0x0e, 0x64, 0x61, + 0x74, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, + 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, + 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x61, 0x74, 0x65, 0x74, 0x69, + 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x69, 0x6d, + 0x61, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, + 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, + 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x48, 0x00, 0x52, 0x0c, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x12, 0x25, 0x0a, 0x0d, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x5f, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0c, 0x62, 0x6f, 0x6f, 0x6c, + 0x65, 0x61, 0x6e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x33, + 0x32, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, + 0x0a, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0d, 0x66, + 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0c, 0x20, 0x01, + 0x28, 0x02, 0x48, 0x00, 0x52, 0x0c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x00, 0x52, 0x0b, 0x75, 0x69, 0x6e, 0x74, + 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x22, 0x34, 0x0a, 0x0c, 0x55, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, - 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, - 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x47, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x65, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, 0x10, 0x0a, - 0x03, 0x64, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64, 0x61, 0x79, 0x22, - 0xb1, 0x01, 0x0a, 0x0d, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, - 0x65, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x64, - 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64, 0x61, 0x79, 0x12, 0x12, 0x0a, - 0x04, 0x68, 0x6f, 0x75, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x68, 0x6f, 0x75, - 0x72, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x63, - 0x6f, 0x6e, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x65, 0x63, 0x6f, 0x6e, - 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, 0x63, - 0x6f, 0x6e, 0x64, 0x22, 0x7a, 0x0a, 0x0c, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, - 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, - 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, - 0x43, 0x5a, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x52, 0x65, - 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, 0x6c, 0x6f, 0x67, 0x69, 0x63, - 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, - 0x6c, 0x2f, 0x73, 0x64, 0x6b, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x6c, 0x71, - 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x22, 0x33, 0x0a, 0x0b, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x06, 0x52, 0x03, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x69, 0x67, 0x68, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, 0x04, 0x68, 0x69, 0x67, 0x68, 0x22, 0x0e, 0x0a, 0x0c, 0x4d, + 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x47, 0x0a, 0x09, 0x44, + 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, + 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e, + 0x74, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x64, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x03, 0x64, 0x61, 0x79, 0x22, 0xb1, 0x01, 0x0a, 0x0d, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, + 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x79, 0x65, 0x61, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x79, 0x65, 0x61, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x6f, + 0x6e, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x6f, 0x6e, 0x74, 0x68, + 0x12, 0x10, 0x0a, 0x03, 0x64, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x64, + 0x61, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x75, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x04, 0x68, 0x6f, 0x75, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x12, 0x16, + 0x0a, 0x06, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, + 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, + 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x6d, 0x69, 0x63, + 0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x22, 0x7a, 0x0a, 0x0c, 0x44, 0x65, 0x63, 0x69, + 0x6d, 0x61, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x63, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x65, + 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x12, 0x36, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, + 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x31, 0x32, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x42, 0x43, 0x5a, 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x49, 0x2f, + 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2d, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x73, 0x64, 0x6b, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x73, + 0x72, 0x63, 0x2f, 0x6c, 0x71, 0x70, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, }) var ( diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index eadde440..8fa8f399 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -655,211 +655,220 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t2212 interface{} + var _t2224 interface{} if value == nil { return int32(default_) } - _ = _t2212 - var _t2213 interface{} + _ = _t2224 + var _t2225 interface{} if hasProtoField(value, "int32_value") { return value.GetInt32Value() } - _ = _t2213 + _ = _t2225 panic(ParseError{msg: "expected an int32 value (e.g. `1i32`) for this config field"}) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t2214 interface{} + var _t2226 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2214 + _ = _t2226 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t2215 interface{} + var _t2227 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2215 + _ = _t2227 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t2216 interface{} + var _t2228 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2216 + _ = _t2228 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t2217 interface{} + var _t2229 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2217 + _ = _t2229 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t2218 interface{} + var _t2230 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2218 + _ = _t2230 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t2219 interface{} + var _t2231 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2219 + _ = _t2231 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t2220 interface{} + var _t2232 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2220 + _ = _t2232 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t2221 interface{} + var _t2233 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2221 + _ = _t2233 return nil } func (p *Parser) construct_non_cdc_relations(targets []*pb.TargetRelation) *pb.TargetRelations { - _t2222 := &pb.PlainTargets{Targets: targets} - _t2223 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2223.Body = &pb.TargetRelations_Plain{Plain: _t2222} - return _t2223 + _t2234 := &pb.PlainTargets{Targets: targets} + _t2235 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2235.Body = &pb.TargetRelations_Plain{Plain: _t2234} + return _t2235 } func (p *Parser) construct_cdc_relations(inserts []*pb.TargetRelation, deletes []*pb.TargetRelation) *pb.TargetRelations { - _t2224 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} - _t2225 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2225.Body = &pb.TargetRelations_Cdc{Cdc: _t2224} - return _t2225 + _t2236 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} + _t2237 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2237.Body = &pb.TargetRelations_Cdc{Cdc: _t2236} + return _t2237 } -func (p *Parser) construct_relations(keys []*pb.NamedColumn, body *pb.TargetRelations) *pb.TargetRelations { - var _t2226 interface{} +func (p *Parser) construct_synthetic_keys(marker string) []interface{} { + var _t2238 interface{} + if marker != "synthetic_key" { + panic(ParseError{msg: "expected the `:synthetic_key` marker in the relation keys clause"}) + } + _ = _t2238 + return []interface{}{[]*pb.NamedColumn{}, true} +} + +func (p *Parser) construct_relations(keys []interface{}, body *pb.TargetRelations) *pb.TargetRelations { + var _t2239 interface{} if hasProtoField(body, "plain") { - _t2227 := &pb.TargetRelations{Keys: keys} - _t2227.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} - return _t2227 + _t2240 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool)} + _t2240.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} + return _t2240 } - _ = _t2226 - _t2228 := &pb.TargetRelations{Keys: keys} - _t2228.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} - return _t2228 + _ = _t2239 + _t2241 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool)} + _t2241.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} + return _t2241 } func (p *Parser) construct_csv_data(locator *pb.CSVLocator, config *pb.CSVConfig, columns_opt []*pb.GNFColumn, relations_opt *pb.TargetRelations, asof string) *pb.CSVData { - _t2229 := columns_opt + _t2242 := columns_opt if columns_opt == nil { - _t2229 = []*pb.GNFColumn{} + _t2242 = []*pb.GNFColumn{} } - _t2230 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2229, Asof: asof, Relations: relations_opt} - return _t2230 + _t2243 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2242, Asof: asof, Relations: relations_opt} + return _t2243 } func (p *Parser) construct_csv_config(config_dict [][]interface{}, storage_integration_opt [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t2231 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2231 - _t2232 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2232 - _t2233 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2233 - _t2234 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2234 - _t2235 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2235 - _t2236 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2236 - _t2237 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2237 - _t2238 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2238 - _t2239 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2239 - _t2240 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2240 - _t2241 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") - compression := _t2241 - _t2242 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2242 - _t2243 := p.construct_csv_storage_integration(storage_integration_opt) - storage_integration := _t2243 - _t2244 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression, PartitionSizeMb: partition_size_mb, StorageIntegration: storage_integration} - return _t2244 + _t2244 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t2244 + _t2245 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t2245 + _t2246 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t2246 + _t2247 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t2247 + _t2248 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t2248 + _t2249 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t2249 + _t2250 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t2250 + _t2251 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t2251 + _t2252 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t2252 + _t2253 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t2253 + _t2254 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") + compression := _t2254 + _t2255 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) + partition_size_mb := _t2255 + _t2256 := p.construct_csv_storage_integration(storage_integration_opt) + storage_integration := _t2256 + _t2257 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression, PartitionSizeMb: partition_size_mb, StorageIntegration: storage_integration} + return _t2257 } func (p *Parser) construct_csv_storage_integration(storage_integration_opt [][]interface{}) *pb.StorageIntegration { - var _t2245 interface{} + var _t2258 interface{} if storage_integration_opt == nil { return nil } - _ = _t2245 + _ = _t2258 config := dictFromList(storage_integration_opt) - _t2246 := p._extract_value_string(dictGetValue(config, "provider"), "") - _t2247 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") - _t2248 := p._extract_value_string(dictGetValue(config, "s3_region"), "") - _t2249 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") - _t2250 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") - _t2251 := &pb.StorageIntegration{Provider: _t2246, AzureSasToken: _t2247, S3Region: _t2248, S3AccessKeyId: _t2249, S3SecretAccessKey: _t2250} - return _t2251 + _t2259 := p._extract_value_string(dictGetValue(config, "provider"), "") + _t2260 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") + _t2261 := p._extract_value_string(dictGetValue(config, "s3_region"), "") + _t2262 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") + _t2263 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") + _t2264 := &pb.StorageIntegration{Provider: _t2259, AzureSasToken: _t2260, S3Region: _t2261, S3AccessKeyId: _t2262, S3SecretAccessKey: _t2263} + return _t2264 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t2252 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2252 - _t2253 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2253 - _t2254 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2254 - _t2255 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2255 - _t2256 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2256 - _t2257 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2257 - _t2258 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2258 - _t2259 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2259 - _t2260 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2260 - _t2261 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t2265 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t2265 + _t2266 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t2266 + _t2267 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t2267 + _t2268 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t2268 + _t2269 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t2269 + _t2270 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t2270 + _t2271 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t2271 + _t2272 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t2272 + _t2273 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t2273 + _t2274 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t2261.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t2274.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t2261.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t2274.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t2261 - _t2262 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2262 + relation_locator := _t2274 + _t2275 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t2275 } func (p *Parser) default_configure() *pb.Configure { - _t2263 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2263 - _t2264 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2264 + _t2276 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t2276 + _t2277 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t2277 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -881,3737 +890,3770 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t2265 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2265 - _t2266 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2266 - _t2267 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t2267 + _t2278 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t2278 + _t2279 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t2279 + _t2280 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t2280 } func (p *Parser) construct_export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t2268 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2268 - _t2269 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2269 - _t2270 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2270 - _t2271 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2271 - _t2272 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2272 - _t2273 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2273 - _t2274 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2274 - _t2275 := &pb.ExportCSVConfig{Path: path, DataColumns: columns, PartitionSize: ptr(partition_size), Compression: ptr(compression), SyntaxHeaderRow: ptr(syntax_header_row), SyntaxMissingString: ptr(syntax_missing_string), SyntaxDelim: ptr(syntax_delim), SyntaxQuotechar: ptr(syntax_quotechar), SyntaxEscapechar: ptr(syntax_escapechar)} - return _t2275 + _t2281 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t2281 + _t2282 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t2282 + _t2283 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t2283 + _t2284 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t2284 + _t2285 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t2285 + _t2286 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t2286 + _t2287 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t2287 + _t2288 := &pb.ExportCSVConfig{Path: path, DataColumns: columns, PartitionSize: ptr(partition_size), Compression: ptr(compression), SyntaxHeaderRow: ptr(syntax_header_row), SyntaxMissingString: ptr(syntax_missing_string), SyntaxDelim: ptr(syntax_delim), SyntaxQuotechar: ptr(syntax_quotechar), SyntaxEscapechar: ptr(syntax_escapechar)} + return _t2288 } func (p *Parser) construct_export_csv_config_with_location(location []interface{}, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2276 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} - return _t2276 + _t2289 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} + return _t2289 } func (p *Parser) construct_iceberg_catalog_config(catalog_uri string, scope_opt *string, property_pairs [][]interface{}, auth_property_pairs [][]interface{}) *pb.IcebergCatalogConfig { props := stringMapFromPairs(property_pairs) auth_props := stringMapFromPairs(auth_property_pairs) - _t2277 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2277 + _t2290 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} + return _t2290 } func (p *Parser) construct_iceberg_data(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, columns []*pb.GNFColumn, from_snapshot_opt *string, to_snapshot_opt *string, returns_delta bool) *pb.IcebergData { - _t2278 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2278 + _t2291 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} + return _t2291 } func (p *Parser) construct_export_iceberg_config_full(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, table_def *pb.RelationId, table_property_pairs [][]interface{}, config_dict [][]interface{}) *pb.ExportIcebergConfig { - _t2279 := config_dict + _t2292 := config_dict if config_dict == nil { - _t2279 = [][]interface{}{} - } - cfg := dictFromList(_t2279) - _t2280 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2280 - _t2281 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2281 - _t2282 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2282 + _t2292 = [][]interface{}{} + } + cfg := dictFromList(_t2292) + _t2293 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") + prefix := _t2293 + _t2294 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) + target_file_size_bytes := _t2294 + _t2295 := p._extract_value_string(dictGetValue(cfg, "compression"), "") + compression := _t2295 table_props := stringMapFromPairs(table_property_pairs) - _t2283 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2283 + _t2296 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} + return _t2296 } // --- Parse functions --- func (p *Parser) parse_transaction() *pb.Transaction { - span_start713 := int64(p.spanStart()) + span_start715 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t1414 *pb.Configure + var _t1418 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t1415 := p.parse_configure() - _t1414 = _t1415 + _t1419 := p.parse_configure() + _t1418 = _t1419 } - configure707 := _t1414 - var _t1416 *pb.Sync + configure709 := _t1418 + var _t1420 *pb.Sync if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t1417 := p.parse_sync() - _t1416 = _t1417 - } - sync708 := _t1416 - xs709 := []*pb.Epoch{} - cond710 := p.matchLookaheadLiteral("(", 0) - for cond710 { - _t1418 := p.parse_epoch() - item711 := _t1418 - xs709 = append(xs709, item711) - cond710 = p.matchLookaheadLiteral("(", 0) - } - epochs712 := xs709 + _t1421 := p.parse_sync() + _t1420 = _t1421 + } + sync710 := _t1420 + xs711 := []*pb.Epoch{} + cond712 := p.matchLookaheadLiteral("(", 0) + for cond712 { + _t1422 := p.parse_epoch() + item713 := _t1422 + xs711 = append(xs711, item713) + cond712 = p.matchLookaheadLiteral("(", 0) + } + epochs714 := xs711 p.consumeLiteral(")") - _t1419 := p.default_configure() - _t1420 := configure707 - if configure707 == nil { - _t1420 = _t1419 + _t1423 := p.default_configure() + _t1424 := configure709 + if configure709 == nil { + _t1424 = _t1423 } - _t1421 := &pb.Transaction{Epochs: epochs712, Configure: _t1420, Sync: sync708} - result714 := _t1421 - p.recordSpan(int(span_start713), "Transaction") - return result714 + _t1425 := &pb.Transaction{Epochs: epochs714, Configure: _t1424, Sync: sync710} + result716 := _t1425 + p.recordSpan(int(span_start715), "Transaction") + return result716 } func (p *Parser) parse_configure() *pb.Configure { - span_start716 := int64(p.spanStart()) + span_start718 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("configure") - _t1422 := p.parse_config_dict() - config_dict715 := _t1422 + _t1426 := p.parse_config_dict() + config_dict717 := _t1426 p.consumeLiteral(")") - _t1423 := p.construct_configure(config_dict715) - result717 := _t1423 - p.recordSpan(int(span_start716), "Configure") - return result717 + _t1427 := p.construct_configure(config_dict717) + result719 := _t1427 + p.recordSpan(int(span_start718), "Configure") + return result719 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs718 := [][]interface{}{} - cond719 := p.matchLookaheadLiteral(":", 0) - for cond719 { - _t1424 := p.parse_config_key_value() - item720 := _t1424 - xs718 = append(xs718, item720) - cond719 = p.matchLookaheadLiteral(":", 0) - } - config_key_values721 := xs718 + xs720 := [][]interface{}{} + cond721 := p.matchLookaheadLiteral(":", 0) + for cond721 { + _t1428 := p.parse_config_key_value() + item722 := _t1428 + xs720 = append(xs720, item722) + cond721 = p.matchLookaheadLiteral(":", 0) + } + config_key_values723 := xs720 p.consumeLiteral("}") - return config_key_values721 + return config_key_values723 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol722 := p.consumeTerminal("SYMBOL").Value.str - _t1425 := p.parse_raw_value() - raw_value723 := _t1425 - return []interface{}{symbol722, raw_value723} + symbol724 := p.consumeTerminal("SYMBOL").Value.str + _t1429 := p.parse_raw_value() + raw_value725 := _t1429 + return []interface{}{symbol724, raw_value725} } func (p *Parser) parse_raw_value() *pb.Value { - span_start737 := int64(p.spanStart()) - var _t1426 int64 + span_start739 := int64(p.spanStart()) + var _t1430 int64 if p.matchLookaheadLiteral("true", 0) { - _t1426 = 12 + _t1430 = 12 } else { - var _t1427 int64 + var _t1431 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1427 = 11 + _t1431 = 11 } else { - var _t1428 int64 + var _t1432 int64 if p.matchLookaheadLiteral("false", 0) { - _t1428 = 12 + _t1432 = 12 } else { - var _t1429 int64 + var _t1433 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1430 int64 + var _t1434 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1430 = 1 + _t1434 = 1 } else { - var _t1431 int64 + var _t1435 int64 if p.matchLookaheadLiteral("date", 1) { - _t1431 = 0 + _t1435 = 0 } else { - _t1431 = -1 + _t1435 = -1 } - _t1430 = _t1431 + _t1434 = _t1435 } - _t1429 = _t1430 + _t1433 = _t1434 } else { - var _t1432 int64 + var _t1436 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1432 = 7 + _t1436 = 7 } else { - var _t1433 int64 + var _t1437 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1433 = 8 + _t1437 = 8 } else { - var _t1434 int64 + var _t1438 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1434 = 2 + _t1438 = 2 } else { - var _t1435 int64 + var _t1439 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1435 = 3 + _t1439 = 3 } else { - var _t1436 int64 + var _t1440 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1436 = 9 + _t1440 = 9 } else { - var _t1437 int64 + var _t1441 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1437 = 4 + _t1441 = 4 } else { - var _t1438 int64 + var _t1442 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1438 = 5 + _t1442 = 5 } else { - var _t1439 int64 + var _t1443 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1439 = 6 + _t1443 = 6 } else { - var _t1440 int64 + var _t1444 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1440 = 10 + _t1444 = 10 } else { - _t1440 = -1 + _t1444 = -1 } - _t1439 = _t1440 + _t1443 = _t1444 } - _t1438 = _t1439 + _t1442 = _t1443 } - _t1437 = _t1438 + _t1441 = _t1442 } - _t1436 = _t1437 + _t1440 = _t1441 } - _t1435 = _t1436 + _t1439 = _t1440 } - _t1434 = _t1435 + _t1438 = _t1439 } - _t1433 = _t1434 + _t1437 = _t1438 } - _t1432 = _t1433 + _t1436 = _t1437 } - _t1429 = _t1432 + _t1433 = _t1436 } - _t1428 = _t1429 + _t1432 = _t1433 } - _t1427 = _t1428 + _t1431 = _t1432 } - _t1426 = _t1427 - } - prediction724 := _t1426 - var _t1441 *pb.Value - if prediction724 == 12 { - _t1442 := p.parse_boolean_value() - boolean_value736 := _t1442 - _t1443 := &pb.Value{} - _t1443.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value736} - _t1441 = _t1443 + _t1430 = _t1431 + } + prediction726 := _t1430 + var _t1445 *pb.Value + if prediction726 == 12 { + _t1446 := p.parse_boolean_value() + boolean_value738 := _t1446 + _t1447 := &pb.Value{} + _t1447.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value738} + _t1445 = _t1447 } else { - var _t1444 *pb.Value - if prediction724 == 11 { + var _t1448 *pb.Value + if prediction726 == 11 { p.consumeLiteral("missing") - _t1445 := &pb.MissingValue{} - _t1446 := &pb.Value{} - _t1446.Value = &pb.Value_MissingValue{MissingValue: _t1445} - _t1444 = _t1446 + _t1449 := &pb.MissingValue{} + _t1450 := &pb.Value{} + _t1450.Value = &pb.Value_MissingValue{MissingValue: _t1449} + _t1448 = _t1450 } else { - var _t1447 *pb.Value - if prediction724 == 10 { - decimal735 := p.consumeTerminal("DECIMAL").Value.decimal - _t1448 := &pb.Value{} - _t1448.Value = &pb.Value_DecimalValue{DecimalValue: decimal735} - _t1447 = _t1448 + var _t1451 *pb.Value + if prediction726 == 10 { + decimal737 := p.consumeTerminal("DECIMAL").Value.decimal + _t1452 := &pb.Value{} + _t1452.Value = &pb.Value_DecimalValue{DecimalValue: decimal737} + _t1451 = _t1452 } else { - var _t1449 *pb.Value - if prediction724 == 9 { - int128734 := p.consumeTerminal("INT128").Value.int128 - _t1450 := &pb.Value{} - _t1450.Value = &pb.Value_Int128Value{Int128Value: int128734} - _t1449 = _t1450 + var _t1453 *pb.Value + if prediction726 == 9 { + int128736 := p.consumeTerminal("INT128").Value.int128 + _t1454 := &pb.Value{} + _t1454.Value = &pb.Value_Int128Value{Int128Value: int128736} + _t1453 = _t1454 } else { - var _t1451 *pb.Value - if prediction724 == 8 { - uint128733 := p.consumeTerminal("UINT128").Value.uint128 - _t1452 := &pb.Value{} - _t1452.Value = &pb.Value_Uint128Value{Uint128Value: uint128733} - _t1451 = _t1452 + var _t1455 *pb.Value + if prediction726 == 8 { + uint128735 := p.consumeTerminal("UINT128").Value.uint128 + _t1456 := &pb.Value{} + _t1456.Value = &pb.Value_Uint128Value{Uint128Value: uint128735} + _t1455 = _t1456 } else { - var _t1453 *pb.Value - if prediction724 == 7 { - uint32732 := p.consumeTerminal("UINT32").Value.u32 - _t1454 := &pb.Value{} - _t1454.Value = &pb.Value_Uint32Value{Uint32Value: uint32732} - _t1453 = _t1454 + var _t1457 *pb.Value + if prediction726 == 7 { + uint32734 := p.consumeTerminal("UINT32").Value.u32 + _t1458 := &pb.Value{} + _t1458.Value = &pb.Value_Uint32Value{Uint32Value: uint32734} + _t1457 = _t1458 } else { - var _t1455 *pb.Value - if prediction724 == 6 { - float731 := p.consumeTerminal("FLOAT").Value.f64 - _t1456 := &pb.Value{} - _t1456.Value = &pb.Value_FloatValue{FloatValue: float731} - _t1455 = _t1456 + var _t1459 *pb.Value + if prediction726 == 6 { + float733 := p.consumeTerminal("FLOAT").Value.f64 + _t1460 := &pb.Value{} + _t1460.Value = &pb.Value_FloatValue{FloatValue: float733} + _t1459 = _t1460 } else { - var _t1457 *pb.Value - if prediction724 == 5 { - float32730 := p.consumeTerminal("FLOAT32").Value.f32 - _t1458 := &pb.Value{} - _t1458.Value = &pb.Value_Float32Value{Float32Value: float32730} - _t1457 = _t1458 + var _t1461 *pb.Value + if prediction726 == 5 { + float32732 := p.consumeTerminal("FLOAT32").Value.f32 + _t1462 := &pb.Value{} + _t1462.Value = &pb.Value_Float32Value{Float32Value: float32732} + _t1461 = _t1462 } else { - var _t1459 *pb.Value - if prediction724 == 4 { - int729 := p.consumeTerminal("INT").Value.i64 - _t1460 := &pb.Value{} - _t1460.Value = &pb.Value_IntValue{IntValue: int729} - _t1459 = _t1460 + var _t1463 *pb.Value + if prediction726 == 4 { + int731 := p.consumeTerminal("INT").Value.i64 + _t1464 := &pb.Value{} + _t1464.Value = &pb.Value_IntValue{IntValue: int731} + _t1463 = _t1464 } else { - var _t1461 *pb.Value - if prediction724 == 3 { - int32728 := p.consumeTerminal("INT32").Value.i32 - _t1462 := &pb.Value{} - _t1462.Value = &pb.Value_Int32Value{Int32Value: int32728} - _t1461 = _t1462 + var _t1465 *pb.Value + if prediction726 == 3 { + int32730 := p.consumeTerminal("INT32").Value.i32 + _t1466 := &pb.Value{} + _t1466.Value = &pb.Value_Int32Value{Int32Value: int32730} + _t1465 = _t1466 } else { - var _t1463 *pb.Value - if prediction724 == 2 { - string727 := p.consumeTerminal("STRING").Value.str - _t1464 := &pb.Value{} - _t1464.Value = &pb.Value_StringValue{StringValue: string727} - _t1463 = _t1464 + var _t1467 *pb.Value + if prediction726 == 2 { + string729 := p.consumeTerminal("STRING").Value.str + _t1468 := &pb.Value{} + _t1468.Value = &pb.Value_StringValue{StringValue: string729} + _t1467 = _t1468 } else { - var _t1465 *pb.Value - if prediction724 == 1 { - _t1466 := p.parse_raw_datetime() - raw_datetime726 := _t1466 - _t1467 := &pb.Value{} - _t1467.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime726} - _t1465 = _t1467 + var _t1469 *pb.Value + if prediction726 == 1 { + _t1470 := p.parse_raw_datetime() + raw_datetime728 := _t1470 + _t1471 := &pb.Value{} + _t1471.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime728} + _t1469 = _t1471 } else { - var _t1468 *pb.Value - if prediction724 == 0 { - _t1469 := p.parse_raw_date() - raw_date725 := _t1469 - _t1470 := &pb.Value{} - _t1470.Value = &pb.Value_DateValue{DateValue: raw_date725} - _t1468 = _t1470 + var _t1472 *pb.Value + if prediction726 == 0 { + _t1473 := p.parse_raw_date() + raw_date727 := _t1473 + _t1474 := &pb.Value{} + _t1474.Value = &pb.Value_DateValue{DateValue: raw_date727} + _t1472 = _t1474 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in raw_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1465 = _t1468 + _t1469 = _t1472 } - _t1463 = _t1465 + _t1467 = _t1469 } - _t1461 = _t1463 + _t1465 = _t1467 } - _t1459 = _t1461 + _t1463 = _t1465 } - _t1457 = _t1459 + _t1461 = _t1463 } - _t1455 = _t1457 + _t1459 = _t1461 } - _t1453 = _t1455 + _t1457 = _t1459 } - _t1451 = _t1453 + _t1455 = _t1457 } - _t1449 = _t1451 + _t1453 = _t1455 } - _t1447 = _t1449 + _t1451 = _t1453 } - _t1444 = _t1447 + _t1448 = _t1451 } - _t1441 = _t1444 + _t1445 = _t1448 } - result738 := _t1441 - p.recordSpan(int(span_start737), "Value") - return result738 + result740 := _t1445 + p.recordSpan(int(span_start739), "Value") + return result740 } func (p *Parser) parse_raw_date() *pb.DateValue { - span_start742 := int64(p.spanStart()) + span_start744 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - int739 := p.consumeTerminal("INT").Value.i64 - int_3740 := p.consumeTerminal("INT").Value.i64 - int_4741 := p.consumeTerminal("INT").Value.i64 + int741 := p.consumeTerminal("INT").Value.i64 + int_3742 := p.consumeTerminal("INT").Value.i64 + int_4743 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1471 := &pb.DateValue{Year: int32(int739), Month: int32(int_3740), Day: int32(int_4741)} - result743 := _t1471 - p.recordSpan(int(span_start742), "DateValue") - return result743 + _t1475 := &pb.DateValue{Year: int32(int741), Month: int32(int_3742), Day: int32(int_4743)} + result745 := _t1475 + p.recordSpan(int(span_start744), "DateValue") + return result745 } func (p *Parser) parse_raw_datetime() *pb.DateTimeValue { - span_start751 := int64(p.spanStart()) + span_start753 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - int744 := p.consumeTerminal("INT").Value.i64 - int_3745 := p.consumeTerminal("INT").Value.i64 - int_4746 := p.consumeTerminal("INT").Value.i64 - int_5747 := p.consumeTerminal("INT").Value.i64 - int_6748 := p.consumeTerminal("INT").Value.i64 - int_7749 := p.consumeTerminal("INT").Value.i64 - var _t1472 *int64 + int746 := p.consumeTerminal("INT").Value.i64 + int_3747 := p.consumeTerminal("INT").Value.i64 + int_4748 := p.consumeTerminal("INT").Value.i64 + int_5749 := p.consumeTerminal("INT").Value.i64 + int_6750 := p.consumeTerminal("INT").Value.i64 + int_7751 := p.consumeTerminal("INT").Value.i64 + var _t1476 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1472 = ptr(p.consumeTerminal("INT").Value.i64) + _t1476 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8750 := _t1472 + int_8752 := _t1476 p.consumeLiteral(")") - _t1473 := &pb.DateTimeValue{Year: int32(int744), Month: int32(int_3745), Day: int32(int_4746), Hour: int32(int_5747), Minute: int32(int_6748), Second: int32(int_7749), Microsecond: int32(deref(int_8750, 0))} - result752 := _t1473 - p.recordSpan(int(span_start751), "DateTimeValue") - return result752 + _t1477 := &pb.DateTimeValue{Year: int32(int746), Month: int32(int_3747), Day: int32(int_4748), Hour: int32(int_5749), Minute: int32(int_6750), Second: int32(int_7751), Microsecond: int32(deref(int_8752, 0))} + result754 := _t1477 + p.recordSpan(int(span_start753), "DateTimeValue") + return result754 } func (p *Parser) parse_boolean_value() bool { - var _t1474 int64 + var _t1478 int64 if p.matchLookaheadLiteral("true", 0) { - _t1474 = 0 + _t1478 = 0 } else { - var _t1475 int64 + var _t1479 int64 if p.matchLookaheadLiteral("false", 0) { - _t1475 = 1 + _t1479 = 1 } else { - _t1475 = -1 + _t1479 = -1 } - _t1474 = _t1475 + _t1478 = _t1479 } - prediction753 := _t1474 - var _t1476 bool - if prediction753 == 1 { + prediction755 := _t1478 + var _t1480 bool + if prediction755 == 1 { p.consumeLiteral("false") - _t1476 = false + _t1480 = false } else { - var _t1477 bool - if prediction753 == 0 { + var _t1481 bool + if prediction755 == 0 { p.consumeLiteral("true") - _t1477 = true + _t1481 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1476 = _t1477 + _t1480 = _t1481 } - return _t1476 + return _t1480 } func (p *Parser) parse_sync() *pb.Sync { - span_start758 := int64(p.spanStart()) + span_start760 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sync") - xs754 := []*pb.FragmentId{} - cond755 := p.matchLookaheadLiteral(":", 0) - for cond755 { - _t1478 := p.parse_fragment_id() - item756 := _t1478 - xs754 = append(xs754, item756) - cond755 = p.matchLookaheadLiteral(":", 0) - } - fragment_ids757 := xs754 + xs756 := []*pb.FragmentId{} + cond757 := p.matchLookaheadLiteral(":", 0) + for cond757 { + _t1482 := p.parse_fragment_id() + item758 := _t1482 + xs756 = append(xs756, item758) + cond757 = p.matchLookaheadLiteral(":", 0) + } + fragment_ids759 := xs756 p.consumeLiteral(")") - _t1479 := &pb.Sync{Fragments: fragment_ids757} - result759 := _t1479 - p.recordSpan(int(span_start758), "Sync") - return result759 + _t1483 := &pb.Sync{Fragments: fragment_ids759} + result761 := _t1483 + p.recordSpan(int(span_start760), "Sync") + return result761 } func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start761 := int64(p.spanStart()) + span_start763 := int64(p.spanStart()) p.consumeLiteral(":") - symbol760 := p.consumeTerminal("SYMBOL").Value.str - result762 := &pb.FragmentId{Id: []byte(symbol760)} - p.recordSpan(int(span_start761), "FragmentId") - return result762 + symbol762 := p.consumeTerminal("SYMBOL").Value.str + result764 := &pb.FragmentId{Id: []byte(symbol762)} + p.recordSpan(int(span_start763), "FragmentId") + return result764 } func (p *Parser) parse_epoch() *pb.Epoch { - span_start765 := int64(p.spanStart()) + span_start767 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t1480 []*pb.Write + var _t1484 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t1481 := p.parse_epoch_writes() - _t1480 = _t1481 + _t1485 := p.parse_epoch_writes() + _t1484 = _t1485 } - epoch_writes763 := _t1480 - var _t1482 []*pb.Read + epoch_writes765 := _t1484 + var _t1486 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t1483 := p.parse_epoch_reads() - _t1482 = _t1483 + _t1487 := p.parse_epoch_reads() + _t1486 = _t1487 } - epoch_reads764 := _t1482 + epoch_reads766 := _t1486 p.consumeLiteral(")") - _t1484 := epoch_writes763 - if epoch_writes763 == nil { - _t1484 = []*pb.Write{} + _t1488 := epoch_writes765 + if epoch_writes765 == nil { + _t1488 = []*pb.Write{} } - _t1485 := epoch_reads764 - if epoch_reads764 == nil { - _t1485 = []*pb.Read{} + _t1489 := epoch_reads766 + if epoch_reads766 == nil { + _t1489 = []*pb.Read{} } - _t1486 := &pb.Epoch{Writes: _t1484, Reads: _t1485} - result766 := _t1486 - p.recordSpan(int(span_start765), "Epoch") - return result766 + _t1490 := &pb.Epoch{Writes: _t1488, Reads: _t1489} + result768 := _t1490 + p.recordSpan(int(span_start767), "Epoch") + return result768 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs767 := []*pb.Write{} - cond768 := p.matchLookaheadLiteral("(", 0) - for cond768 { - _t1487 := p.parse_write() - item769 := _t1487 - xs767 = append(xs767, item769) - cond768 = p.matchLookaheadLiteral("(", 0) - } - writes770 := xs767 + xs769 := []*pb.Write{} + cond770 := p.matchLookaheadLiteral("(", 0) + for cond770 { + _t1491 := p.parse_write() + item771 := _t1491 + xs769 = append(xs769, item771) + cond770 = p.matchLookaheadLiteral("(", 0) + } + writes772 := xs769 p.consumeLiteral(")") - return writes770 + return writes772 } func (p *Parser) parse_write() *pb.Write { - span_start776 := int64(p.spanStart()) - var _t1488 int64 + span_start778 := int64(p.spanStart()) + var _t1492 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1489 int64 + var _t1493 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t1489 = 1 + _t1493 = 1 } else { - var _t1490 int64 + var _t1494 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t1490 = 3 + _t1494 = 3 } else { - var _t1491 int64 + var _t1495 int64 if p.matchLookaheadLiteral("define", 1) { - _t1491 = 0 + _t1495 = 0 } else { - var _t1492 int64 + var _t1496 int64 if p.matchLookaheadLiteral("context", 1) { - _t1492 = 2 + _t1496 = 2 } else { - _t1492 = -1 + _t1496 = -1 } - _t1491 = _t1492 + _t1495 = _t1496 } - _t1490 = _t1491 + _t1494 = _t1495 } - _t1489 = _t1490 + _t1493 = _t1494 } - _t1488 = _t1489 + _t1492 = _t1493 } else { - _t1488 = -1 - } - prediction771 := _t1488 - var _t1493 *pb.Write - if prediction771 == 3 { - _t1494 := p.parse_snapshot() - snapshot775 := _t1494 - _t1495 := &pb.Write{} - _t1495.WriteType = &pb.Write_Snapshot{Snapshot: snapshot775} - _t1493 = _t1495 + _t1492 = -1 + } + prediction773 := _t1492 + var _t1497 *pb.Write + if prediction773 == 3 { + _t1498 := p.parse_snapshot() + snapshot777 := _t1498 + _t1499 := &pb.Write{} + _t1499.WriteType = &pb.Write_Snapshot{Snapshot: snapshot777} + _t1497 = _t1499 } else { - var _t1496 *pb.Write - if prediction771 == 2 { - _t1497 := p.parse_context() - context774 := _t1497 - _t1498 := &pb.Write{} - _t1498.WriteType = &pb.Write_Context{Context: context774} - _t1496 = _t1498 + var _t1500 *pb.Write + if prediction773 == 2 { + _t1501 := p.parse_context() + context776 := _t1501 + _t1502 := &pb.Write{} + _t1502.WriteType = &pb.Write_Context{Context: context776} + _t1500 = _t1502 } else { - var _t1499 *pb.Write - if prediction771 == 1 { - _t1500 := p.parse_undefine() - undefine773 := _t1500 - _t1501 := &pb.Write{} - _t1501.WriteType = &pb.Write_Undefine{Undefine: undefine773} - _t1499 = _t1501 + var _t1503 *pb.Write + if prediction773 == 1 { + _t1504 := p.parse_undefine() + undefine775 := _t1504 + _t1505 := &pb.Write{} + _t1505.WriteType = &pb.Write_Undefine{Undefine: undefine775} + _t1503 = _t1505 } else { - var _t1502 *pb.Write - if prediction771 == 0 { - _t1503 := p.parse_define() - define772 := _t1503 - _t1504 := &pb.Write{} - _t1504.WriteType = &pb.Write_Define{Define: define772} - _t1502 = _t1504 + var _t1506 *pb.Write + if prediction773 == 0 { + _t1507 := p.parse_define() + define774 := _t1507 + _t1508 := &pb.Write{} + _t1508.WriteType = &pb.Write_Define{Define: define774} + _t1506 = _t1508 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1499 = _t1502 + _t1503 = _t1506 } - _t1496 = _t1499 + _t1500 = _t1503 } - _t1493 = _t1496 + _t1497 = _t1500 } - result777 := _t1493 - p.recordSpan(int(span_start776), "Write") - return result777 + result779 := _t1497 + p.recordSpan(int(span_start778), "Write") + return result779 } func (p *Parser) parse_define() *pb.Define { - span_start779 := int64(p.spanStart()) + span_start781 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("define") - _t1505 := p.parse_fragment() - fragment778 := _t1505 + _t1509 := p.parse_fragment() + fragment780 := _t1509 p.consumeLiteral(")") - _t1506 := &pb.Define{Fragment: fragment778} - result780 := _t1506 - p.recordSpan(int(span_start779), "Define") - return result780 + _t1510 := &pb.Define{Fragment: fragment780} + result782 := _t1510 + p.recordSpan(int(span_start781), "Define") + return result782 } func (p *Parser) parse_fragment() *pb.Fragment { - span_start786 := int64(p.spanStart()) + span_start788 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("fragment") - _t1507 := p.parse_new_fragment_id() - new_fragment_id781 := _t1507 - xs782 := []*pb.Declaration{} - cond783 := p.matchLookaheadLiteral("(", 0) - for cond783 { - _t1508 := p.parse_declaration() - item784 := _t1508 - xs782 = append(xs782, item784) - cond783 = p.matchLookaheadLiteral("(", 0) - } - declarations785 := xs782 + _t1511 := p.parse_new_fragment_id() + new_fragment_id783 := _t1511 + xs784 := []*pb.Declaration{} + cond785 := p.matchLookaheadLiteral("(", 0) + for cond785 { + _t1512 := p.parse_declaration() + item786 := _t1512 + xs784 = append(xs784, item786) + cond785 = p.matchLookaheadLiteral("(", 0) + } + declarations787 := xs784 p.consumeLiteral(")") - result787 := p.constructFragment(new_fragment_id781, declarations785) - p.recordSpan(int(span_start786), "Fragment") - return result787 + result789 := p.constructFragment(new_fragment_id783, declarations787) + p.recordSpan(int(span_start788), "Fragment") + return result789 } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - span_start789 := int64(p.spanStart()) - _t1509 := p.parse_fragment_id() - fragment_id788 := _t1509 - p.startFragment(fragment_id788) - result790 := fragment_id788 - p.recordSpan(int(span_start789), "FragmentId") - return result790 + span_start791 := int64(p.spanStart()) + _t1513 := p.parse_fragment_id() + fragment_id790 := _t1513 + p.startFragment(fragment_id790) + result792 := fragment_id790 + p.recordSpan(int(span_start791), "FragmentId") + return result792 } func (p *Parser) parse_declaration() *pb.Declaration { - span_start796 := int64(p.spanStart()) - var _t1510 int64 + span_start798 := int64(p.spanStart()) + var _t1514 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1511 int64 + var _t1515 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1511 = 3 + _t1515 = 3 } else { - var _t1512 int64 + var _t1516 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1512 = 2 + _t1516 = 2 } else { - var _t1513 int64 + var _t1517 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1513 = 3 + _t1517 = 3 } else { - var _t1514 int64 + var _t1518 int64 if p.matchLookaheadLiteral("def", 1) { - _t1514 = 0 + _t1518 = 0 } else { - var _t1515 int64 + var _t1519 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1515 = 3 + _t1519 = 3 } else { - var _t1516 int64 + var _t1520 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1516 = 3 + _t1520 = 3 } else { - var _t1517 int64 + var _t1521 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t1517 = 1 + _t1521 = 1 } else { - _t1517 = -1 + _t1521 = -1 } - _t1516 = _t1517 + _t1520 = _t1521 } - _t1515 = _t1516 + _t1519 = _t1520 } - _t1514 = _t1515 + _t1518 = _t1519 } - _t1513 = _t1514 + _t1517 = _t1518 } - _t1512 = _t1513 + _t1516 = _t1517 } - _t1511 = _t1512 + _t1515 = _t1516 } - _t1510 = _t1511 + _t1514 = _t1515 } else { - _t1510 = -1 - } - prediction791 := _t1510 - var _t1518 *pb.Declaration - if prediction791 == 3 { - _t1519 := p.parse_data() - data795 := _t1519 - _t1520 := &pb.Declaration{} - _t1520.DeclarationType = &pb.Declaration_Data{Data: data795} - _t1518 = _t1520 + _t1514 = -1 + } + prediction793 := _t1514 + var _t1522 *pb.Declaration + if prediction793 == 3 { + _t1523 := p.parse_data() + data797 := _t1523 + _t1524 := &pb.Declaration{} + _t1524.DeclarationType = &pb.Declaration_Data{Data: data797} + _t1522 = _t1524 } else { - var _t1521 *pb.Declaration - if prediction791 == 2 { - _t1522 := p.parse_constraint() - constraint794 := _t1522 - _t1523 := &pb.Declaration{} - _t1523.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint794} - _t1521 = _t1523 + var _t1525 *pb.Declaration + if prediction793 == 2 { + _t1526 := p.parse_constraint() + constraint796 := _t1526 + _t1527 := &pb.Declaration{} + _t1527.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint796} + _t1525 = _t1527 } else { - var _t1524 *pb.Declaration - if prediction791 == 1 { - _t1525 := p.parse_algorithm() - algorithm793 := _t1525 - _t1526 := &pb.Declaration{} - _t1526.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm793} - _t1524 = _t1526 + var _t1528 *pb.Declaration + if prediction793 == 1 { + _t1529 := p.parse_algorithm() + algorithm795 := _t1529 + _t1530 := &pb.Declaration{} + _t1530.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm795} + _t1528 = _t1530 } else { - var _t1527 *pb.Declaration - if prediction791 == 0 { - _t1528 := p.parse_def() - def792 := _t1528 - _t1529 := &pb.Declaration{} - _t1529.DeclarationType = &pb.Declaration_Def{Def: def792} - _t1527 = _t1529 + var _t1531 *pb.Declaration + if prediction793 == 0 { + _t1532 := p.parse_def() + def794 := _t1532 + _t1533 := &pb.Declaration{} + _t1533.DeclarationType = &pb.Declaration_Def{Def: def794} + _t1531 = _t1533 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1524 = _t1527 + _t1528 = _t1531 } - _t1521 = _t1524 + _t1525 = _t1528 } - _t1518 = _t1521 + _t1522 = _t1525 } - result797 := _t1518 - p.recordSpan(int(span_start796), "Declaration") - return result797 + result799 := _t1522 + p.recordSpan(int(span_start798), "Declaration") + return result799 } func (p *Parser) parse_def() *pb.Def { - span_start801 := int64(p.spanStart()) + span_start803 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("def") - _t1530 := p.parse_relation_id() - relation_id798 := _t1530 - _t1531 := p.parse_abstraction() - abstraction799 := _t1531 - var _t1532 []*pb.Attribute + _t1534 := p.parse_relation_id() + relation_id800 := _t1534 + _t1535 := p.parse_abstraction() + abstraction801 := _t1535 + var _t1536 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1533 := p.parse_attrs() - _t1532 = _t1533 + _t1537 := p.parse_attrs() + _t1536 = _t1537 } - attrs800 := _t1532 + attrs802 := _t1536 p.consumeLiteral(")") - _t1534 := attrs800 - if attrs800 == nil { - _t1534 = []*pb.Attribute{} + _t1538 := attrs802 + if attrs802 == nil { + _t1538 = []*pb.Attribute{} } - _t1535 := &pb.Def{Name: relation_id798, Body: abstraction799, Attrs: _t1534} - result802 := _t1535 - p.recordSpan(int(span_start801), "Def") - return result802 + _t1539 := &pb.Def{Name: relation_id800, Body: abstraction801, Attrs: _t1538} + result804 := _t1539 + p.recordSpan(int(span_start803), "Def") + return result804 } func (p *Parser) parse_relation_id() *pb.RelationId { - span_start806 := int64(p.spanStart()) - var _t1536 int64 + span_start808 := int64(p.spanStart()) + var _t1540 int64 if p.matchLookaheadLiteral(":", 0) { - _t1536 = 0 + _t1540 = 0 } else { - var _t1537 int64 + var _t1541 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1537 = 1 + _t1541 = 1 } else { - _t1537 = -1 + _t1541 = -1 } - _t1536 = _t1537 - } - prediction803 := _t1536 - var _t1538 *pb.RelationId - if prediction803 == 1 { - uint128805 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128805 - _t1538 = &pb.RelationId{IdLow: uint128805.Low, IdHigh: uint128805.High} + _t1540 = _t1541 + } + prediction805 := _t1540 + var _t1542 *pb.RelationId + if prediction805 == 1 { + uint128807 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128807 + _t1542 = &pb.RelationId{IdLow: uint128807.Low, IdHigh: uint128807.High} } else { - var _t1539 *pb.RelationId - if prediction803 == 0 { + var _t1543 *pb.RelationId + if prediction805 == 0 { p.consumeLiteral(":") - symbol804 := p.consumeTerminal("SYMBOL").Value.str - _t1539 = p.relationIdFromString(symbol804) + symbol806 := p.consumeTerminal("SYMBOL").Value.str + _t1543 = p.relationIdFromString(symbol806) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1538 = _t1539 + _t1542 = _t1543 } - result807 := _t1538 - p.recordSpan(int(span_start806), "RelationId") - return result807 + result809 := _t1542 + p.recordSpan(int(span_start808), "RelationId") + return result809 } func (p *Parser) parse_abstraction() *pb.Abstraction { - span_start810 := int64(p.spanStart()) + span_start812 := int64(p.spanStart()) p.consumeLiteral("(") - _t1540 := p.parse_bindings() - bindings808 := _t1540 - _t1541 := p.parse_formula() - formula809 := _t1541 + _t1544 := p.parse_bindings() + bindings810 := _t1544 + _t1545 := p.parse_formula() + formula811 := _t1545 p.consumeLiteral(")") - _t1542 := &pb.Abstraction{Vars: listConcat(bindings808[0].([]*pb.Binding), bindings808[1].([]*pb.Binding)), Value: formula809} - result811 := _t1542 - p.recordSpan(int(span_start810), "Abstraction") - return result811 + _t1546 := &pb.Abstraction{Vars: listConcat(bindings810[0].([]*pb.Binding), bindings810[1].([]*pb.Binding)), Value: formula811} + result813 := _t1546 + p.recordSpan(int(span_start812), "Abstraction") + return result813 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs812 := []*pb.Binding{} - cond813 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond813 { - _t1543 := p.parse_binding() - item814 := _t1543 - xs812 = append(xs812, item814) - cond813 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings815 := xs812 - var _t1544 []*pb.Binding + xs814 := []*pb.Binding{} + cond815 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond815 { + _t1547 := p.parse_binding() + item816 := _t1547 + xs814 = append(xs814, item816) + cond815 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings817 := xs814 + var _t1548 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t1545 := p.parse_value_bindings() - _t1544 = _t1545 + _t1549 := p.parse_value_bindings() + _t1548 = _t1549 } - value_bindings816 := _t1544 + value_bindings818 := _t1548 p.consumeLiteral("]") - _t1546 := value_bindings816 - if value_bindings816 == nil { - _t1546 = []*pb.Binding{} + _t1550 := value_bindings818 + if value_bindings818 == nil { + _t1550 = []*pb.Binding{} } - return []interface{}{bindings815, _t1546} + return []interface{}{bindings817, _t1550} } func (p *Parser) parse_binding() *pb.Binding { - span_start819 := int64(p.spanStart()) - symbol817 := p.consumeTerminal("SYMBOL").Value.str + span_start821 := int64(p.spanStart()) + symbol819 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t1547 := p.parse_type() - type818 := _t1547 - _t1548 := &pb.Var{Name: symbol817} - _t1549 := &pb.Binding{Var: _t1548, Type: type818} - result820 := _t1549 - p.recordSpan(int(span_start819), "Binding") - return result820 + _t1551 := p.parse_type() + type820 := _t1551 + _t1552 := &pb.Var{Name: symbol819} + _t1553 := &pb.Binding{Var: _t1552, Type: type820} + result822 := _t1553 + p.recordSpan(int(span_start821), "Binding") + return result822 } func (p *Parser) parse_type() *pb.Type { - span_start836 := int64(p.spanStart()) - var _t1550 int64 + span_start838 := int64(p.spanStart()) + var _t1554 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1550 = 0 + _t1554 = 0 } else { - var _t1551 int64 + var _t1555 int64 if p.matchLookaheadLiteral("UINT32", 0) { - _t1551 = 13 + _t1555 = 13 } else { - var _t1552 int64 + var _t1556 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t1552 = 4 + _t1556 = 4 } else { - var _t1553 int64 + var _t1557 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t1553 = 1 + _t1557 = 1 } else { - var _t1554 int64 + var _t1558 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t1554 = 8 + _t1558 = 8 } else { - var _t1555 int64 + var _t1559 int64 if p.matchLookaheadLiteral("INT32", 0) { - _t1555 = 11 + _t1559 = 11 } else { - var _t1556 int64 + var _t1560 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t1556 = 5 + _t1560 = 5 } else { - var _t1557 int64 + var _t1561 int64 if p.matchLookaheadLiteral("INT", 0) { - _t1557 = 2 + _t1561 = 2 } else { - var _t1558 int64 + var _t1562 int64 if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1558 = 12 + _t1562 = 12 } else { - var _t1559 int64 + var _t1563 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t1559 = 3 + _t1563 = 3 } else { - var _t1560 int64 + var _t1564 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t1560 = 7 + _t1564 = 7 } else { - var _t1561 int64 + var _t1565 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t1561 = 6 + _t1565 = 6 } else { - var _t1562 int64 + var _t1566 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1562 = 10 + _t1566 = 10 } else { - var _t1563 int64 + var _t1567 int64 if p.matchLookaheadLiteral("(", 0) { - _t1563 = 9 + _t1567 = 9 } else { - _t1563 = -1 + _t1567 = -1 } - _t1562 = _t1563 + _t1566 = _t1567 } - _t1561 = _t1562 + _t1565 = _t1566 } - _t1560 = _t1561 + _t1564 = _t1565 } - _t1559 = _t1560 + _t1563 = _t1564 } - _t1558 = _t1559 + _t1562 = _t1563 } - _t1557 = _t1558 + _t1561 = _t1562 } - _t1556 = _t1557 + _t1560 = _t1561 } - _t1555 = _t1556 + _t1559 = _t1560 } - _t1554 = _t1555 + _t1558 = _t1559 } - _t1553 = _t1554 + _t1557 = _t1558 } - _t1552 = _t1553 + _t1556 = _t1557 } - _t1551 = _t1552 + _t1555 = _t1556 } - _t1550 = _t1551 - } - prediction821 := _t1550 - var _t1564 *pb.Type - if prediction821 == 13 { - _t1565 := p.parse_uint32_type() - uint32_type835 := _t1565 - _t1566 := &pb.Type{} - _t1566.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type835} - _t1564 = _t1566 + _t1554 = _t1555 + } + prediction823 := _t1554 + var _t1568 *pb.Type + if prediction823 == 13 { + _t1569 := p.parse_uint32_type() + uint32_type837 := _t1569 + _t1570 := &pb.Type{} + _t1570.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type837} + _t1568 = _t1570 } else { - var _t1567 *pb.Type - if prediction821 == 12 { - _t1568 := p.parse_float32_type() - float32_type834 := _t1568 - _t1569 := &pb.Type{} - _t1569.Type = &pb.Type_Float32Type{Float32Type: float32_type834} - _t1567 = _t1569 + var _t1571 *pb.Type + if prediction823 == 12 { + _t1572 := p.parse_float32_type() + float32_type836 := _t1572 + _t1573 := &pb.Type{} + _t1573.Type = &pb.Type_Float32Type{Float32Type: float32_type836} + _t1571 = _t1573 } else { - var _t1570 *pb.Type - if prediction821 == 11 { - _t1571 := p.parse_int32_type() - int32_type833 := _t1571 - _t1572 := &pb.Type{} - _t1572.Type = &pb.Type_Int32Type{Int32Type: int32_type833} - _t1570 = _t1572 + var _t1574 *pb.Type + if prediction823 == 11 { + _t1575 := p.parse_int32_type() + int32_type835 := _t1575 + _t1576 := &pb.Type{} + _t1576.Type = &pb.Type_Int32Type{Int32Type: int32_type835} + _t1574 = _t1576 } else { - var _t1573 *pb.Type - if prediction821 == 10 { - _t1574 := p.parse_boolean_type() - boolean_type832 := _t1574 - _t1575 := &pb.Type{} - _t1575.Type = &pb.Type_BooleanType{BooleanType: boolean_type832} - _t1573 = _t1575 + var _t1577 *pb.Type + if prediction823 == 10 { + _t1578 := p.parse_boolean_type() + boolean_type834 := _t1578 + _t1579 := &pb.Type{} + _t1579.Type = &pb.Type_BooleanType{BooleanType: boolean_type834} + _t1577 = _t1579 } else { - var _t1576 *pb.Type - if prediction821 == 9 { - _t1577 := p.parse_decimal_type() - decimal_type831 := _t1577 - _t1578 := &pb.Type{} - _t1578.Type = &pb.Type_DecimalType{DecimalType: decimal_type831} - _t1576 = _t1578 + var _t1580 *pb.Type + if prediction823 == 9 { + _t1581 := p.parse_decimal_type() + decimal_type833 := _t1581 + _t1582 := &pb.Type{} + _t1582.Type = &pb.Type_DecimalType{DecimalType: decimal_type833} + _t1580 = _t1582 } else { - var _t1579 *pb.Type - if prediction821 == 8 { - _t1580 := p.parse_missing_type() - missing_type830 := _t1580 - _t1581 := &pb.Type{} - _t1581.Type = &pb.Type_MissingType{MissingType: missing_type830} - _t1579 = _t1581 + var _t1583 *pb.Type + if prediction823 == 8 { + _t1584 := p.parse_missing_type() + missing_type832 := _t1584 + _t1585 := &pb.Type{} + _t1585.Type = &pb.Type_MissingType{MissingType: missing_type832} + _t1583 = _t1585 } else { - var _t1582 *pb.Type - if prediction821 == 7 { - _t1583 := p.parse_datetime_type() - datetime_type829 := _t1583 - _t1584 := &pb.Type{} - _t1584.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type829} - _t1582 = _t1584 + var _t1586 *pb.Type + if prediction823 == 7 { + _t1587 := p.parse_datetime_type() + datetime_type831 := _t1587 + _t1588 := &pb.Type{} + _t1588.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type831} + _t1586 = _t1588 } else { - var _t1585 *pb.Type - if prediction821 == 6 { - _t1586 := p.parse_date_type() - date_type828 := _t1586 - _t1587 := &pb.Type{} - _t1587.Type = &pb.Type_DateType{DateType: date_type828} - _t1585 = _t1587 + var _t1589 *pb.Type + if prediction823 == 6 { + _t1590 := p.parse_date_type() + date_type830 := _t1590 + _t1591 := &pb.Type{} + _t1591.Type = &pb.Type_DateType{DateType: date_type830} + _t1589 = _t1591 } else { - var _t1588 *pb.Type - if prediction821 == 5 { - _t1589 := p.parse_int128_type() - int128_type827 := _t1589 - _t1590 := &pb.Type{} - _t1590.Type = &pb.Type_Int128Type{Int128Type: int128_type827} - _t1588 = _t1590 + var _t1592 *pb.Type + if prediction823 == 5 { + _t1593 := p.parse_int128_type() + int128_type829 := _t1593 + _t1594 := &pb.Type{} + _t1594.Type = &pb.Type_Int128Type{Int128Type: int128_type829} + _t1592 = _t1594 } else { - var _t1591 *pb.Type - if prediction821 == 4 { - _t1592 := p.parse_uint128_type() - uint128_type826 := _t1592 - _t1593 := &pb.Type{} - _t1593.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type826} - _t1591 = _t1593 + var _t1595 *pb.Type + if prediction823 == 4 { + _t1596 := p.parse_uint128_type() + uint128_type828 := _t1596 + _t1597 := &pb.Type{} + _t1597.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type828} + _t1595 = _t1597 } else { - var _t1594 *pb.Type - if prediction821 == 3 { - _t1595 := p.parse_float_type() - float_type825 := _t1595 - _t1596 := &pb.Type{} - _t1596.Type = &pb.Type_FloatType{FloatType: float_type825} - _t1594 = _t1596 + var _t1598 *pb.Type + if prediction823 == 3 { + _t1599 := p.parse_float_type() + float_type827 := _t1599 + _t1600 := &pb.Type{} + _t1600.Type = &pb.Type_FloatType{FloatType: float_type827} + _t1598 = _t1600 } else { - var _t1597 *pb.Type - if prediction821 == 2 { - _t1598 := p.parse_int_type() - int_type824 := _t1598 - _t1599 := &pb.Type{} - _t1599.Type = &pb.Type_IntType{IntType: int_type824} - _t1597 = _t1599 + var _t1601 *pb.Type + if prediction823 == 2 { + _t1602 := p.parse_int_type() + int_type826 := _t1602 + _t1603 := &pb.Type{} + _t1603.Type = &pb.Type_IntType{IntType: int_type826} + _t1601 = _t1603 } else { - var _t1600 *pb.Type - if prediction821 == 1 { - _t1601 := p.parse_string_type() - string_type823 := _t1601 - _t1602 := &pb.Type{} - _t1602.Type = &pb.Type_StringType{StringType: string_type823} - _t1600 = _t1602 + var _t1604 *pb.Type + if prediction823 == 1 { + _t1605 := p.parse_string_type() + string_type825 := _t1605 + _t1606 := &pb.Type{} + _t1606.Type = &pb.Type_StringType{StringType: string_type825} + _t1604 = _t1606 } else { - var _t1603 *pb.Type - if prediction821 == 0 { - _t1604 := p.parse_unspecified_type() - unspecified_type822 := _t1604 - _t1605 := &pb.Type{} - _t1605.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type822} - _t1603 = _t1605 + var _t1607 *pb.Type + if prediction823 == 0 { + _t1608 := p.parse_unspecified_type() + unspecified_type824 := _t1608 + _t1609 := &pb.Type{} + _t1609.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type824} + _t1607 = _t1609 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1600 = _t1603 + _t1604 = _t1607 } - _t1597 = _t1600 + _t1601 = _t1604 } - _t1594 = _t1597 + _t1598 = _t1601 } - _t1591 = _t1594 + _t1595 = _t1598 } - _t1588 = _t1591 + _t1592 = _t1595 } - _t1585 = _t1588 + _t1589 = _t1592 } - _t1582 = _t1585 + _t1586 = _t1589 } - _t1579 = _t1582 + _t1583 = _t1586 } - _t1576 = _t1579 + _t1580 = _t1583 } - _t1573 = _t1576 + _t1577 = _t1580 } - _t1570 = _t1573 + _t1574 = _t1577 } - _t1567 = _t1570 + _t1571 = _t1574 } - _t1564 = _t1567 + _t1568 = _t1571 } - result837 := _t1564 - p.recordSpan(int(span_start836), "Type") - return result837 + result839 := _t1568 + p.recordSpan(int(span_start838), "Type") + return result839 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start838 := int64(p.spanStart()) + span_start840 := int64(p.spanStart()) p.consumeLiteral("UNKNOWN") - _t1606 := &pb.UnspecifiedType{} - result839 := _t1606 - p.recordSpan(int(span_start838), "UnspecifiedType") - return result839 + _t1610 := &pb.UnspecifiedType{} + result841 := _t1610 + p.recordSpan(int(span_start840), "UnspecifiedType") + return result841 } func (p *Parser) parse_string_type() *pb.StringType { - span_start840 := int64(p.spanStart()) + span_start842 := int64(p.spanStart()) p.consumeLiteral("STRING") - _t1607 := &pb.StringType{} - result841 := _t1607 - p.recordSpan(int(span_start840), "StringType") - return result841 + _t1611 := &pb.StringType{} + result843 := _t1611 + p.recordSpan(int(span_start842), "StringType") + return result843 } func (p *Parser) parse_int_type() *pb.IntType { - span_start842 := int64(p.spanStart()) + span_start844 := int64(p.spanStart()) p.consumeLiteral("INT") - _t1608 := &pb.IntType{} - result843 := _t1608 - p.recordSpan(int(span_start842), "IntType") - return result843 + _t1612 := &pb.IntType{} + result845 := _t1612 + p.recordSpan(int(span_start844), "IntType") + return result845 } func (p *Parser) parse_float_type() *pb.FloatType { - span_start844 := int64(p.spanStart()) + span_start846 := int64(p.spanStart()) p.consumeLiteral("FLOAT") - _t1609 := &pb.FloatType{} - result845 := _t1609 - p.recordSpan(int(span_start844), "FloatType") - return result845 + _t1613 := &pb.FloatType{} + result847 := _t1613 + p.recordSpan(int(span_start846), "FloatType") + return result847 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start846 := int64(p.spanStart()) + span_start848 := int64(p.spanStart()) p.consumeLiteral("UINT128") - _t1610 := &pb.UInt128Type{} - result847 := _t1610 - p.recordSpan(int(span_start846), "UInt128Type") - return result847 + _t1614 := &pb.UInt128Type{} + result849 := _t1614 + p.recordSpan(int(span_start848), "UInt128Type") + return result849 } func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start848 := int64(p.spanStart()) + span_start850 := int64(p.spanStart()) p.consumeLiteral("INT128") - _t1611 := &pb.Int128Type{} - result849 := _t1611 - p.recordSpan(int(span_start848), "Int128Type") - return result849 + _t1615 := &pb.Int128Type{} + result851 := _t1615 + p.recordSpan(int(span_start850), "Int128Type") + return result851 } func (p *Parser) parse_date_type() *pb.DateType { - span_start850 := int64(p.spanStart()) + span_start852 := int64(p.spanStart()) p.consumeLiteral("DATE") - _t1612 := &pb.DateType{} - result851 := _t1612 - p.recordSpan(int(span_start850), "DateType") - return result851 + _t1616 := &pb.DateType{} + result853 := _t1616 + p.recordSpan(int(span_start852), "DateType") + return result853 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start852 := int64(p.spanStart()) + span_start854 := int64(p.spanStart()) p.consumeLiteral("DATETIME") - _t1613 := &pb.DateTimeType{} - result853 := _t1613 - p.recordSpan(int(span_start852), "DateTimeType") - return result853 + _t1617 := &pb.DateTimeType{} + result855 := _t1617 + p.recordSpan(int(span_start854), "DateTimeType") + return result855 } func (p *Parser) parse_missing_type() *pb.MissingType { - span_start854 := int64(p.spanStart()) + span_start856 := int64(p.spanStart()) p.consumeLiteral("MISSING") - _t1614 := &pb.MissingType{} - result855 := _t1614 - p.recordSpan(int(span_start854), "MissingType") - return result855 + _t1618 := &pb.MissingType{} + result857 := _t1618 + p.recordSpan(int(span_start856), "MissingType") + return result857 } func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start858 := int64(p.spanStart()) + span_start860 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int856 := p.consumeTerminal("INT").Value.i64 - int_3857 := p.consumeTerminal("INT").Value.i64 + int858 := p.consumeTerminal("INT").Value.i64 + int_3859 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1615 := &pb.DecimalType{Precision: int32(int856), Scale: int32(int_3857)} - result859 := _t1615 - p.recordSpan(int(span_start858), "DecimalType") - return result859 + _t1619 := &pb.DecimalType{Precision: int32(int858), Scale: int32(int_3859)} + result861 := _t1619 + p.recordSpan(int(span_start860), "DecimalType") + return result861 } func (p *Parser) parse_boolean_type() *pb.BooleanType { - span_start860 := int64(p.spanStart()) + span_start862 := int64(p.spanStart()) p.consumeLiteral("BOOLEAN") - _t1616 := &pb.BooleanType{} - result861 := _t1616 - p.recordSpan(int(span_start860), "BooleanType") - return result861 + _t1620 := &pb.BooleanType{} + result863 := _t1620 + p.recordSpan(int(span_start862), "BooleanType") + return result863 } func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start862 := int64(p.spanStart()) + span_start864 := int64(p.spanStart()) p.consumeLiteral("INT32") - _t1617 := &pb.Int32Type{} - result863 := _t1617 - p.recordSpan(int(span_start862), "Int32Type") - return result863 + _t1621 := &pb.Int32Type{} + result865 := _t1621 + p.recordSpan(int(span_start864), "Int32Type") + return result865 } func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start864 := int64(p.spanStart()) + span_start866 := int64(p.spanStart()) p.consumeLiteral("FLOAT32") - _t1618 := &pb.Float32Type{} - result865 := _t1618 - p.recordSpan(int(span_start864), "Float32Type") - return result865 + _t1622 := &pb.Float32Type{} + result867 := _t1622 + p.recordSpan(int(span_start866), "Float32Type") + return result867 } func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start866 := int64(p.spanStart()) + span_start868 := int64(p.spanStart()) p.consumeLiteral("UINT32") - _t1619 := &pb.UInt32Type{} - result867 := _t1619 - p.recordSpan(int(span_start866), "UInt32Type") - return result867 + _t1623 := &pb.UInt32Type{} + result869 := _t1623 + p.recordSpan(int(span_start868), "UInt32Type") + return result869 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs868 := []*pb.Binding{} - cond869 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond869 { - _t1620 := p.parse_binding() - item870 := _t1620 - xs868 = append(xs868, item870) - cond869 = p.matchLookaheadTerminal("SYMBOL", 0) + xs870 := []*pb.Binding{} + cond871 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond871 { + _t1624 := p.parse_binding() + item872 := _t1624 + xs870 = append(xs870, item872) + cond871 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings871 := xs868 - return bindings871 + bindings873 := xs870 + return bindings873 } func (p *Parser) parse_formula() *pb.Formula { - span_start886 := int64(p.spanStart()) - var _t1621 int64 + span_start888 := int64(p.spanStart()) + var _t1625 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1622 int64 + var _t1626 int64 if p.matchLookaheadLiteral("true", 1) { - _t1622 = 0 + _t1626 = 0 } else { - var _t1623 int64 + var _t1627 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t1623 = 11 + _t1627 = 11 } else { - var _t1624 int64 + var _t1628 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t1624 = 3 + _t1628 = 3 } else { - var _t1625 int64 + var _t1629 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1625 = 10 + _t1629 = 10 } else { - var _t1626 int64 + var _t1630 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t1626 = 9 + _t1630 = 9 } else { - var _t1627 int64 + var _t1631 int64 if p.matchLookaheadLiteral("or", 1) { - _t1627 = 5 + _t1631 = 5 } else { - var _t1628 int64 + var _t1632 int64 if p.matchLookaheadLiteral("not", 1) { - _t1628 = 6 + _t1632 = 6 } else { - var _t1629 int64 + var _t1633 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t1629 = 7 + _t1633 = 7 } else { - var _t1630 int64 + var _t1634 int64 if p.matchLookaheadLiteral("false", 1) { - _t1630 = 1 + _t1634 = 1 } else { - var _t1631 int64 + var _t1635 int64 if p.matchLookaheadLiteral("exists", 1) { - _t1631 = 2 + _t1635 = 2 } else { - var _t1632 int64 + var _t1636 int64 if p.matchLookaheadLiteral("cast", 1) { - _t1632 = 12 + _t1636 = 12 } else { - var _t1633 int64 + var _t1637 int64 if p.matchLookaheadLiteral("atom", 1) { - _t1633 = 8 + _t1637 = 8 } else { - var _t1634 int64 + var _t1638 int64 if p.matchLookaheadLiteral("and", 1) { - _t1634 = 4 + _t1638 = 4 } else { - var _t1635 int64 + var _t1639 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1635 = 10 + _t1639 = 10 } else { - var _t1636 int64 + var _t1640 int64 if p.matchLookaheadLiteral(">", 1) { - _t1636 = 10 + _t1640 = 10 } else { - var _t1637 int64 + var _t1641 int64 if p.matchLookaheadLiteral("=", 1) { - _t1637 = 10 + _t1641 = 10 } else { - var _t1638 int64 + var _t1642 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1638 = 10 + _t1642 = 10 } else { - var _t1639 int64 + var _t1643 int64 if p.matchLookaheadLiteral("<", 1) { - _t1639 = 10 + _t1643 = 10 } else { - var _t1640 int64 + var _t1644 int64 if p.matchLookaheadLiteral("/", 1) { - _t1640 = 10 + _t1644 = 10 } else { - var _t1641 int64 + var _t1645 int64 if p.matchLookaheadLiteral("-", 1) { - _t1641 = 10 + _t1645 = 10 } else { - var _t1642 int64 + var _t1646 int64 if p.matchLookaheadLiteral("+", 1) { - _t1642 = 10 + _t1646 = 10 } else { - var _t1643 int64 + var _t1647 int64 if p.matchLookaheadLiteral("*", 1) { - _t1643 = 10 + _t1647 = 10 } else { - _t1643 = -1 + _t1647 = -1 } - _t1642 = _t1643 + _t1646 = _t1647 } - _t1641 = _t1642 + _t1645 = _t1646 } - _t1640 = _t1641 + _t1644 = _t1645 } - _t1639 = _t1640 + _t1643 = _t1644 } - _t1638 = _t1639 + _t1642 = _t1643 } - _t1637 = _t1638 + _t1641 = _t1642 } - _t1636 = _t1637 + _t1640 = _t1641 } - _t1635 = _t1636 + _t1639 = _t1640 } - _t1634 = _t1635 + _t1638 = _t1639 } - _t1633 = _t1634 + _t1637 = _t1638 } - _t1632 = _t1633 + _t1636 = _t1637 } - _t1631 = _t1632 + _t1635 = _t1636 } - _t1630 = _t1631 + _t1634 = _t1635 } - _t1629 = _t1630 + _t1633 = _t1634 } - _t1628 = _t1629 + _t1632 = _t1633 } - _t1627 = _t1628 + _t1631 = _t1632 } - _t1626 = _t1627 + _t1630 = _t1631 } - _t1625 = _t1626 + _t1629 = _t1630 } - _t1624 = _t1625 + _t1628 = _t1629 } - _t1623 = _t1624 + _t1627 = _t1628 } - _t1622 = _t1623 + _t1626 = _t1627 } - _t1621 = _t1622 + _t1625 = _t1626 } else { - _t1621 = -1 - } - prediction872 := _t1621 - var _t1644 *pb.Formula - if prediction872 == 12 { - _t1645 := p.parse_cast() - cast885 := _t1645 - _t1646 := &pb.Formula{} - _t1646.FormulaType = &pb.Formula_Cast{Cast: cast885} - _t1644 = _t1646 + _t1625 = -1 + } + prediction874 := _t1625 + var _t1648 *pb.Formula + if prediction874 == 12 { + _t1649 := p.parse_cast() + cast887 := _t1649 + _t1650 := &pb.Formula{} + _t1650.FormulaType = &pb.Formula_Cast{Cast: cast887} + _t1648 = _t1650 } else { - var _t1647 *pb.Formula - if prediction872 == 11 { - _t1648 := p.parse_rel_atom() - rel_atom884 := _t1648 - _t1649 := &pb.Formula{} - _t1649.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom884} - _t1647 = _t1649 + var _t1651 *pb.Formula + if prediction874 == 11 { + _t1652 := p.parse_rel_atom() + rel_atom886 := _t1652 + _t1653 := &pb.Formula{} + _t1653.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom886} + _t1651 = _t1653 } else { - var _t1650 *pb.Formula - if prediction872 == 10 { - _t1651 := p.parse_primitive() - primitive883 := _t1651 - _t1652 := &pb.Formula{} - _t1652.FormulaType = &pb.Formula_Primitive{Primitive: primitive883} - _t1650 = _t1652 + var _t1654 *pb.Formula + if prediction874 == 10 { + _t1655 := p.parse_primitive() + primitive885 := _t1655 + _t1656 := &pb.Formula{} + _t1656.FormulaType = &pb.Formula_Primitive{Primitive: primitive885} + _t1654 = _t1656 } else { - var _t1653 *pb.Formula - if prediction872 == 9 { - _t1654 := p.parse_pragma() - pragma882 := _t1654 - _t1655 := &pb.Formula{} - _t1655.FormulaType = &pb.Formula_Pragma{Pragma: pragma882} - _t1653 = _t1655 + var _t1657 *pb.Formula + if prediction874 == 9 { + _t1658 := p.parse_pragma() + pragma884 := _t1658 + _t1659 := &pb.Formula{} + _t1659.FormulaType = &pb.Formula_Pragma{Pragma: pragma884} + _t1657 = _t1659 } else { - var _t1656 *pb.Formula - if prediction872 == 8 { - _t1657 := p.parse_atom() - atom881 := _t1657 - _t1658 := &pb.Formula{} - _t1658.FormulaType = &pb.Formula_Atom{Atom: atom881} - _t1656 = _t1658 + var _t1660 *pb.Formula + if prediction874 == 8 { + _t1661 := p.parse_atom() + atom883 := _t1661 + _t1662 := &pb.Formula{} + _t1662.FormulaType = &pb.Formula_Atom{Atom: atom883} + _t1660 = _t1662 } else { - var _t1659 *pb.Formula - if prediction872 == 7 { - _t1660 := p.parse_ffi() - ffi880 := _t1660 - _t1661 := &pb.Formula{} - _t1661.FormulaType = &pb.Formula_Ffi{Ffi: ffi880} - _t1659 = _t1661 + var _t1663 *pb.Formula + if prediction874 == 7 { + _t1664 := p.parse_ffi() + ffi882 := _t1664 + _t1665 := &pb.Formula{} + _t1665.FormulaType = &pb.Formula_Ffi{Ffi: ffi882} + _t1663 = _t1665 } else { - var _t1662 *pb.Formula - if prediction872 == 6 { - _t1663 := p.parse_not() - not879 := _t1663 - _t1664 := &pb.Formula{} - _t1664.FormulaType = &pb.Formula_Not{Not: not879} - _t1662 = _t1664 + var _t1666 *pb.Formula + if prediction874 == 6 { + _t1667 := p.parse_not() + not881 := _t1667 + _t1668 := &pb.Formula{} + _t1668.FormulaType = &pb.Formula_Not{Not: not881} + _t1666 = _t1668 } else { - var _t1665 *pb.Formula - if prediction872 == 5 { - _t1666 := p.parse_disjunction() - disjunction878 := _t1666 - _t1667 := &pb.Formula{} - _t1667.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction878} - _t1665 = _t1667 + var _t1669 *pb.Formula + if prediction874 == 5 { + _t1670 := p.parse_disjunction() + disjunction880 := _t1670 + _t1671 := &pb.Formula{} + _t1671.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction880} + _t1669 = _t1671 } else { - var _t1668 *pb.Formula - if prediction872 == 4 { - _t1669 := p.parse_conjunction() - conjunction877 := _t1669 - _t1670 := &pb.Formula{} - _t1670.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction877} - _t1668 = _t1670 + var _t1672 *pb.Formula + if prediction874 == 4 { + _t1673 := p.parse_conjunction() + conjunction879 := _t1673 + _t1674 := &pb.Formula{} + _t1674.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction879} + _t1672 = _t1674 } else { - var _t1671 *pb.Formula - if prediction872 == 3 { - _t1672 := p.parse_reduce() - reduce876 := _t1672 - _t1673 := &pb.Formula{} - _t1673.FormulaType = &pb.Formula_Reduce{Reduce: reduce876} - _t1671 = _t1673 + var _t1675 *pb.Formula + if prediction874 == 3 { + _t1676 := p.parse_reduce() + reduce878 := _t1676 + _t1677 := &pb.Formula{} + _t1677.FormulaType = &pb.Formula_Reduce{Reduce: reduce878} + _t1675 = _t1677 } else { - var _t1674 *pb.Formula - if prediction872 == 2 { - _t1675 := p.parse_exists() - exists875 := _t1675 - _t1676 := &pb.Formula{} - _t1676.FormulaType = &pb.Formula_Exists{Exists: exists875} - _t1674 = _t1676 + var _t1678 *pb.Formula + if prediction874 == 2 { + _t1679 := p.parse_exists() + exists877 := _t1679 + _t1680 := &pb.Formula{} + _t1680.FormulaType = &pb.Formula_Exists{Exists: exists877} + _t1678 = _t1680 } else { - var _t1677 *pb.Formula - if prediction872 == 1 { - _t1678 := p.parse_false() - false874 := _t1678 - _t1679 := &pb.Formula{} - _t1679.FormulaType = &pb.Formula_Disjunction{Disjunction: false874} - _t1677 = _t1679 + var _t1681 *pb.Formula + if prediction874 == 1 { + _t1682 := p.parse_false() + false876 := _t1682 + _t1683 := &pb.Formula{} + _t1683.FormulaType = &pb.Formula_Disjunction{Disjunction: false876} + _t1681 = _t1683 } else { - var _t1680 *pb.Formula - if prediction872 == 0 { - _t1681 := p.parse_true() - true873 := _t1681 - _t1682 := &pb.Formula{} - _t1682.FormulaType = &pb.Formula_Conjunction{Conjunction: true873} - _t1680 = _t1682 + var _t1684 *pb.Formula + if prediction874 == 0 { + _t1685 := p.parse_true() + true875 := _t1685 + _t1686 := &pb.Formula{} + _t1686.FormulaType = &pb.Formula_Conjunction{Conjunction: true875} + _t1684 = _t1686 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1677 = _t1680 + _t1681 = _t1684 } - _t1674 = _t1677 + _t1678 = _t1681 } - _t1671 = _t1674 + _t1675 = _t1678 } - _t1668 = _t1671 + _t1672 = _t1675 } - _t1665 = _t1668 + _t1669 = _t1672 } - _t1662 = _t1665 + _t1666 = _t1669 } - _t1659 = _t1662 + _t1663 = _t1666 } - _t1656 = _t1659 + _t1660 = _t1663 } - _t1653 = _t1656 + _t1657 = _t1660 } - _t1650 = _t1653 + _t1654 = _t1657 } - _t1647 = _t1650 + _t1651 = _t1654 } - _t1644 = _t1647 + _t1648 = _t1651 } - result887 := _t1644 - p.recordSpan(int(span_start886), "Formula") - return result887 + result889 := _t1648 + p.recordSpan(int(span_start888), "Formula") + return result889 } func (p *Parser) parse_true() *pb.Conjunction { - span_start888 := int64(p.spanStart()) + span_start890 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t1683 := &pb.Conjunction{Args: []*pb.Formula{}} - result889 := _t1683 - p.recordSpan(int(span_start888), "Conjunction") - return result889 + _t1687 := &pb.Conjunction{Args: []*pb.Formula{}} + result891 := _t1687 + p.recordSpan(int(span_start890), "Conjunction") + return result891 } func (p *Parser) parse_false() *pb.Disjunction { - span_start890 := int64(p.spanStart()) + span_start892 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t1684 := &pb.Disjunction{Args: []*pb.Formula{}} - result891 := _t1684 - p.recordSpan(int(span_start890), "Disjunction") - return result891 + _t1688 := &pb.Disjunction{Args: []*pb.Formula{}} + result893 := _t1688 + p.recordSpan(int(span_start892), "Disjunction") + return result893 } func (p *Parser) parse_exists() *pb.Exists { - span_start894 := int64(p.spanStart()) + span_start896 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("exists") - _t1685 := p.parse_bindings() - bindings892 := _t1685 - _t1686 := p.parse_formula() - formula893 := _t1686 + _t1689 := p.parse_bindings() + bindings894 := _t1689 + _t1690 := p.parse_formula() + formula895 := _t1690 p.consumeLiteral(")") - _t1687 := &pb.Abstraction{Vars: listConcat(bindings892[0].([]*pb.Binding), bindings892[1].([]*pb.Binding)), Value: formula893} - _t1688 := &pb.Exists{Body: _t1687} - result895 := _t1688 - p.recordSpan(int(span_start894), "Exists") - return result895 + _t1691 := &pb.Abstraction{Vars: listConcat(bindings894[0].([]*pb.Binding), bindings894[1].([]*pb.Binding)), Value: formula895} + _t1692 := &pb.Exists{Body: _t1691} + result897 := _t1692 + p.recordSpan(int(span_start896), "Exists") + return result897 } func (p *Parser) parse_reduce() *pb.Reduce { - span_start899 := int64(p.spanStart()) + span_start901 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("reduce") - _t1689 := p.parse_abstraction() - abstraction896 := _t1689 - _t1690 := p.parse_abstraction() - abstraction_3897 := _t1690 - _t1691 := p.parse_terms() - terms898 := _t1691 + _t1693 := p.parse_abstraction() + abstraction898 := _t1693 + _t1694 := p.parse_abstraction() + abstraction_3899 := _t1694 + _t1695 := p.parse_terms() + terms900 := _t1695 p.consumeLiteral(")") - _t1692 := &pb.Reduce{Op: abstraction896, Body: abstraction_3897, Terms: terms898} - result900 := _t1692 - p.recordSpan(int(span_start899), "Reduce") - return result900 + _t1696 := &pb.Reduce{Op: abstraction898, Body: abstraction_3899, Terms: terms900} + result902 := _t1696 + p.recordSpan(int(span_start901), "Reduce") + return result902 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs901 := []*pb.Term{} - cond902 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond902 { - _t1693 := p.parse_term() - item903 := _t1693 - xs901 = append(xs901, item903) - cond902 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - terms904 := xs901 + xs903 := []*pb.Term{} + cond904 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond904 { + _t1697 := p.parse_term() + item905 := _t1697 + xs903 = append(xs903, item905) + cond904 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + } + terms906 := xs903 p.consumeLiteral(")") - return terms904 + return terms906 } func (p *Parser) parse_term() *pb.Term { - span_start908 := int64(p.spanStart()) - var _t1694 int64 + span_start910 := int64(p.spanStart()) + var _t1698 int64 if p.matchLookaheadLiteral("true", 0) { - _t1694 = 1 + _t1698 = 1 } else { - var _t1695 int64 + var _t1699 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1695 = 1 + _t1699 = 1 } else { - var _t1696 int64 + var _t1700 int64 if p.matchLookaheadLiteral("false", 0) { - _t1696 = 1 + _t1700 = 1 } else { - var _t1697 int64 + var _t1701 int64 if p.matchLookaheadLiteral("(", 0) { - _t1697 = 1 + _t1701 = 1 } else { - var _t1698 int64 + var _t1702 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1698 = 0 + _t1702 = 0 } else { - var _t1699 int64 + var _t1703 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1699 = 1 + _t1703 = 1 } else { - var _t1700 int64 + var _t1704 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1700 = 1 + _t1704 = 1 } else { - var _t1701 int64 + var _t1705 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1701 = 1 + _t1705 = 1 } else { - var _t1702 int64 + var _t1706 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1702 = 1 + _t1706 = 1 } else { - var _t1703 int64 + var _t1707 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1703 = 1 + _t1707 = 1 } else { - var _t1704 int64 + var _t1708 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1704 = 1 + _t1708 = 1 } else { - var _t1705 int64 + var _t1709 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1705 = 1 + _t1709 = 1 } else { - var _t1706 int64 + var _t1710 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1706 = 1 + _t1710 = 1 } else { - var _t1707 int64 + var _t1711 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1707 = 1 + _t1711 = 1 } else { - _t1707 = -1 + _t1711 = -1 } - _t1706 = _t1707 + _t1710 = _t1711 } - _t1705 = _t1706 + _t1709 = _t1710 } - _t1704 = _t1705 + _t1708 = _t1709 } - _t1703 = _t1704 + _t1707 = _t1708 } - _t1702 = _t1703 + _t1706 = _t1707 } - _t1701 = _t1702 + _t1705 = _t1706 } - _t1700 = _t1701 + _t1704 = _t1705 } - _t1699 = _t1700 + _t1703 = _t1704 } - _t1698 = _t1699 + _t1702 = _t1703 } - _t1697 = _t1698 + _t1701 = _t1702 } - _t1696 = _t1697 + _t1700 = _t1701 } - _t1695 = _t1696 + _t1699 = _t1700 } - _t1694 = _t1695 - } - prediction905 := _t1694 - var _t1708 *pb.Term - if prediction905 == 1 { - _t1709 := p.parse_value() - value907 := _t1709 - _t1710 := &pb.Term{} - _t1710.TermType = &pb.Term_Constant{Constant: value907} - _t1708 = _t1710 + _t1698 = _t1699 + } + prediction907 := _t1698 + var _t1712 *pb.Term + if prediction907 == 1 { + _t1713 := p.parse_value() + value909 := _t1713 + _t1714 := &pb.Term{} + _t1714.TermType = &pb.Term_Constant{Constant: value909} + _t1712 = _t1714 } else { - var _t1711 *pb.Term - if prediction905 == 0 { - _t1712 := p.parse_var() - var906 := _t1712 - _t1713 := &pb.Term{} - _t1713.TermType = &pb.Term_Var{Var: var906} - _t1711 = _t1713 + var _t1715 *pb.Term + if prediction907 == 0 { + _t1716 := p.parse_var() + var908 := _t1716 + _t1717 := &pb.Term{} + _t1717.TermType = &pb.Term_Var{Var: var908} + _t1715 = _t1717 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1708 = _t1711 + _t1712 = _t1715 } - result909 := _t1708 - p.recordSpan(int(span_start908), "Term") - return result909 + result911 := _t1712 + p.recordSpan(int(span_start910), "Term") + return result911 } func (p *Parser) parse_var() *pb.Var { - span_start911 := int64(p.spanStart()) - symbol910 := p.consumeTerminal("SYMBOL").Value.str - _t1714 := &pb.Var{Name: symbol910} - result912 := _t1714 - p.recordSpan(int(span_start911), "Var") - return result912 + span_start913 := int64(p.spanStart()) + symbol912 := p.consumeTerminal("SYMBOL").Value.str + _t1718 := &pb.Var{Name: symbol912} + result914 := _t1718 + p.recordSpan(int(span_start913), "Var") + return result914 } func (p *Parser) parse_value() *pb.Value { - span_start926 := int64(p.spanStart()) - var _t1715 int64 + span_start928 := int64(p.spanStart()) + var _t1719 int64 if p.matchLookaheadLiteral("true", 0) { - _t1715 = 12 + _t1719 = 12 } else { - var _t1716 int64 + var _t1720 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1716 = 11 + _t1720 = 11 } else { - var _t1717 int64 + var _t1721 int64 if p.matchLookaheadLiteral("false", 0) { - _t1717 = 12 + _t1721 = 12 } else { - var _t1718 int64 + var _t1722 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1719 int64 + var _t1723 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1719 = 1 + _t1723 = 1 } else { - var _t1720 int64 + var _t1724 int64 if p.matchLookaheadLiteral("date", 1) { - _t1720 = 0 + _t1724 = 0 } else { - _t1720 = -1 + _t1724 = -1 } - _t1719 = _t1720 + _t1723 = _t1724 } - _t1718 = _t1719 + _t1722 = _t1723 } else { - var _t1721 int64 + var _t1725 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1721 = 7 + _t1725 = 7 } else { - var _t1722 int64 + var _t1726 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1722 = 8 + _t1726 = 8 } else { - var _t1723 int64 + var _t1727 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1723 = 2 + _t1727 = 2 } else { - var _t1724 int64 + var _t1728 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1724 = 3 + _t1728 = 3 } else { - var _t1725 int64 + var _t1729 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1725 = 9 + _t1729 = 9 } else { - var _t1726 int64 + var _t1730 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1726 = 4 + _t1730 = 4 } else { - var _t1727 int64 + var _t1731 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1727 = 5 + _t1731 = 5 } else { - var _t1728 int64 + var _t1732 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1728 = 6 + _t1732 = 6 } else { - var _t1729 int64 + var _t1733 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1729 = 10 + _t1733 = 10 } else { - _t1729 = -1 + _t1733 = -1 } - _t1728 = _t1729 + _t1732 = _t1733 } - _t1727 = _t1728 + _t1731 = _t1732 } - _t1726 = _t1727 + _t1730 = _t1731 } - _t1725 = _t1726 + _t1729 = _t1730 } - _t1724 = _t1725 + _t1728 = _t1729 } - _t1723 = _t1724 + _t1727 = _t1728 } - _t1722 = _t1723 + _t1726 = _t1727 } - _t1721 = _t1722 + _t1725 = _t1726 } - _t1718 = _t1721 + _t1722 = _t1725 } - _t1717 = _t1718 + _t1721 = _t1722 } - _t1716 = _t1717 + _t1720 = _t1721 } - _t1715 = _t1716 - } - prediction913 := _t1715 - var _t1730 *pb.Value - if prediction913 == 12 { - _t1731 := p.parse_boolean_value() - boolean_value925 := _t1731 - _t1732 := &pb.Value{} - _t1732.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value925} - _t1730 = _t1732 + _t1719 = _t1720 + } + prediction915 := _t1719 + var _t1734 *pb.Value + if prediction915 == 12 { + _t1735 := p.parse_boolean_value() + boolean_value927 := _t1735 + _t1736 := &pb.Value{} + _t1736.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value927} + _t1734 = _t1736 } else { - var _t1733 *pb.Value - if prediction913 == 11 { + var _t1737 *pb.Value + if prediction915 == 11 { p.consumeLiteral("missing") - _t1734 := &pb.MissingValue{} - _t1735 := &pb.Value{} - _t1735.Value = &pb.Value_MissingValue{MissingValue: _t1734} - _t1733 = _t1735 + _t1738 := &pb.MissingValue{} + _t1739 := &pb.Value{} + _t1739.Value = &pb.Value_MissingValue{MissingValue: _t1738} + _t1737 = _t1739 } else { - var _t1736 *pb.Value - if prediction913 == 10 { - formatted_decimal924 := p.consumeTerminal("DECIMAL").Value.decimal - _t1737 := &pb.Value{} - _t1737.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal924} - _t1736 = _t1737 + var _t1740 *pb.Value + if prediction915 == 10 { + formatted_decimal926 := p.consumeTerminal("DECIMAL").Value.decimal + _t1741 := &pb.Value{} + _t1741.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal926} + _t1740 = _t1741 } else { - var _t1738 *pb.Value - if prediction913 == 9 { - formatted_int128923 := p.consumeTerminal("INT128").Value.int128 - _t1739 := &pb.Value{} - _t1739.Value = &pb.Value_Int128Value{Int128Value: formatted_int128923} - _t1738 = _t1739 + var _t1742 *pb.Value + if prediction915 == 9 { + formatted_int128925 := p.consumeTerminal("INT128").Value.int128 + _t1743 := &pb.Value{} + _t1743.Value = &pb.Value_Int128Value{Int128Value: formatted_int128925} + _t1742 = _t1743 } else { - var _t1740 *pb.Value - if prediction913 == 8 { - formatted_uint128922 := p.consumeTerminal("UINT128").Value.uint128 - _t1741 := &pb.Value{} - _t1741.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128922} - _t1740 = _t1741 + var _t1744 *pb.Value + if prediction915 == 8 { + formatted_uint128924 := p.consumeTerminal("UINT128").Value.uint128 + _t1745 := &pb.Value{} + _t1745.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128924} + _t1744 = _t1745 } else { - var _t1742 *pb.Value - if prediction913 == 7 { - formatted_uint32921 := p.consumeTerminal("UINT32").Value.u32 - _t1743 := &pb.Value{} - _t1743.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32921} - _t1742 = _t1743 + var _t1746 *pb.Value + if prediction915 == 7 { + formatted_uint32923 := p.consumeTerminal("UINT32").Value.u32 + _t1747 := &pb.Value{} + _t1747.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32923} + _t1746 = _t1747 } else { - var _t1744 *pb.Value - if prediction913 == 6 { - formatted_float920 := p.consumeTerminal("FLOAT").Value.f64 - _t1745 := &pb.Value{} - _t1745.Value = &pb.Value_FloatValue{FloatValue: formatted_float920} - _t1744 = _t1745 + var _t1748 *pb.Value + if prediction915 == 6 { + formatted_float922 := p.consumeTerminal("FLOAT").Value.f64 + _t1749 := &pb.Value{} + _t1749.Value = &pb.Value_FloatValue{FloatValue: formatted_float922} + _t1748 = _t1749 } else { - var _t1746 *pb.Value - if prediction913 == 5 { - formatted_float32919 := p.consumeTerminal("FLOAT32").Value.f32 - _t1747 := &pb.Value{} - _t1747.Value = &pb.Value_Float32Value{Float32Value: formatted_float32919} - _t1746 = _t1747 + var _t1750 *pb.Value + if prediction915 == 5 { + formatted_float32921 := p.consumeTerminal("FLOAT32").Value.f32 + _t1751 := &pb.Value{} + _t1751.Value = &pb.Value_Float32Value{Float32Value: formatted_float32921} + _t1750 = _t1751 } else { - var _t1748 *pb.Value - if prediction913 == 4 { - formatted_int918 := p.consumeTerminal("INT").Value.i64 - _t1749 := &pb.Value{} - _t1749.Value = &pb.Value_IntValue{IntValue: formatted_int918} - _t1748 = _t1749 + var _t1752 *pb.Value + if prediction915 == 4 { + formatted_int920 := p.consumeTerminal("INT").Value.i64 + _t1753 := &pb.Value{} + _t1753.Value = &pb.Value_IntValue{IntValue: formatted_int920} + _t1752 = _t1753 } else { - var _t1750 *pb.Value - if prediction913 == 3 { - formatted_int32917 := p.consumeTerminal("INT32").Value.i32 - _t1751 := &pb.Value{} - _t1751.Value = &pb.Value_Int32Value{Int32Value: formatted_int32917} - _t1750 = _t1751 + var _t1754 *pb.Value + if prediction915 == 3 { + formatted_int32919 := p.consumeTerminal("INT32").Value.i32 + _t1755 := &pb.Value{} + _t1755.Value = &pb.Value_Int32Value{Int32Value: formatted_int32919} + _t1754 = _t1755 } else { - var _t1752 *pb.Value - if prediction913 == 2 { - formatted_string916 := p.consumeTerminal("STRING").Value.str - _t1753 := &pb.Value{} - _t1753.Value = &pb.Value_StringValue{StringValue: formatted_string916} - _t1752 = _t1753 + var _t1756 *pb.Value + if prediction915 == 2 { + formatted_string918 := p.consumeTerminal("STRING").Value.str + _t1757 := &pb.Value{} + _t1757.Value = &pb.Value_StringValue{StringValue: formatted_string918} + _t1756 = _t1757 } else { - var _t1754 *pb.Value - if prediction913 == 1 { - _t1755 := p.parse_datetime() - datetime915 := _t1755 - _t1756 := &pb.Value{} - _t1756.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime915} - _t1754 = _t1756 + var _t1758 *pb.Value + if prediction915 == 1 { + _t1759 := p.parse_datetime() + datetime917 := _t1759 + _t1760 := &pb.Value{} + _t1760.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime917} + _t1758 = _t1760 } else { - var _t1757 *pb.Value - if prediction913 == 0 { - _t1758 := p.parse_date() - date914 := _t1758 - _t1759 := &pb.Value{} - _t1759.Value = &pb.Value_DateValue{DateValue: date914} - _t1757 = _t1759 + var _t1761 *pb.Value + if prediction915 == 0 { + _t1762 := p.parse_date() + date916 := _t1762 + _t1763 := &pb.Value{} + _t1763.Value = &pb.Value_DateValue{DateValue: date916} + _t1761 = _t1763 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1754 = _t1757 + _t1758 = _t1761 } - _t1752 = _t1754 + _t1756 = _t1758 } - _t1750 = _t1752 + _t1754 = _t1756 } - _t1748 = _t1750 + _t1752 = _t1754 } - _t1746 = _t1748 + _t1750 = _t1752 } - _t1744 = _t1746 + _t1748 = _t1750 } - _t1742 = _t1744 + _t1746 = _t1748 } - _t1740 = _t1742 + _t1744 = _t1746 } - _t1738 = _t1740 + _t1742 = _t1744 } - _t1736 = _t1738 + _t1740 = _t1742 } - _t1733 = _t1736 + _t1737 = _t1740 } - _t1730 = _t1733 + _t1734 = _t1737 } - result927 := _t1730 - p.recordSpan(int(span_start926), "Value") - return result927 + result929 := _t1734 + p.recordSpan(int(span_start928), "Value") + return result929 } func (p *Parser) parse_date() *pb.DateValue { - span_start931 := int64(p.spanStart()) + span_start933 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - formatted_int928 := p.consumeTerminal("INT").Value.i64 - formatted_int_3929 := p.consumeTerminal("INT").Value.i64 - formatted_int_4930 := p.consumeTerminal("INT").Value.i64 + formatted_int930 := p.consumeTerminal("INT").Value.i64 + formatted_int_3931 := p.consumeTerminal("INT").Value.i64 + formatted_int_4932 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1760 := &pb.DateValue{Year: int32(formatted_int928), Month: int32(formatted_int_3929), Day: int32(formatted_int_4930)} - result932 := _t1760 - p.recordSpan(int(span_start931), "DateValue") - return result932 + _t1764 := &pb.DateValue{Year: int32(formatted_int930), Month: int32(formatted_int_3931), Day: int32(formatted_int_4932)} + result934 := _t1764 + p.recordSpan(int(span_start933), "DateValue") + return result934 } func (p *Parser) parse_datetime() *pb.DateTimeValue { - span_start940 := int64(p.spanStart()) + span_start942 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - formatted_int933 := p.consumeTerminal("INT").Value.i64 - formatted_int_3934 := p.consumeTerminal("INT").Value.i64 - formatted_int_4935 := p.consumeTerminal("INT").Value.i64 - formatted_int_5936 := p.consumeTerminal("INT").Value.i64 - formatted_int_6937 := p.consumeTerminal("INT").Value.i64 - formatted_int_7938 := p.consumeTerminal("INT").Value.i64 - var _t1761 *int64 + formatted_int935 := p.consumeTerminal("INT").Value.i64 + formatted_int_3936 := p.consumeTerminal("INT").Value.i64 + formatted_int_4937 := p.consumeTerminal("INT").Value.i64 + formatted_int_5938 := p.consumeTerminal("INT").Value.i64 + formatted_int_6939 := p.consumeTerminal("INT").Value.i64 + formatted_int_7940 := p.consumeTerminal("INT").Value.i64 + var _t1765 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1761 = ptr(p.consumeTerminal("INT").Value.i64) + _t1765 = ptr(p.consumeTerminal("INT").Value.i64) } - formatted_int_8939 := _t1761 + formatted_int_8941 := _t1765 p.consumeLiteral(")") - _t1762 := &pb.DateTimeValue{Year: int32(formatted_int933), Month: int32(formatted_int_3934), Day: int32(formatted_int_4935), Hour: int32(formatted_int_5936), Minute: int32(formatted_int_6937), Second: int32(formatted_int_7938), Microsecond: int32(deref(formatted_int_8939, 0))} - result941 := _t1762 - p.recordSpan(int(span_start940), "DateTimeValue") - return result941 + _t1766 := &pb.DateTimeValue{Year: int32(formatted_int935), Month: int32(formatted_int_3936), Day: int32(formatted_int_4937), Hour: int32(formatted_int_5938), Minute: int32(formatted_int_6939), Second: int32(formatted_int_7940), Microsecond: int32(deref(formatted_int_8941, 0))} + result943 := _t1766 + p.recordSpan(int(span_start942), "DateTimeValue") + return result943 } func (p *Parser) parse_conjunction() *pb.Conjunction { - span_start946 := int64(p.spanStart()) + span_start948 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("and") - xs942 := []*pb.Formula{} - cond943 := p.matchLookaheadLiteral("(", 0) - for cond943 { - _t1763 := p.parse_formula() - item944 := _t1763 - xs942 = append(xs942, item944) - cond943 = p.matchLookaheadLiteral("(", 0) - } - formulas945 := xs942 + xs944 := []*pb.Formula{} + cond945 := p.matchLookaheadLiteral("(", 0) + for cond945 { + _t1767 := p.parse_formula() + item946 := _t1767 + xs944 = append(xs944, item946) + cond945 = p.matchLookaheadLiteral("(", 0) + } + formulas947 := xs944 p.consumeLiteral(")") - _t1764 := &pb.Conjunction{Args: formulas945} - result947 := _t1764 - p.recordSpan(int(span_start946), "Conjunction") - return result947 + _t1768 := &pb.Conjunction{Args: formulas947} + result949 := _t1768 + p.recordSpan(int(span_start948), "Conjunction") + return result949 } func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start952 := int64(p.spanStart()) + span_start954 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") - xs948 := []*pb.Formula{} - cond949 := p.matchLookaheadLiteral("(", 0) - for cond949 { - _t1765 := p.parse_formula() - item950 := _t1765 - xs948 = append(xs948, item950) - cond949 = p.matchLookaheadLiteral("(", 0) - } - formulas951 := xs948 + xs950 := []*pb.Formula{} + cond951 := p.matchLookaheadLiteral("(", 0) + for cond951 { + _t1769 := p.parse_formula() + item952 := _t1769 + xs950 = append(xs950, item952) + cond951 = p.matchLookaheadLiteral("(", 0) + } + formulas953 := xs950 p.consumeLiteral(")") - _t1766 := &pb.Disjunction{Args: formulas951} - result953 := _t1766 - p.recordSpan(int(span_start952), "Disjunction") - return result953 + _t1770 := &pb.Disjunction{Args: formulas953} + result955 := _t1770 + p.recordSpan(int(span_start954), "Disjunction") + return result955 } func (p *Parser) parse_not() *pb.Not { - span_start955 := int64(p.spanStart()) + span_start957 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("not") - _t1767 := p.parse_formula() - formula954 := _t1767 + _t1771 := p.parse_formula() + formula956 := _t1771 p.consumeLiteral(")") - _t1768 := &pb.Not{Arg: formula954} - result956 := _t1768 - p.recordSpan(int(span_start955), "Not") - return result956 + _t1772 := &pb.Not{Arg: formula956} + result958 := _t1772 + p.recordSpan(int(span_start957), "Not") + return result958 } func (p *Parser) parse_ffi() *pb.FFI { - span_start960 := int64(p.spanStart()) + span_start962 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("ffi") - _t1769 := p.parse_name() - name957 := _t1769 - _t1770 := p.parse_ffi_args() - ffi_args958 := _t1770 - _t1771 := p.parse_terms() - terms959 := _t1771 + _t1773 := p.parse_name() + name959 := _t1773 + _t1774 := p.parse_ffi_args() + ffi_args960 := _t1774 + _t1775 := p.parse_terms() + terms961 := _t1775 p.consumeLiteral(")") - _t1772 := &pb.FFI{Name: name957, Args: ffi_args958, Terms: terms959} - result961 := _t1772 - p.recordSpan(int(span_start960), "FFI") - return result961 + _t1776 := &pb.FFI{Name: name959, Args: ffi_args960, Terms: terms961} + result963 := _t1776 + p.recordSpan(int(span_start962), "FFI") + return result963 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol962 := p.consumeTerminal("SYMBOL").Value.str - return symbol962 + symbol964 := p.consumeTerminal("SYMBOL").Value.str + return symbol964 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs963 := []*pb.Abstraction{} - cond964 := p.matchLookaheadLiteral("(", 0) - for cond964 { - _t1773 := p.parse_abstraction() - item965 := _t1773 - xs963 = append(xs963, item965) - cond964 = p.matchLookaheadLiteral("(", 0) - } - abstractions966 := xs963 + xs965 := []*pb.Abstraction{} + cond966 := p.matchLookaheadLiteral("(", 0) + for cond966 { + _t1777 := p.parse_abstraction() + item967 := _t1777 + xs965 = append(xs965, item967) + cond966 = p.matchLookaheadLiteral("(", 0) + } + abstractions968 := xs965 p.consumeLiteral(")") - return abstractions966 + return abstractions968 } func (p *Parser) parse_atom() *pb.Atom { - span_start972 := int64(p.spanStart()) + span_start974 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("atom") - _t1774 := p.parse_relation_id() - relation_id967 := _t1774 - xs968 := []*pb.Term{} - cond969 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond969 { - _t1775 := p.parse_term() - item970 := _t1775 - xs968 = append(xs968, item970) - cond969 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - terms971 := xs968 + _t1778 := p.parse_relation_id() + relation_id969 := _t1778 + xs970 := []*pb.Term{} + cond971 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond971 { + _t1779 := p.parse_term() + item972 := _t1779 + xs970 = append(xs970, item972) + cond971 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + } + terms973 := xs970 p.consumeLiteral(")") - _t1776 := &pb.Atom{Name: relation_id967, Terms: terms971} - result973 := _t1776 - p.recordSpan(int(span_start972), "Atom") - return result973 + _t1780 := &pb.Atom{Name: relation_id969, Terms: terms973} + result975 := _t1780 + p.recordSpan(int(span_start974), "Atom") + return result975 } func (p *Parser) parse_pragma() *pb.Pragma { - span_start979 := int64(p.spanStart()) + span_start981 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1777 := p.parse_name() - name974 := _t1777 - xs975 := []*pb.Term{} - cond976 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond976 { - _t1778 := p.parse_term() - item977 := _t1778 - xs975 = append(xs975, item977) - cond976 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - terms978 := xs975 + _t1781 := p.parse_name() + name976 := _t1781 + xs977 := []*pb.Term{} + cond978 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond978 { + _t1782 := p.parse_term() + item979 := _t1782 + xs977 = append(xs977, item979) + cond978 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + } + terms980 := xs977 p.consumeLiteral(")") - _t1779 := &pb.Pragma{Name: name974, Terms: terms978} - result980 := _t1779 - p.recordSpan(int(span_start979), "Pragma") - return result980 + _t1783 := &pb.Pragma{Name: name976, Terms: terms980} + result982 := _t1783 + p.recordSpan(int(span_start981), "Pragma") + return result982 } func (p *Parser) parse_primitive() *pb.Primitive { - span_start996 := int64(p.spanStart()) - var _t1780 int64 + span_start998 := int64(p.spanStart()) + var _t1784 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1781 int64 + var _t1785 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1781 = 9 + _t1785 = 9 } else { - var _t1782 int64 + var _t1786 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1782 = 4 + _t1786 = 4 } else { - var _t1783 int64 + var _t1787 int64 if p.matchLookaheadLiteral(">", 1) { - _t1783 = 3 + _t1787 = 3 } else { - var _t1784 int64 + var _t1788 int64 if p.matchLookaheadLiteral("=", 1) { - _t1784 = 0 + _t1788 = 0 } else { - var _t1785 int64 + var _t1789 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1785 = 2 + _t1789 = 2 } else { - var _t1786 int64 + var _t1790 int64 if p.matchLookaheadLiteral("<", 1) { - _t1786 = 1 + _t1790 = 1 } else { - var _t1787 int64 + var _t1791 int64 if p.matchLookaheadLiteral("/", 1) { - _t1787 = 8 + _t1791 = 8 } else { - var _t1788 int64 + var _t1792 int64 if p.matchLookaheadLiteral("-", 1) { - _t1788 = 6 + _t1792 = 6 } else { - var _t1789 int64 + var _t1793 int64 if p.matchLookaheadLiteral("+", 1) { - _t1789 = 5 + _t1793 = 5 } else { - var _t1790 int64 + var _t1794 int64 if p.matchLookaheadLiteral("*", 1) { - _t1790 = 7 + _t1794 = 7 } else { - _t1790 = -1 + _t1794 = -1 } - _t1789 = _t1790 + _t1793 = _t1794 } - _t1788 = _t1789 + _t1792 = _t1793 } - _t1787 = _t1788 + _t1791 = _t1792 } - _t1786 = _t1787 + _t1790 = _t1791 } - _t1785 = _t1786 + _t1789 = _t1790 } - _t1784 = _t1785 + _t1788 = _t1789 } - _t1783 = _t1784 + _t1787 = _t1788 } - _t1782 = _t1783 + _t1786 = _t1787 } - _t1781 = _t1782 + _t1785 = _t1786 } - _t1780 = _t1781 + _t1784 = _t1785 } else { - _t1780 = -1 + _t1784 = -1 } - prediction981 := _t1780 - var _t1791 *pb.Primitive - if prediction981 == 9 { + prediction983 := _t1784 + var _t1795 *pb.Primitive + if prediction983 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1792 := p.parse_name() - name991 := _t1792 - xs992 := []*pb.RelTerm{} - cond993 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond993 { - _t1793 := p.parse_rel_term() - item994 := _t1793 - xs992 = append(xs992, item994) - cond993 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + _t1796 := p.parse_name() + name993 := _t1796 + xs994 := []*pb.RelTerm{} + cond995 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond995 { + _t1797 := p.parse_rel_term() + item996 := _t1797 + xs994 = append(xs994, item996) + cond995 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) } - rel_terms995 := xs992 + rel_terms997 := xs994 p.consumeLiteral(")") - _t1794 := &pb.Primitive{Name: name991, Terms: rel_terms995} - _t1791 = _t1794 + _t1798 := &pb.Primitive{Name: name993, Terms: rel_terms997} + _t1795 = _t1798 } else { - var _t1795 *pb.Primitive - if prediction981 == 8 { - _t1796 := p.parse_divide() - divide990 := _t1796 - _t1795 = divide990 + var _t1799 *pb.Primitive + if prediction983 == 8 { + _t1800 := p.parse_divide() + divide992 := _t1800 + _t1799 = divide992 } else { - var _t1797 *pb.Primitive - if prediction981 == 7 { - _t1798 := p.parse_multiply() - multiply989 := _t1798 - _t1797 = multiply989 + var _t1801 *pb.Primitive + if prediction983 == 7 { + _t1802 := p.parse_multiply() + multiply991 := _t1802 + _t1801 = multiply991 } else { - var _t1799 *pb.Primitive - if prediction981 == 6 { - _t1800 := p.parse_minus() - minus988 := _t1800 - _t1799 = minus988 + var _t1803 *pb.Primitive + if prediction983 == 6 { + _t1804 := p.parse_minus() + minus990 := _t1804 + _t1803 = minus990 } else { - var _t1801 *pb.Primitive - if prediction981 == 5 { - _t1802 := p.parse_add() - add987 := _t1802 - _t1801 = add987 + var _t1805 *pb.Primitive + if prediction983 == 5 { + _t1806 := p.parse_add() + add989 := _t1806 + _t1805 = add989 } else { - var _t1803 *pb.Primitive - if prediction981 == 4 { - _t1804 := p.parse_gt_eq() - gt_eq986 := _t1804 - _t1803 = gt_eq986 + var _t1807 *pb.Primitive + if prediction983 == 4 { + _t1808 := p.parse_gt_eq() + gt_eq988 := _t1808 + _t1807 = gt_eq988 } else { - var _t1805 *pb.Primitive - if prediction981 == 3 { - _t1806 := p.parse_gt() - gt985 := _t1806 - _t1805 = gt985 + var _t1809 *pb.Primitive + if prediction983 == 3 { + _t1810 := p.parse_gt() + gt987 := _t1810 + _t1809 = gt987 } else { - var _t1807 *pb.Primitive - if prediction981 == 2 { - _t1808 := p.parse_lt_eq() - lt_eq984 := _t1808 - _t1807 = lt_eq984 + var _t1811 *pb.Primitive + if prediction983 == 2 { + _t1812 := p.parse_lt_eq() + lt_eq986 := _t1812 + _t1811 = lt_eq986 } else { - var _t1809 *pb.Primitive - if prediction981 == 1 { - _t1810 := p.parse_lt() - lt983 := _t1810 - _t1809 = lt983 + var _t1813 *pb.Primitive + if prediction983 == 1 { + _t1814 := p.parse_lt() + lt985 := _t1814 + _t1813 = lt985 } else { - var _t1811 *pb.Primitive - if prediction981 == 0 { - _t1812 := p.parse_eq() - eq982 := _t1812 - _t1811 = eq982 + var _t1815 *pb.Primitive + if prediction983 == 0 { + _t1816 := p.parse_eq() + eq984 := _t1816 + _t1815 = eq984 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1809 = _t1811 + _t1813 = _t1815 } - _t1807 = _t1809 + _t1811 = _t1813 } - _t1805 = _t1807 + _t1809 = _t1811 } - _t1803 = _t1805 + _t1807 = _t1809 } - _t1801 = _t1803 + _t1805 = _t1807 } - _t1799 = _t1801 + _t1803 = _t1805 } - _t1797 = _t1799 + _t1801 = _t1803 } - _t1795 = _t1797 + _t1799 = _t1801 } - _t1791 = _t1795 + _t1795 = _t1799 } - result997 := _t1791 - p.recordSpan(int(span_start996), "Primitive") - return result997 + result999 := _t1795 + p.recordSpan(int(span_start998), "Primitive") + return result999 } func (p *Parser) parse_eq() *pb.Primitive { - span_start1000 := int64(p.spanStart()) + span_start1002 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("=") - _t1813 := p.parse_term() - term998 := _t1813 - _t1814 := p.parse_term() - term_3999 := _t1814 + _t1817 := p.parse_term() + term1000 := _t1817 + _t1818 := p.parse_term() + term_31001 := _t1818 p.consumeLiteral(")") - _t1815 := &pb.RelTerm{} - _t1815.RelTermType = &pb.RelTerm_Term{Term: term998} - _t1816 := &pb.RelTerm{} - _t1816.RelTermType = &pb.RelTerm_Term{Term: term_3999} - _t1817 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1815, _t1816}} - result1001 := _t1817 - p.recordSpan(int(span_start1000), "Primitive") - return result1001 + _t1819 := &pb.RelTerm{} + _t1819.RelTermType = &pb.RelTerm_Term{Term: term1000} + _t1820 := &pb.RelTerm{} + _t1820.RelTermType = &pb.RelTerm_Term{Term: term_31001} + _t1821 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1819, _t1820}} + result1003 := _t1821 + p.recordSpan(int(span_start1002), "Primitive") + return result1003 } func (p *Parser) parse_lt() *pb.Primitive { - span_start1004 := int64(p.spanStart()) + span_start1006 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<") - _t1818 := p.parse_term() - term1002 := _t1818 - _t1819 := p.parse_term() - term_31003 := _t1819 + _t1822 := p.parse_term() + term1004 := _t1822 + _t1823 := p.parse_term() + term_31005 := _t1823 p.consumeLiteral(")") - _t1820 := &pb.RelTerm{} - _t1820.RelTermType = &pb.RelTerm_Term{Term: term1002} - _t1821 := &pb.RelTerm{} - _t1821.RelTermType = &pb.RelTerm_Term{Term: term_31003} - _t1822 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1820, _t1821}} - result1005 := _t1822 - p.recordSpan(int(span_start1004), "Primitive") - return result1005 + _t1824 := &pb.RelTerm{} + _t1824.RelTermType = &pb.RelTerm_Term{Term: term1004} + _t1825 := &pb.RelTerm{} + _t1825.RelTermType = &pb.RelTerm_Term{Term: term_31005} + _t1826 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1824, _t1825}} + result1007 := _t1826 + p.recordSpan(int(span_start1006), "Primitive") + return result1007 } func (p *Parser) parse_lt_eq() *pb.Primitive { - span_start1008 := int64(p.spanStart()) + span_start1010 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<=") - _t1823 := p.parse_term() - term1006 := _t1823 - _t1824 := p.parse_term() - term_31007 := _t1824 + _t1827 := p.parse_term() + term1008 := _t1827 + _t1828 := p.parse_term() + term_31009 := _t1828 p.consumeLiteral(")") - _t1825 := &pb.RelTerm{} - _t1825.RelTermType = &pb.RelTerm_Term{Term: term1006} - _t1826 := &pb.RelTerm{} - _t1826.RelTermType = &pb.RelTerm_Term{Term: term_31007} - _t1827 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1825, _t1826}} - result1009 := _t1827 - p.recordSpan(int(span_start1008), "Primitive") - return result1009 + _t1829 := &pb.RelTerm{} + _t1829.RelTermType = &pb.RelTerm_Term{Term: term1008} + _t1830 := &pb.RelTerm{} + _t1830.RelTermType = &pb.RelTerm_Term{Term: term_31009} + _t1831 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1829, _t1830}} + result1011 := _t1831 + p.recordSpan(int(span_start1010), "Primitive") + return result1011 } func (p *Parser) parse_gt() *pb.Primitive { - span_start1012 := int64(p.spanStart()) + span_start1014 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">") - _t1828 := p.parse_term() - term1010 := _t1828 - _t1829 := p.parse_term() - term_31011 := _t1829 + _t1832 := p.parse_term() + term1012 := _t1832 + _t1833 := p.parse_term() + term_31013 := _t1833 p.consumeLiteral(")") - _t1830 := &pb.RelTerm{} - _t1830.RelTermType = &pb.RelTerm_Term{Term: term1010} - _t1831 := &pb.RelTerm{} - _t1831.RelTermType = &pb.RelTerm_Term{Term: term_31011} - _t1832 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1830, _t1831}} - result1013 := _t1832 - p.recordSpan(int(span_start1012), "Primitive") - return result1013 + _t1834 := &pb.RelTerm{} + _t1834.RelTermType = &pb.RelTerm_Term{Term: term1012} + _t1835 := &pb.RelTerm{} + _t1835.RelTermType = &pb.RelTerm_Term{Term: term_31013} + _t1836 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1834, _t1835}} + result1015 := _t1836 + p.recordSpan(int(span_start1014), "Primitive") + return result1015 } func (p *Parser) parse_gt_eq() *pb.Primitive { - span_start1016 := int64(p.spanStart()) + span_start1018 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">=") - _t1833 := p.parse_term() - term1014 := _t1833 - _t1834 := p.parse_term() - term_31015 := _t1834 + _t1837 := p.parse_term() + term1016 := _t1837 + _t1838 := p.parse_term() + term_31017 := _t1838 p.consumeLiteral(")") - _t1835 := &pb.RelTerm{} - _t1835.RelTermType = &pb.RelTerm_Term{Term: term1014} - _t1836 := &pb.RelTerm{} - _t1836.RelTermType = &pb.RelTerm_Term{Term: term_31015} - _t1837 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1835, _t1836}} - result1017 := _t1837 - p.recordSpan(int(span_start1016), "Primitive") - return result1017 + _t1839 := &pb.RelTerm{} + _t1839.RelTermType = &pb.RelTerm_Term{Term: term1016} + _t1840 := &pb.RelTerm{} + _t1840.RelTermType = &pb.RelTerm_Term{Term: term_31017} + _t1841 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1839, _t1840}} + result1019 := _t1841 + p.recordSpan(int(span_start1018), "Primitive") + return result1019 } func (p *Parser) parse_add() *pb.Primitive { - span_start1021 := int64(p.spanStart()) + span_start1023 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("+") - _t1838 := p.parse_term() - term1018 := _t1838 - _t1839 := p.parse_term() - term_31019 := _t1839 - _t1840 := p.parse_term() - term_41020 := _t1840 + _t1842 := p.parse_term() + term1020 := _t1842 + _t1843 := p.parse_term() + term_31021 := _t1843 + _t1844 := p.parse_term() + term_41022 := _t1844 p.consumeLiteral(")") - _t1841 := &pb.RelTerm{} - _t1841.RelTermType = &pb.RelTerm_Term{Term: term1018} - _t1842 := &pb.RelTerm{} - _t1842.RelTermType = &pb.RelTerm_Term{Term: term_31019} - _t1843 := &pb.RelTerm{} - _t1843.RelTermType = &pb.RelTerm_Term{Term: term_41020} - _t1844 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1841, _t1842, _t1843}} - result1022 := _t1844 - p.recordSpan(int(span_start1021), "Primitive") - return result1022 + _t1845 := &pb.RelTerm{} + _t1845.RelTermType = &pb.RelTerm_Term{Term: term1020} + _t1846 := &pb.RelTerm{} + _t1846.RelTermType = &pb.RelTerm_Term{Term: term_31021} + _t1847 := &pb.RelTerm{} + _t1847.RelTermType = &pb.RelTerm_Term{Term: term_41022} + _t1848 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1845, _t1846, _t1847}} + result1024 := _t1848 + p.recordSpan(int(span_start1023), "Primitive") + return result1024 } func (p *Parser) parse_minus() *pb.Primitive { - span_start1026 := int64(p.spanStart()) + span_start1028 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("-") - _t1845 := p.parse_term() - term1023 := _t1845 - _t1846 := p.parse_term() - term_31024 := _t1846 - _t1847 := p.parse_term() - term_41025 := _t1847 + _t1849 := p.parse_term() + term1025 := _t1849 + _t1850 := p.parse_term() + term_31026 := _t1850 + _t1851 := p.parse_term() + term_41027 := _t1851 p.consumeLiteral(")") - _t1848 := &pb.RelTerm{} - _t1848.RelTermType = &pb.RelTerm_Term{Term: term1023} - _t1849 := &pb.RelTerm{} - _t1849.RelTermType = &pb.RelTerm_Term{Term: term_31024} - _t1850 := &pb.RelTerm{} - _t1850.RelTermType = &pb.RelTerm_Term{Term: term_41025} - _t1851 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1848, _t1849, _t1850}} - result1027 := _t1851 - p.recordSpan(int(span_start1026), "Primitive") - return result1027 + _t1852 := &pb.RelTerm{} + _t1852.RelTermType = &pb.RelTerm_Term{Term: term1025} + _t1853 := &pb.RelTerm{} + _t1853.RelTermType = &pb.RelTerm_Term{Term: term_31026} + _t1854 := &pb.RelTerm{} + _t1854.RelTermType = &pb.RelTerm_Term{Term: term_41027} + _t1855 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1852, _t1853, _t1854}} + result1029 := _t1855 + p.recordSpan(int(span_start1028), "Primitive") + return result1029 } func (p *Parser) parse_multiply() *pb.Primitive { - span_start1031 := int64(p.spanStart()) + span_start1033 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("*") - _t1852 := p.parse_term() - term1028 := _t1852 - _t1853 := p.parse_term() - term_31029 := _t1853 - _t1854 := p.parse_term() - term_41030 := _t1854 + _t1856 := p.parse_term() + term1030 := _t1856 + _t1857 := p.parse_term() + term_31031 := _t1857 + _t1858 := p.parse_term() + term_41032 := _t1858 p.consumeLiteral(")") - _t1855 := &pb.RelTerm{} - _t1855.RelTermType = &pb.RelTerm_Term{Term: term1028} - _t1856 := &pb.RelTerm{} - _t1856.RelTermType = &pb.RelTerm_Term{Term: term_31029} - _t1857 := &pb.RelTerm{} - _t1857.RelTermType = &pb.RelTerm_Term{Term: term_41030} - _t1858 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1855, _t1856, _t1857}} - result1032 := _t1858 - p.recordSpan(int(span_start1031), "Primitive") - return result1032 + _t1859 := &pb.RelTerm{} + _t1859.RelTermType = &pb.RelTerm_Term{Term: term1030} + _t1860 := &pb.RelTerm{} + _t1860.RelTermType = &pb.RelTerm_Term{Term: term_31031} + _t1861 := &pb.RelTerm{} + _t1861.RelTermType = &pb.RelTerm_Term{Term: term_41032} + _t1862 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1859, _t1860, _t1861}} + result1034 := _t1862 + p.recordSpan(int(span_start1033), "Primitive") + return result1034 } func (p *Parser) parse_divide() *pb.Primitive { - span_start1036 := int64(p.spanStart()) + span_start1038 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("/") - _t1859 := p.parse_term() - term1033 := _t1859 - _t1860 := p.parse_term() - term_31034 := _t1860 - _t1861 := p.parse_term() - term_41035 := _t1861 + _t1863 := p.parse_term() + term1035 := _t1863 + _t1864 := p.parse_term() + term_31036 := _t1864 + _t1865 := p.parse_term() + term_41037 := _t1865 p.consumeLiteral(")") - _t1862 := &pb.RelTerm{} - _t1862.RelTermType = &pb.RelTerm_Term{Term: term1033} - _t1863 := &pb.RelTerm{} - _t1863.RelTermType = &pb.RelTerm_Term{Term: term_31034} - _t1864 := &pb.RelTerm{} - _t1864.RelTermType = &pb.RelTerm_Term{Term: term_41035} - _t1865 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1862, _t1863, _t1864}} - result1037 := _t1865 - p.recordSpan(int(span_start1036), "Primitive") - return result1037 + _t1866 := &pb.RelTerm{} + _t1866.RelTermType = &pb.RelTerm_Term{Term: term1035} + _t1867 := &pb.RelTerm{} + _t1867.RelTermType = &pb.RelTerm_Term{Term: term_31036} + _t1868 := &pb.RelTerm{} + _t1868.RelTermType = &pb.RelTerm_Term{Term: term_41037} + _t1869 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1866, _t1867, _t1868}} + result1039 := _t1869 + p.recordSpan(int(span_start1038), "Primitive") + return result1039 } func (p *Parser) parse_rel_term() *pb.RelTerm { - span_start1041 := int64(p.spanStart()) - var _t1866 int64 + span_start1043 := int64(p.spanStart()) + var _t1870 int64 if p.matchLookaheadLiteral("true", 0) { - _t1866 = 1 + _t1870 = 1 } else { - var _t1867 int64 + var _t1871 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1867 = 1 + _t1871 = 1 } else { - var _t1868 int64 + var _t1872 int64 if p.matchLookaheadLiteral("false", 0) { - _t1868 = 1 + _t1872 = 1 } else { - var _t1869 int64 + var _t1873 int64 if p.matchLookaheadLiteral("(", 0) { - _t1869 = 1 + _t1873 = 1 } else { - var _t1870 int64 + var _t1874 int64 if p.matchLookaheadLiteral("#", 0) { - _t1870 = 0 + _t1874 = 0 } else { - var _t1871 int64 + var _t1875 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1871 = 1 + _t1875 = 1 } else { - var _t1872 int64 + var _t1876 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1872 = 1 + _t1876 = 1 } else { - var _t1873 int64 + var _t1877 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1873 = 1 + _t1877 = 1 } else { - var _t1874 int64 + var _t1878 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1874 = 1 + _t1878 = 1 } else { - var _t1875 int64 + var _t1879 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1875 = 1 + _t1879 = 1 } else { - var _t1876 int64 + var _t1880 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1876 = 1 + _t1880 = 1 } else { - var _t1877 int64 + var _t1881 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1877 = 1 + _t1881 = 1 } else { - var _t1878 int64 + var _t1882 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1878 = 1 + _t1882 = 1 } else { - var _t1879 int64 + var _t1883 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1879 = 1 + _t1883 = 1 } else { - var _t1880 int64 + var _t1884 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1880 = 1 + _t1884 = 1 } else { - _t1880 = -1 + _t1884 = -1 } - _t1879 = _t1880 + _t1883 = _t1884 } - _t1878 = _t1879 + _t1882 = _t1883 } - _t1877 = _t1878 + _t1881 = _t1882 } - _t1876 = _t1877 + _t1880 = _t1881 } - _t1875 = _t1876 + _t1879 = _t1880 } - _t1874 = _t1875 + _t1878 = _t1879 } - _t1873 = _t1874 + _t1877 = _t1878 } - _t1872 = _t1873 + _t1876 = _t1877 } - _t1871 = _t1872 + _t1875 = _t1876 } - _t1870 = _t1871 + _t1874 = _t1875 } - _t1869 = _t1870 + _t1873 = _t1874 } - _t1868 = _t1869 + _t1872 = _t1873 } - _t1867 = _t1868 + _t1871 = _t1872 } - _t1866 = _t1867 - } - prediction1038 := _t1866 - var _t1881 *pb.RelTerm - if prediction1038 == 1 { - _t1882 := p.parse_term() - term1040 := _t1882 - _t1883 := &pb.RelTerm{} - _t1883.RelTermType = &pb.RelTerm_Term{Term: term1040} - _t1881 = _t1883 + _t1870 = _t1871 + } + prediction1040 := _t1870 + var _t1885 *pb.RelTerm + if prediction1040 == 1 { + _t1886 := p.parse_term() + term1042 := _t1886 + _t1887 := &pb.RelTerm{} + _t1887.RelTermType = &pb.RelTerm_Term{Term: term1042} + _t1885 = _t1887 } else { - var _t1884 *pb.RelTerm - if prediction1038 == 0 { - _t1885 := p.parse_specialized_value() - specialized_value1039 := _t1885 - _t1886 := &pb.RelTerm{} - _t1886.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1039} - _t1884 = _t1886 + var _t1888 *pb.RelTerm + if prediction1040 == 0 { + _t1889 := p.parse_specialized_value() + specialized_value1041 := _t1889 + _t1890 := &pb.RelTerm{} + _t1890.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1041} + _t1888 = _t1890 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1881 = _t1884 + _t1885 = _t1888 } - result1042 := _t1881 - p.recordSpan(int(span_start1041), "RelTerm") - return result1042 + result1044 := _t1885 + p.recordSpan(int(span_start1043), "RelTerm") + return result1044 } func (p *Parser) parse_specialized_value() *pb.Value { - span_start1044 := int64(p.spanStart()) + span_start1046 := int64(p.spanStart()) p.consumeLiteral("#") - _t1887 := p.parse_raw_value() - raw_value1043 := _t1887 - result1045 := raw_value1043 - p.recordSpan(int(span_start1044), "Value") - return result1045 + _t1891 := p.parse_raw_value() + raw_value1045 := _t1891 + result1047 := raw_value1045 + p.recordSpan(int(span_start1046), "Value") + return result1047 } func (p *Parser) parse_rel_atom() *pb.RelAtom { - span_start1051 := int64(p.spanStart()) + span_start1053 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1888 := p.parse_name() - name1046 := _t1888 - xs1047 := []*pb.RelTerm{} - cond1048 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond1048 { - _t1889 := p.parse_rel_term() - item1049 := _t1889 - xs1047 = append(xs1047, item1049) - cond1048 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - rel_terms1050 := xs1047 + _t1892 := p.parse_name() + name1048 := _t1892 + xs1049 := []*pb.RelTerm{} + cond1050 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond1050 { + _t1893 := p.parse_rel_term() + item1051 := _t1893 + xs1049 = append(xs1049, item1051) + cond1050 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + } + rel_terms1052 := xs1049 p.consumeLiteral(")") - _t1890 := &pb.RelAtom{Name: name1046, Terms: rel_terms1050} - result1052 := _t1890 - p.recordSpan(int(span_start1051), "RelAtom") - return result1052 + _t1894 := &pb.RelAtom{Name: name1048, Terms: rel_terms1052} + result1054 := _t1894 + p.recordSpan(int(span_start1053), "RelAtom") + return result1054 } func (p *Parser) parse_cast() *pb.Cast { - span_start1055 := int64(p.spanStart()) + span_start1057 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("cast") - _t1891 := p.parse_term() - term1053 := _t1891 - _t1892 := p.parse_term() - term_31054 := _t1892 + _t1895 := p.parse_term() + term1055 := _t1895 + _t1896 := p.parse_term() + term_31056 := _t1896 p.consumeLiteral(")") - _t1893 := &pb.Cast{Input: term1053, Result: term_31054} - result1056 := _t1893 - p.recordSpan(int(span_start1055), "Cast") - return result1056 + _t1897 := &pb.Cast{Input: term1055, Result: term_31056} + result1058 := _t1897 + p.recordSpan(int(span_start1057), "Cast") + return result1058 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs1057 := []*pb.Attribute{} - cond1058 := p.matchLookaheadLiteral("(", 0) - for cond1058 { - _t1894 := p.parse_attribute() - item1059 := _t1894 - xs1057 = append(xs1057, item1059) - cond1058 = p.matchLookaheadLiteral("(", 0) - } - attributes1060 := xs1057 + xs1059 := []*pb.Attribute{} + cond1060 := p.matchLookaheadLiteral("(", 0) + for cond1060 { + _t1898 := p.parse_attribute() + item1061 := _t1898 + xs1059 = append(xs1059, item1061) + cond1060 = p.matchLookaheadLiteral("(", 0) + } + attributes1062 := xs1059 p.consumeLiteral(")") - return attributes1060 + return attributes1062 } func (p *Parser) parse_attribute() *pb.Attribute { - span_start1066 := int64(p.spanStart()) + span_start1068 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1895 := p.parse_name() - name1061 := _t1895 - xs1062 := []*pb.Value{} - cond1063 := ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) - for cond1063 { - _t1896 := p.parse_raw_value() - item1064 := _t1896 - xs1062 = append(xs1062, item1064) - cond1063 = ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) - } - raw_values1065 := xs1062 + _t1899 := p.parse_name() + name1063 := _t1899 + xs1064 := []*pb.Value{} + cond1065 := ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) + for cond1065 { + _t1900 := p.parse_raw_value() + item1066 := _t1900 + xs1064 = append(xs1064, item1066) + cond1065 = ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) + } + raw_values1067 := xs1064 p.consumeLiteral(")") - _t1897 := &pb.Attribute{Name: name1061, Args: raw_values1065} - result1067 := _t1897 - p.recordSpan(int(span_start1066), "Attribute") - return result1067 + _t1901 := &pb.Attribute{Name: name1063, Args: raw_values1067} + result1069 := _t1901 + p.recordSpan(int(span_start1068), "Attribute") + return result1069 } func (p *Parser) parse_algorithm() *pb.Algorithm { - span_start1074 := int64(p.spanStart()) + span_start1076 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs1068 := []*pb.RelationId{} - cond1069 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1069 { - _t1898 := p.parse_relation_id() - item1070 := _t1898 - xs1068 = append(xs1068, item1070) - cond1069 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1071 := xs1068 - _t1899 := p.parse_script() - script1072 := _t1899 - var _t1900 []*pb.Attribute + xs1070 := []*pb.RelationId{} + cond1071 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1071 { + _t1902 := p.parse_relation_id() + item1072 := _t1902 + xs1070 = append(xs1070, item1072) + cond1071 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1073 := xs1070 + _t1903 := p.parse_script() + script1074 := _t1903 + var _t1904 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1901 := p.parse_attrs() - _t1900 = _t1901 + _t1905 := p.parse_attrs() + _t1904 = _t1905 } - attrs1073 := _t1900 + attrs1075 := _t1904 p.consumeLiteral(")") - _t1902 := attrs1073 - if attrs1073 == nil { - _t1902 = []*pb.Attribute{} + _t1906 := attrs1075 + if attrs1075 == nil { + _t1906 = []*pb.Attribute{} } - _t1903 := &pb.Algorithm{Global: relation_ids1071, Body: script1072, Attrs: _t1902} - result1075 := _t1903 - p.recordSpan(int(span_start1074), "Algorithm") - return result1075 + _t1907 := &pb.Algorithm{Global: relation_ids1073, Body: script1074, Attrs: _t1906} + result1077 := _t1907 + p.recordSpan(int(span_start1076), "Algorithm") + return result1077 } func (p *Parser) parse_script() *pb.Script { - span_start1080 := int64(p.spanStart()) + span_start1082 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("script") - xs1076 := []*pb.Construct{} - cond1077 := p.matchLookaheadLiteral("(", 0) - for cond1077 { - _t1904 := p.parse_construct() - item1078 := _t1904 - xs1076 = append(xs1076, item1078) - cond1077 = p.matchLookaheadLiteral("(", 0) - } - constructs1079 := xs1076 + xs1078 := []*pb.Construct{} + cond1079 := p.matchLookaheadLiteral("(", 0) + for cond1079 { + _t1908 := p.parse_construct() + item1080 := _t1908 + xs1078 = append(xs1078, item1080) + cond1079 = p.matchLookaheadLiteral("(", 0) + } + constructs1081 := xs1078 p.consumeLiteral(")") - _t1905 := &pb.Script{Constructs: constructs1079} - result1081 := _t1905 - p.recordSpan(int(span_start1080), "Script") - return result1081 + _t1909 := &pb.Script{Constructs: constructs1081} + result1083 := _t1909 + p.recordSpan(int(span_start1082), "Script") + return result1083 } func (p *Parser) parse_construct() *pb.Construct { - span_start1085 := int64(p.spanStart()) - var _t1906 int64 + span_start1087 := int64(p.spanStart()) + var _t1910 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1907 int64 + var _t1911 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1907 = 1 + _t1911 = 1 } else { - var _t1908 int64 + var _t1912 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1908 = 1 + _t1912 = 1 } else { - var _t1909 int64 + var _t1913 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1909 = 1 + _t1913 = 1 } else { - var _t1910 int64 + var _t1914 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1910 = 0 + _t1914 = 0 } else { - var _t1911 int64 + var _t1915 int64 if p.matchLookaheadLiteral("break", 1) { - _t1911 = 1 + _t1915 = 1 } else { - var _t1912 int64 + var _t1916 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1912 = 1 + _t1916 = 1 } else { - _t1912 = -1 + _t1916 = -1 } - _t1911 = _t1912 + _t1915 = _t1916 } - _t1910 = _t1911 + _t1914 = _t1915 } - _t1909 = _t1910 + _t1913 = _t1914 } - _t1908 = _t1909 + _t1912 = _t1913 } - _t1907 = _t1908 + _t1911 = _t1912 } - _t1906 = _t1907 + _t1910 = _t1911 } else { - _t1906 = -1 - } - prediction1082 := _t1906 - var _t1913 *pb.Construct - if prediction1082 == 1 { - _t1914 := p.parse_instruction() - instruction1084 := _t1914 - _t1915 := &pb.Construct{} - _t1915.ConstructType = &pb.Construct_Instruction{Instruction: instruction1084} - _t1913 = _t1915 + _t1910 = -1 + } + prediction1084 := _t1910 + var _t1917 *pb.Construct + if prediction1084 == 1 { + _t1918 := p.parse_instruction() + instruction1086 := _t1918 + _t1919 := &pb.Construct{} + _t1919.ConstructType = &pb.Construct_Instruction{Instruction: instruction1086} + _t1917 = _t1919 } else { - var _t1916 *pb.Construct - if prediction1082 == 0 { - _t1917 := p.parse_loop() - loop1083 := _t1917 - _t1918 := &pb.Construct{} - _t1918.ConstructType = &pb.Construct_Loop{Loop: loop1083} - _t1916 = _t1918 + var _t1920 *pb.Construct + if prediction1084 == 0 { + _t1921 := p.parse_loop() + loop1085 := _t1921 + _t1922 := &pb.Construct{} + _t1922.ConstructType = &pb.Construct_Loop{Loop: loop1085} + _t1920 = _t1922 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1913 = _t1916 + _t1917 = _t1920 } - result1086 := _t1913 - p.recordSpan(int(span_start1085), "Construct") - return result1086 + result1088 := _t1917 + p.recordSpan(int(span_start1087), "Construct") + return result1088 } func (p *Parser) parse_loop() *pb.Loop { - span_start1090 := int64(p.spanStart()) + span_start1092 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("loop") - _t1919 := p.parse_init() - init1087 := _t1919 - _t1920 := p.parse_script() - script1088 := _t1920 - var _t1921 []*pb.Attribute + _t1923 := p.parse_init() + init1089 := _t1923 + _t1924 := p.parse_script() + script1090 := _t1924 + var _t1925 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1922 := p.parse_attrs() - _t1921 = _t1922 + _t1926 := p.parse_attrs() + _t1925 = _t1926 } - attrs1089 := _t1921 + attrs1091 := _t1925 p.consumeLiteral(")") - _t1923 := attrs1089 - if attrs1089 == nil { - _t1923 = []*pb.Attribute{} + _t1927 := attrs1091 + if attrs1091 == nil { + _t1927 = []*pb.Attribute{} } - _t1924 := &pb.Loop{Init: init1087, Body: script1088, Attrs: _t1923} - result1091 := _t1924 - p.recordSpan(int(span_start1090), "Loop") - return result1091 + _t1928 := &pb.Loop{Init: init1089, Body: script1090, Attrs: _t1927} + result1093 := _t1928 + p.recordSpan(int(span_start1092), "Loop") + return result1093 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs1092 := []*pb.Instruction{} - cond1093 := p.matchLookaheadLiteral("(", 0) - for cond1093 { - _t1925 := p.parse_instruction() - item1094 := _t1925 - xs1092 = append(xs1092, item1094) - cond1093 = p.matchLookaheadLiteral("(", 0) - } - instructions1095 := xs1092 + xs1094 := []*pb.Instruction{} + cond1095 := p.matchLookaheadLiteral("(", 0) + for cond1095 { + _t1929 := p.parse_instruction() + item1096 := _t1929 + xs1094 = append(xs1094, item1096) + cond1095 = p.matchLookaheadLiteral("(", 0) + } + instructions1097 := xs1094 p.consumeLiteral(")") - return instructions1095 + return instructions1097 } func (p *Parser) parse_instruction() *pb.Instruction { - span_start1102 := int64(p.spanStart()) - var _t1926 int64 + span_start1104 := int64(p.spanStart()) + var _t1930 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1927 int64 + var _t1931 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1927 = 1 + _t1931 = 1 } else { - var _t1928 int64 + var _t1932 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1928 = 4 + _t1932 = 4 } else { - var _t1929 int64 + var _t1933 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1929 = 3 + _t1933 = 3 } else { - var _t1930 int64 + var _t1934 int64 if p.matchLookaheadLiteral("break", 1) { - _t1930 = 2 + _t1934 = 2 } else { - var _t1931 int64 + var _t1935 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1931 = 0 + _t1935 = 0 } else { - _t1931 = -1 + _t1935 = -1 } - _t1930 = _t1931 + _t1934 = _t1935 } - _t1929 = _t1930 + _t1933 = _t1934 } - _t1928 = _t1929 + _t1932 = _t1933 } - _t1927 = _t1928 + _t1931 = _t1932 } - _t1926 = _t1927 + _t1930 = _t1931 } else { - _t1926 = -1 - } - prediction1096 := _t1926 - var _t1932 *pb.Instruction - if prediction1096 == 4 { - _t1933 := p.parse_monus_def() - monus_def1101 := _t1933 - _t1934 := &pb.Instruction{} - _t1934.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1101} - _t1932 = _t1934 + _t1930 = -1 + } + prediction1098 := _t1930 + var _t1936 *pb.Instruction + if prediction1098 == 4 { + _t1937 := p.parse_monus_def() + monus_def1103 := _t1937 + _t1938 := &pb.Instruction{} + _t1938.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1103} + _t1936 = _t1938 } else { - var _t1935 *pb.Instruction - if prediction1096 == 3 { - _t1936 := p.parse_monoid_def() - monoid_def1100 := _t1936 - _t1937 := &pb.Instruction{} - _t1937.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1100} - _t1935 = _t1937 + var _t1939 *pb.Instruction + if prediction1098 == 3 { + _t1940 := p.parse_monoid_def() + monoid_def1102 := _t1940 + _t1941 := &pb.Instruction{} + _t1941.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1102} + _t1939 = _t1941 } else { - var _t1938 *pb.Instruction - if prediction1096 == 2 { - _t1939 := p.parse_break() - break1099 := _t1939 - _t1940 := &pb.Instruction{} - _t1940.InstrType = &pb.Instruction_Break{Break: break1099} - _t1938 = _t1940 + var _t1942 *pb.Instruction + if prediction1098 == 2 { + _t1943 := p.parse_break() + break1101 := _t1943 + _t1944 := &pb.Instruction{} + _t1944.InstrType = &pb.Instruction_Break{Break: break1101} + _t1942 = _t1944 } else { - var _t1941 *pb.Instruction - if prediction1096 == 1 { - _t1942 := p.parse_upsert() - upsert1098 := _t1942 - _t1943 := &pb.Instruction{} - _t1943.InstrType = &pb.Instruction_Upsert{Upsert: upsert1098} - _t1941 = _t1943 + var _t1945 *pb.Instruction + if prediction1098 == 1 { + _t1946 := p.parse_upsert() + upsert1100 := _t1946 + _t1947 := &pb.Instruction{} + _t1947.InstrType = &pb.Instruction_Upsert{Upsert: upsert1100} + _t1945 = _t1947 } else { - var _t1944 *pb.Instruction - if prediction1096 == 0 { - _t1945 := p.parse_assign() - assign1097 := _t1945 - _t1946 := &pb.Instruction{} - _t1946.InstrType = &pb.Instruction_Assign{Assign: assign1097} - _t1944 = _t1946 + var _t1948 *pb.Instruction + if prediction1098 == 0 { + _t1949 := p.parse_assign() + assign1099 := _t1949 + _t1950 := &pb.Instruction{} + _t1950.InstrType = &pb.Instruction_Assign{Assign: assign1099} + _t1948 = _t1950 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1941 = _t1944 + _t1945 = _t1948 } - _t1938 = _t1941 + _t1942 = _t1945 } - _t1935 = _t1938 + _t1939 = _t1942 } - _t1932 = _t1935 + _t1936 = _t1939 } - result1103 := _t1932 - p.recordSpan(int(span_start1102), "Instruction") - return result1103 + result1105 := _t1936 + p.recordSpan(int(span_start1104), "Instruction") + return result1105 } func (p *Parser) parse_assign() *pb.Assign { - span_start1107 := int64(p.spanStart()) + span_start1109 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("assign") - _t1947 := p.parse_relation_id() - relation_id1104 := _t1947 - _t1948 := p.parse_abstraction() - abstraction1105 := _t1948 - var _t1949 []*pb.Attribute + _t1951 := p.parse_relation_id() + relation_id1106 := _t1951 + _t1952 := p.parse_abstraction() + abstraction1107 := _t1952 + var _t1953 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1950 := p.parse_attrs() - _t1949 = _t1950 + _t1954 := p.parse_attrs() + _t1953 = _t1954 } - attrs1106 := _t1949 + attrs1108 := _t1953 p.consumeLiteral(")") - _t1951 := attrs1106 - if attrs1106 == nil { - _t1951 = []*pb.Attribute{} + _t1955 := attrs1108 + if attrs1108 == nil { + _t1955 = []*pb.Attribute{} } - _t1952 := &pb.Assign{Name: relation_id1104, Body: abstraction1105, Attrs: _t1951} - result1108 := _t1952 - p.recordSpan(int(span_start1107), "Assign") - return result1108 + _t1956 := &pb.Assign{Name: relation_id1106, Body: abstraction1107, Attrs: _t1955} + result1110 := _t1956 + p.recordSpan(int(span_start1109), "Assign") + return result1110 } func (p *Parser) parse_upsert() *pb.Upsert { - span_start1112 := int64(p.spanStart()) + span_start1114 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1953 := p.parse_relation_id() - relation_id1109 := _t1953 - _t1954 := p.parse_abstraction_with_arity() - abstraction_with_arity1110 := _t1954 - var _t1955 []*pb.Attribute + _t1957 := p.parse_relation_id() + relation_id1111 := _t1957 + _t1958 := p.parse_abstraction_with_arity() + abstraction_with_arity1112 := _t1958 + var _t1959 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1956 := p.parse_attrs() - _t1955 = _t1956 + _t1960 := p.parse_attrs() + _t1959 = _t1960 } - attrs1111 := _t1955 + attrs1113 := _t1959 p.consumeLiteral(")") - _t1957 := attrs1111 - if attrs1111 == nil { - _t1957 = []*pb.Attribute{} + _t1961 := attrs1113 + if attrs1113 == nil { + _t1961 = []*pb.Attribute{} } - _t1958 := &pb.Upsert{Name: relation_id1109, Body: abstraction_with_arity1110[0].(*pb.Abstraction), Attrs: _t1957, ValueArity: abstraction_with_arity1110[1].(int64)} - result1113 := _t1958 - p.recordSpan(int(span_start1112), "Upsert") - return result1113 + _t1962 := &pb.Upsert{Name: relation_id1111, Body: abstraction_with_arity1112[0].(*pb.Abstraction), Attrs: _t1961, ValueArity: abstraction_with_arity1112[1].(int64)} + result1115 := _t1962 + p.recordSpan(int(span_start1114), "Upsert") + return result1115 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1959 := p.parse_bindings() - bindings1114 := _t1959 - _t1960 := p.parse_formula() - formula1115 := _t1960 + _t1963 := p.parse_bindings() + bindings1116 := _t1963 + _t1964 := p.parse_formula() + formula1117 := _t1964 p.consumeLiteral(")") - _t1961 := &pb.Abstraction{Vars: listConcat(bindings1114[0].([]*pb.Binding), bindings1114[1].([]*pb.Binding)), Value: formula1115} - return []interface{}{_t1961, int64(len(bindings1114[1].([]*pb.Binding)))} + _t1965 := &pb.Abstraction{Vars: listConcat(bindings1116[0].([]*pb.Binding), bindings1116[1].([]*pb.Binding)), Value: formula1117} + return []interface{}{_t1965, int64(len(bindings1116[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { - span_start1119 := int64(p.spanStart()) + span_start1121 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("break") - _t1962 := p.parse_relation_id() - relation_id1116 := _t1962 - _t1963 := p.parse_abstraction() - abstraction1117 := _t1963 - var _t1964 []*pb.Attribute + _t1966 := p.parse_relation_id() + relation_id1118 := _t1966 + _t1967 := p.parse_abstraction() + abstraction1119 := _t1967 + var _t1968 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1965 := p.parse_attrs() - _t1964 = _t1965 + _t1969 := p.parse_attrs() + _t1968 = _t1969 } - attrs1118 := _t1964 + attrs1120 := _t1968 p.consumeLiteral(")") - _t1966 := attrs1118 - if attrs1118 == nil { - _t1966 = []*pb.Attribute{} + _t1970 := attrs1120 + if attrs1120 == nil { + _t1970 = []*pb.Attribute{} } - _t1967 := &pb.Break{Name: relation_id1116, Body: abstraction1117, Attrs: _t1966} - result1120 := _t1967 - p.recordSpan(int(span_start1119), "Break") - return result1120 + _t1971 := &pb.Break{Name: relation_id1118, Body: abstraction1119, Attrs: _t1970} + result1122 := _t1971 + p.recordSpan(int(span_start1121), "Break") + return result1122 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { - span_start1125 := int64(p.spanStart()) + span_start1127 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1968 := p.parse_monoid() - monoid1121 := _t1968 - _t1969 := p.parse_relation_id() - relation_id1122 := _t1969 - _t1970 := p.parse_abstraction_with_arity() - abstraction_with_arity1123 := _t1970 - var _t1971 []*pb.Attribute + _t1972 := p.parse_monoid() + monoid1123 := _t1972 + _t1973 := p.parse_relation_id() + relation_id1124 := _t1973 + _t1974 := p.parse_abstraction_with_arity() + abstraction_with_arity1125 := _t1974 + var _t1975 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1972 := p.parse_attrs() - _t1971 = _t1972 + _t1976 := p.parse_attrs() + _t1975 = _t1976 } - attrs1124 := _t1971 + attrs1126 := _t1975 p.consumeLiteral(")") - _t1973 := attrs1124 - if attrs1124 == nil { - _t1973 = []*pb.Attribute{} + _t1977 := attrs1126 + if attrs1126 == nil { + _t1977 = []*pb.Attribute{} } - _t1974 := &pb.MonoidDef{Monoid: monoid1121, Name: relation_id1122, Body: abstraction_with_arity1123[0].(*pb.Abstraction), Attrs: _t1973, ValueArity: abstraction_with_arity1123[1].(int64)} - result1126 := _t1974 - p.recordSpan(int(span_start1125), "MonoidDef") - return result1126 + _t1978 := &pb.MonoidDef{Monoid: monoid1123, Name: relation_id1124, Body: abstraction_with_arity1125[0].(*pb.Abstraction), Attrs: _t1977, ValueArity: abstraction_with_arity1125[1].(int64)} + result1128 := _t1978 + p.recordSpan(int(span_start1127), "MonoidDef") + return result1128 } func (p *Parser) parse_monoid() *pb.Monoid { - span_start1132 := int64(p.spanStart()) - var _t1975 int64 + span_start1134 := int64(p.spanStart()) + var _t1979 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1976 int64 + var _t1980 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1976 = 3 + _t1980 = 3 } else { - var _t1977 int64 + var _t1981 int64 if p.matchLookaheadLiteral("or", 1) { - _t1977 = 0 + _t1981 = 0 } else { - var _t1978 int64 + var _t1982 int64 if p.matchLookaheadLiteral("min", 1) { - _t1978 = 1 + _t1982 = 1 } else { - var _t1979 int64 + var _t1983 int64 if p.matchLookaheadLiteral("max", 1) { - _t1979 = 2 + _t1983 = 2 } else { - _t1979 = -1 + _t1983 = -1 } - _t1978 = _t1979 + _t1982 = _t1983 } - _t1977 = _t1978 + _t1981 = _t1982 } - _t1976 = _t1977 + _t1980 = _t1981 } - _t1975 = _t1976 + _t1979 = _t1980 } else { - _t1975 = -1 - } - prediction1127 := _t1975 - var _t1980 *pb.Monoid - if prediction1127 == 3 { - _t1981 := p.parse_sum_monoid() - sum_monoid1131 := _t1981 - _t1982 := &pb.Monoid{} - _t1982.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1131} - _t1980 = _t1982 + _t1979 = -1 + } + prediction1129 := _t1979 + var _t1984 *pb.Monoid + if prediction1129 == 3 { + _t1985 := p.parse_sum_monoid() + sum_monoid1133 := _t1985 + _t1986 := &pb.Monoid{} + _t1986.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1133} + _t1984 = _t1986 } else { - var _t1983 *pb.Monoid - if prediction1127 == 2 { - _t1984 := p.parse_max_monoid() - max_monoid1130 := _t1984 - _t1985 := &pb.Monoid{} - _t1985.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1130} - _t1983 = _t1985 + var _t1987 *pb.Monoid + if prediction1129 == 2 { + _t1988 := p.parse_max_monoid() + max_monoid1132 := _t1988 + _t1989 := &pb.Monoid{} + _t1989.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1132} + _t1987 = _t1989 } else { - var _t1986 *pb.Monoid - if prediction1127 == 1 { - _t1987 := p.parse_min_monoid() - min_monoid1129 := _t1987 - _t1988 := &pb.Monoid{} - _t1988.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1129} - _t1986 = _t1988 + var _t1990 *pb.Monoid + if prediction1129 == 1 { + _t1991 := p.parse_min_monoid() + min_monoid1131 := _t1991 + _t1992 := &pb.Monoid{} + _t1992.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1131} + _t1990 = _t1992 } else { - var _t1989 *pb.Monoid - if prediction1127 == 0 { - _t1990 := p.parse_or_monoid() - or_monoid1128 := _t1990 - _t1991 := &pb.Monoid{} - _t1991.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1128} - _t1989 = _t1991 + var _t1993 *pb.Monoid + if prediction1129 == 0 { + _t1994 := p.parse_or_monoid() + or_monoid1130 := _t1994 + _t1995 := &pb.Monoid{} + _t1995.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1130} + _t1993 = _t1995 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1986 = _t1989 + _t1990 = _t1993 } - _t1983 = _t1986 + _t1987 = _t1990 } - _t1980 = _t1983 + _t1984 = _t1987 } - result1133 := _t1980 - p.recordSpan(int(span_start1132), "Monoid") - return result1133 + result1135 := _t1984 + p.recordSpan(int(span_start1134), "Monoid") + return result1135 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { - span_start1134 := int64(p.spanStart()) + span_start1136 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1992 := &pb.OrMonoid{} - result1135 := _t1992 - p.recordSpan(int(span_start1134), "OrMonoid") - return result1135 + _t1996 := &pb.OrMonoid{} + result1137 := _t1996 + p.recordSpan(int(span_start1136), "OrMonoid") + return result1137 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { - span_start1137 := int64(p.spanStart()) + span_start1139 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("min") - _t1993 := p.parse_type() - type1136 := _t1993 + _t1997 := p.parse_type() + type1138 := _t1997 p.consumeLiteral(")") - _t1994 := &pb.MinMonoid{Type: type1136} - result1138 := _t1994 - p.recordSpan(int(span_start1137), "MinMonoid") - return result1138 + _t1998 := &pb.MinMonoid{Type: type1138} + result1140 := _t1998 + p.recordSpan(int(span_start1139), "MinMonoid") + return result1140 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { - span_start1140 := int64(p.spanStart()) + span_start1142 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("max") - _t1995 := p.parse_type() - type1139 := _t1995 + _t1999 := p.parse_type() + type1141 := _t1999 p.consumeLiteral(")") - _t1996 := &pb.MaxMonoid{Type: type1139} - result1141 := _t1996 - p.recordSpan(int(span_start1140), "MaxMonoid") - return result1141 + _t2000 := &pb.MaxMonoid{Type: type1141} + result1143 := _t2000 + p.recordSpan(int(span_start1142), "MaxMonoid") + return result1143 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { - span_start1143 := int64(p.spanStart()) + span_start1145 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sum") - _t1997 := p.parse_type() - type1142 := _t1997 + _t2001 := p.parse_type() + type1144 := _t2001 p.consumeLiteral(")") - _t1998 := &pb.SumMonoid{Type: type1142} - result1144 := _t1998 - p.recordSpan(int(span_start1143), "SumMonoid") - return result1144 + _t2002 := &pb.SumMonoid{Type: type1144} + result1146 := _t2002 + p.recordSpan(int(span_start1145), "SumMonoid") + return result1146 } func (p *Parser) parse_monus_def() *pb.MonusDef { - span_start1149 := int64(p.spanStart()) + span_start1151 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monus") - _t1999 := p.parse_monoid() - monoid1145 := _t1999 - _t2000 := p.parse_relation_id() - relation_id1146 := _t2000 - _t2001 := p.parse_abstraction_with_arity() - abstraction_with_arity1147 := _t2001 - var _t2002 []*pb.Attribute + _t2003 := p.parse_monoid() + monoid1147 := _t2003 + _t2004 := p.parse_relation_id() + relation_id1148 := _t2004 + _t2005 := p.parse_abstraction_with_arity() + abstraction_with_arity1149 := _t2005 + var _t2006 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t2003 := p.parse_attrs() - _t2002 = _t2003 + _t2007 := p.parse_attrs() + _t2006 = _t2007 } - attrs1148 := _t2002 + attrs1150 := _t2006 p.consumeLiteral(")") - _t2004 := attrs1148 - if attrs1148 == nil { - _t2004 = []*pb.Attribute{} + _t2008 := attrs1150 + if attrs1150 == nil { + _t2008 = []*pb.Attribute{} } - _t2005 := &pb.MonusDef{Monoid: monoid1145, Name: relation_id1146, Body: abstraction_with_arity1147[0].(*pb.Abstraction), Attrs: _t2004, ValueArity: abstraction_with_arity1147[1].(int64)} - result1150 := _t2005 - p.recordSpan(int(span_start1149), "MonusDef") - return result1150 + _t2009 := &pb.MonusDef{Monoid: monoid1147, Name: relation_id1148, Body: abstraction_with_arity1149[0].(*pb.Abstraction), Attrs: _t2008, ValueArity: abstraction_with_arity1149[1].(int64)} + result1152 := _t2009 + p.recordSpan(int(span_start1151), "MonusDef") + return result1152 } func (p *Parser) parse_constraint() *pb.Constraint { - span_start1155 := int64(p.spanStart()) + span_start1157 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t2006 := p.parse_relation_id() - relation_id1151 := _t2006 - _t2007 := p.parse_abstraction() - abstraction1152 := _t2007 - _t2008 := p.parse_functional_dependency_keys() - functional_dependency_keys1153 := _t2008 - _t2009 := p.parse_functional_dependency_values() - functional_dependency_values1154 := _t2009 + _t2010 := p.parse_relation_id() + relation_id1153 := _t2010 + _t2011 := p.parse_abstraction() + abstraction1154 := _t2011 + _t2012 := p.parse_functional_dependency_keys() + functional_dependency_keys1155 := _t2012 + _t2013 := p.parse_functional_dependency_values() + functional_dependency_values1156 := _t2013 p.consumeLiteral(")") - _t2010 := &pb.FunctionalDependency{Guard: abstraction1152, Keys: functional_dependency_keys1153, Values: functional_dependency_values1154} - _t2011 := &pb.Constraint{Name: relation_id1151} - _t2011.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t2010} - result1156 := _t2011 - p.recordSpan(int(span_start1155), "Constraint") - return result1156 + _t2014 := &pb.FunctionalDependency{Guard: abstraction1154, Keys: functional_dependency_keys1155, Values: functional_dependency_values1156} + _t2015 := &pb.Constraint{Name: relation_id1153} + _t2015.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t2014} + result1158 := _t2015 + p.recordSpan(int(span_start1157), "Constraint") + return result1158 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1157 := []*pb.Var{} - cond1158 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1158 { - _t2012 := p.parse_var() - item1159 := _t2012 - xs1157 = append(xs1157, item1159) - cond1158 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1160 := xs1157 + xs1159 := []*pb.Var{} + cond1160 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1160 { + _t2016 := p.parse_var() + item1161 := _t2016 + xs1159 = append(xs1159, item1161) + cond1160 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1162 := xs1159 p.consumeLiteral(")") - return vars1160 + return vars1162 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - xs1161 := []*pb.Var{} - cond1162 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1162 { - _t2013 := p.parse_var() - item1163 := _t2013 - xs1161 = append(xs1161, item1163) - cond1162 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1164 := xs1161 + xs1163 := []*pb.Var{} + cond1164 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1164 { + _t2017 := p.parse_var() + item1165 := _t2017 + xs1163 = append(xs1163, item1165) + cond1164 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1166 := xs1163 p.consumeLiteral(")") - return vars1164 + return vars1166 } func (p *Parser) parse_data() *pb.Data { - span_start1170 := int64(p.spanStart()) - var _t2014 int64 + span_start1172 := int64(p.spanStart()) + var _t2018 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2015 int64 + var _t2019 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t2015 = 3 + _t2019 = 3 } else { - var _t2016 int64 + var _t2020 int64 if p.matchLookaheadLiteral("edb", 1) { - _t2016 = 0 + _t2020 = 0 } else { - var _t2017 int64 + var _t2021 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t2017 = 2 + _t2021 = 2 } else { - var _t2018 int64 + var _t2022 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t2018 = 1 + _t2022 = 1 } else { - _t2018 = -1 + _t2022 = -1 } - _t2017 = _t2018 + _t2021 = _t2022 } - _t2016 = _t2017 + _t2020 = _t2021 } - _t2015 = _t2016 + _t2019 = _t2020 } - _t2014 = _t2015 + _t2018 = _t2019 } else { - _t2014 = -1 - } - prediction1165 := _t2014 - var _t2019 *pb.Data - if prediction1165 == 3 { - _t2020 := p.parse_iceberg_data() - iceberg_data1169 := _t2020 - _t2021 := &pb.Data{} - _t2021.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1169} - _t2019 = _t2021 + _t2018 = -1 + } + prediction1167 := _t2018 + var _t2023 *pb.Data + if prediction1167 == 3 { + _t2024 := p.parse_iceberg_data() + iceberg_data1171 := _t2024 + _t2025 := &pb.Data{} + _t2025.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1171} + _t2023 = _t2025 } else { - var _t2022 *pb.Data - if prediction1165 == 2 { - _t2023 := p.parse_csv_data() - csv_data1168 := _t2023 - _t2024 := &pb.Data{} - _t2024.DataType = &pb.Data_CsvData{CsvData: csv_data1168} - _t2022 = _t2024 + var _t2026 *pb.Data + if prediction1167 == 2 { + _t2027 := p.parse_csv_data() + csv_data1170 := _t2027 + _t2028 := &pb.Data{} + _t2028.DataType = &pb.Data_CsvData{CsvData: csv_data1170} + _t2026 = _t2028 } else { - var _t2025 *pb.Data - if prediction1165 == 1 { - _t2026 := p.parse_betree_relation() - betree_relation1167 := _t2026 - _t2027 := &pb.Data{} - _t2027.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1167} - _t2025 = _t2027 + var _t2029 *pb.Data + if prediction1167 == 1 { + _t2030 := p.parse_betree_relation() + betree_relation1169 := _t2030 + _t2031 := &pb.Data{} + _t2031.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1169} + _t2029 = _t2031 } else { - var _t2028 *pb.Data - if prediction1165 == 0 { - _t2029 := p.parse_edb() - edb1166 := _t2029 - _t2030 := &pb.Data{} - _t2030.DataType = &pb.Data_Edb{Edb: edb1166} - _t2028 = _t2030 + var _t2032 *pb.Data + if prediction1167 == 0 { + _t2033 := p.parse_edb() + edb1168 := _t2033 + _t2034 := &pb.Data{} + _t2034.DataType = &pb.Data_Edb{Edb: edb1168} + _t2032 = _t2034 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2025 = _t2028 + _t2029 = _t2032 } - _t2022 = _t2025 + _t2026 = _t2029 } - _t2019 = _t2022 + _t2023 = _t2026 } - result1171 := _t2019 - p.recordSpan(int(span_start1170), "Data") - return result1171 + result1173 := _t2023 + p.recordSpan(int(span_start1172), "Data") + return result1173 } func (p *Parser) parse_edb() *pb.EDB { - span_start1175 := int64(p.spanStart()) + span_start1177 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("edb") - _t2031 := p.parse_relation_id() - relation_id1172 := _t2031 - _t2032 := p.parse_edb_path() - edb_path1173 := _t2032 - _t2033 := p.parse_edb_types() - edb_types1174 := _t2033 + _t2035 := p.parse_relation_id() + relation_id1174 := _t2035 + _t2036 := p.parse_edb_path() + edb_path1175 := _t2036 + _t2037 := p.parse_edb_types() + edb_types1176 := _t2037 p.consumeLiteral(")") - _t2034 := &pb.EDB{TargetId: relation_id1172, Path: edb_path1173, Types: edb_types1174} - result1176 := _t2034 - p.recordSpan(int(span_start1175), "EDB") - return result1176 + _t2038 := &pb.EDB{TargetId: relation_id1174, Path: edb_path1175, Types: edb_types1176} + result1178 := _t2038 + p.recordSpan(int(span_start1177), "EDB") + return result1178 } func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") - xs1177 := []string{} - cond1178 := p.matchLookaheadTerminal("STRING", 0) - for cond1178 { - item1179 := p.consumeTerminal("STRING").Value.str - xs1177 = append(xs1177, item1179) - cond1178 = p.matchLookaheadTerminal("STRING", 0) - } - strings1180 := xs1177 + xs1179 := []string{} + cond1180 := p.matchLookaheadTerminal("STRING", 0) + for cond1180 { + item1181 := p.consumeTerminal("STRING").Value.str + xs1179 = append(xs1179, item1181) + cond1180 = p.matchLookaheadTerminal("STRING", 0) + } + strings1182 := xs1179 p.consumeLiteral("]") - return strings1180 + return strings1182 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - xs1181 := []*pb.Type{} - cond1182 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1182 { - _t2035 := p.parse_type() - item1183 := _t2035 - xs1181 = append(xs1181, item1183) - cond1182 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1184 := xs1181 + xs1183 := []*pb.Type{} + cond1184 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1184 { + _t2039 := p.parse_type() + item1185 := _t2039 + xs1183 = append(xs1183, item1185) + cond1184 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1186 := xs1183 p.consumeLiteral("]") - return types1184 + return types1186 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { - span_start1187 := int64(p.spanStart()) + span_start1189 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t2036 := p.parse_relation_id() - relation_id1185 := _t2036 - _t2037 := p.parse_betree_info() - betree_info1186 := _t2037 + _t2040 := p.parse_relation_id() + relation_id1187 := _t2040 + _t2041 := p.parse_betree_info() + betree_info1188 := _t2041 p.consumeLiteral(")") - _t2038 := &pb.BeTreeRelation{Name: relation_id1185, RelationInfo: betree_info1186} - result1188 := _t2038 - p.recordSpan(int(span_start1187), "BeTreeRelation") - return result1188 + _t2042 := &pb.BeTreeRelation{Name: relation_id1187, RelationInfo: betree_info1188} + result1190 := _t2042 + p.recordSpan(int(span_start1189), "BeTreeRelation") + return result1190 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { - span_start1192 := int64(p.spanStart()) + span_start1194 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t2039 := p.parse_betree_info_key_types() - betree_info_key_types1189 := _t2039 - _t2040 := p.parse_betree_info_value_types() - betree_info_value_types1190 := _t2040 - _t2041 := p.parse_config_dict() - config_dict1191 := _t2041 + _t2043 := p.parse_betree_info_key_types() + betree_info_key_types1191 := _t2043 + _t2044 := p.parse_betree_info_value_types() + betree_info_value_types1192 := _t2044 + _t2045 := p.parse_config_dict() + config_dict1193 := _t2045 p.consumeLiteral(")") - _t2042 := p.construct_betree_info(betree_info_key_types1189, betree_info_value_types1190, config_dict1191) - result1193 := _t2042 - p.recordSpan(int(span_start1192), "BeTreeInfo") - return result1193 + _t2046 := p.construct_betree_info(betree_info_key_types1191, betree_info_value_types1192, config_dict1193) + result1195 := _t2046 + p.recordSpan(int(span_start1194), "BeTreeInfo") + return result1195 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs1194 := []*pb.Type{} - cond1195 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1195 { - _t2043 := p.parse_type() - item1196 := _t2043 - xs1194 = append(xs1194, item1196) - cond1195 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1197 := xs1194 + xs1196 := []*pb.Type{} + cond1197 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1197 { + _t2047 := p.parse_type() + item1198 := _t2047 + xs1196 = append(xs1196, item1198) + cond1197 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1199 := xs1196 p.consumeLiteral(")") - return types1197 + return types1199 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - xs1198 := []*pb.Type{} - cond1199 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1199 { - _t2044 := p.parse_type() - item1200 := _t2044 - xs1198 = append(xs1198, item1200) - cond1199 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1201 := xs1198 + xs1200 := []*pb.Type{} + cond1201 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1201 { + _t2048 := p.parse_type() + item1202 := _t2048 + xs1200 = append(xs1200, item1202) + cond1201 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1203 := xs1200 p.consumeLiteral(")") - return types1201 + return types1203 } func (p *Parser) parse_csv_data() *pb.CSVData { - span_start1207 := int64(p.spanStart()) + span_start1209 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t2045 := p.parse_csvlocator() - csvlocator1202 := _t2045 - _t2046 := p.parse_csv_config() - csv_config1203 := _t2046 - var _t2047 []*pb.GNFColumn + _t2049 := p.parse_csvlocator() + csvlocator1204 := _t2049 + _t2050 := p.parse_csv_config() + csv_config1205 := _t2050 + var _t2051 []*pb.GNFColumn if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("columns", 1)) { - _t2048 := p.parse_gnf_columns() - _t2047 = _t2048 + _t2052 := p.parse_gnf_columns() + _t2051 = _t2052 } - gnf_columns1204 := _t2047 - var _t2049 *pb.TargetRelations + gnf_columns1206 := _t2051 + var _t2053 *pb.TargetRelations if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("relations", 1)) { - _t2050 := p.parse_target_relations() - _t2049 = _t2050 + _t2054 := p.parse_target_relations() + _t2053 = _t2054 } - target_relations1205 := _t2049 - _t2051 := p.parse_csv_asof() - csv_asof1206 := _t2051 + target_relations1207 := _t2053 + _t2055 := p.parse_csv_asof() + csv_asof1208 := _t2055 p.consumeLiteral(")") - _t2052 := p.construct_csv_data(csvlocator1202, csv_config1203, gnf_columns1204, target_relations1205, csv_asof1206) - result1208 := _t2052 - p.recordSpan(int(span_start1207), "CSVData") - return result1208 + _t2056 := p.construct_csv_data(csvlocator1204, csv_config1205, gnf_columns1206, target_relations1207, csv_asof1208) + result1210 := _t2056 + p.recordSpan(int(span_start1209), "CSVData") + return result1210 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { - span_start1211 := int64(p.spanStart()) + span_start1213 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t2053 []string + var _t2057 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t2054 := p.parse_csv_locator_paths() - _t2053 = _t2054 + _t2058 := p.parse_csv_locator_paths() + _t2057 = _t2058 } - csv_locator_paths1209 := _t2053 - var _t2055 *string + csv_locator_paths1211 := _t2057 + var _t2059 *string if p.matchLookaheadLiteral("(", 0) { - _t2056 := p.parse_csv_locator_inline_data() - _t2055 = ptr(_t2056) + _t2060 := p.parse_csv_locator_inline_data() + _t2059 = ptr(_t2060) } - csv_locator_inline_data1210 := _t2055 + csv_locator_inline_data1212 := _t2059 p.consumeLiteral(")") - _t2057 := csv_locator_paths1209 - if csv_locator_paths1209 == nil { - _t2057 = []string{} + _t2061 := csv_locator_paths1211 + if csv_locator_paths1211 == nil { + _t2061 = []string{} } - _t2058 := &pb.CSVLocator{Paths: _t2057, InlineData: []byte(deref(csv_locator_inline_data1210, ""))} - result1212 := _t2058 - p.recordSpan(int(span_start1211), "CSVLocator") - return result1212 + _t2062 := &pb.CSVLocator{Paths: _t2061, InlineData: []byte(deref(csv_locator_inline_data1212, ""))} + result1214 := _t2062 + p.recordSpan(int(span_start1213), "CSVLocator") + return result1214 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs1213 := []string{} - cond1214 := p.matchLookaheadTerminal("STRING", 0) - for cond1214 { - item1215 := p.consumeTerminal("STRING").Value.str - xs1213 = append(xs1213, item1215) - cond1214 = p.matchLookaheadTerminal("STRING", 0) - } - strings1216 := xs1213 + xs1215 := []string{} + cond1216 := p.matchLookaheadTerminal("STRING", 0) + for cond1216 { + item1217 := p.consumeTerminal("STRING").Value.str + xs1215 = append(xs1215, item1217) + cond1216 = p.matchLookaheadTerminal("STRING", 0) + } + strings1218 := xs1215 p.consumeLiteral(")") - return strings1216 + return strings1218 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - formatted_string1217 := p.consumeTerminal("STRING").Value.str + formatted_string1219 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return formatted_string1217 + return formatted_string1219 } func (p *Parser) parse_csv_config() *pb.CSVConfig { - span_start1220 := int64(p.spanStart()) + span_start1222 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t2059 := p.parse_config_dict() - config_dict1218 := _t2059 - var _t2060 [][]interface{} + _t2063 := p.parse_config_dict() + config_dict1220 := _t2063 + var _t2064 [][]interface{} if p.matchLookaheadLiteral("(", 0) { - _t2061 := p.parse__storage_integration() - _t2060 = _t2061 + _t2065 := p.parse__storage_integration() + _t2064 = _t2065 } - _storage_integration1219 := _t2060 + _storage_integration1221 := _t2064 p.consumeLiteral(")") - _t2062 := p.construct_csv_config(config_dict1218, _storage_integration1219) - result1221 := _t2062 - p.recordSpan(int(span_start1220), "CSVConfig") - return result1221 + _t2066 := p.construct_csv_config(config_dict1220, _storage_integration1221) + result1223 := _t2066 + p.recordSpan(int(span_start1222), "CSVConfig") + return result1223 } func (p *Parser) parse__storage_integration() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("storage_integration") - _t2063 := p.parse_config_dict() - config_dict1222 := _t2063 + _t2067 := p.parse_config_dict() + config_dict1224 := _t2067 p.consumeLiteral(")") - return config_dict1222 + return config_dict1224 } func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1223 := []*pb.GNFColumn{} - cond1224 := p.matchLookaheadLiteral("(", 0) - for cond1224 { - _t2064 := p.parse_gnf_column() - item1225 := _t2064 - xs1223 = append(xs1223, item1225) - cond1224 = p.matchLookaheadLiteral("(", 0) - } - gnf_columns1226 := xs1223 + xs1225 := []*pb.GNFColumn{} + cond1226 := p.matchLookaheadLiteral("(", 0) + for cond1226 { + _t2068 := p.parse_gnf_column() + item1227 := _t2068 + xs1225 = append(xs1225, item1227) + cond1226 = p.matchLookaheadLiteral("(", 0) + } + gnf_columns1228 := xs1225 p.consumeLiteral(")") - return gnf_columns1226 + return gnf_columns1228 } func (p *Parser) parse_gnf_column() *pb.GNFColumn { - span_start1233 := int64(p.spanStart()) + span_start1235 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - _t2065 := p.parse_gnf_column_path() - gnf_column_path1227 := _t2065 - var _t2066 *pb.RelationId + _t2069 := p.parse_gnf_column_path() + gnf_column_path1229 := _t2069 + var _t2070 *pb.RelationId if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t2067 := p.parse_relation_id() - _t2066 = _t2067 + _t2071 := p.parse_relation_id() + _t2070 = _t2071 } - relation_id1228 := _t2066 + relation_id1230 := _t2070 p.consumeLiteral("[") - xs1229 := []*pb.Type{} - cond1230 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1230 { - _t2068 := p.parse_type() - item1231 := _t2068 - xs1229 = append(xs1229, item1231) - cond1230 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1232 := xs1229 + xs1231 := []*pb.Type{} + cond1232 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1232 { + _t2072 := p.parse_type() + item1233 := _t2072 + xs1231 = append(xs1231, item1233) + cond1232 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1234 := xs1231 p.consumeLiteral("]") p.consumeLiteral(")") - _t2069 := &pb.GNFColumn{ColumnPath: gnf_column_path1227, TargetId: relation_id1228, Types: types1232} - result1234 := _t2069 - p.recordSpan(int(span_start1233), "GNFColumn") - return result1234 + _t2073 := &pb.GNFColumn{ColumnPath: gnf_column_path1229, TargetId: relation_id1230, Types: types1234} + result1236 := _t2073 + p.recordSpan(int(span_start1235), "GNFColumn") + return result1236 } func (p *Parser) parse_gnf_column_path() []string { - var _t2070 int64 + var _t2074 int64 if p.matchLookaheadLiteral("[", 0) { - _t2070 = 1 + _t2074 = 1 } else { - var _t2071 int64 + var _t2075 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t2071 = 0 + _t2075 = 0 } else { - _t2071 = -1 + _t2075 = -1 } - _t2070 = _t2071 + _t2074 = _t2075 } - prediction1235 := _t2070 - var _t2072 []string - if prediction1235 == 1 { + prediction1237 := _t2074 + var _t2076 []string + if prediction1237 == 1 { p.consumeLiteral("[") - xs1237 := []string{} - cond1238 := p.matchLookaheadTerminal("STRING", 0) - for cond1238 { - item1239 := p.consumeTerminal("STRING").Value.str - xs1237 = append(xs1237, item1239) - cond1238 = p.matchLookaheadTerminal("STRING", 0) + xs1239 := []string{} + cond1240 := p.matchLookaheadTerminal("STRING", 0) + for cond1240 { + item1241 := p.consumeTerminal("STRING").Value.str + xs1239 = append(xs1239, item1241) + cond1240 = p.matchLookaheadTerminal("STRING", 0) } - strings1240 := xs1237 + strings1242 := xs1239 p.consumeLiteral("]") - _t2072 = strings1240 + _t2076 = strings1242 } else { - var _t2073 []string - if prediction1235 == 0 { - string1236 := p.consumeTerminal("STRING").Value.str - _ = string1236 - _t2073 = []string{string1236} + var _t2077 []string + if prediction1237 == 0 { + string1238 := p.consumeTerminal("STRING").Value.str + _ = string1238 + _t2077 = []string{string1238} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2072 = _t2073 + _t2076 = _t2077 } - return _t2072 + return _t2076 } func (p *Parser) parse_target_relations() *pb.TargetRelations { - span_start1243 := int64(p.spanStart()) + span_start1245 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relations") - _t2074 := p.parse_relation_keys() - relation_keys1241 := _t2074 - _t2075 := p.parse_relation_body() - relation_body1242 := _t2075 + _t2078 := p.parse_relation_keys() + relation_keys1243 := _t2078 + _t2079 := p.parse_relation_body() + relation_body1244 := _t2079 p.consumeLiteral(")") - _t2076 := p.construct_relations(relation_keys1241, relation_body1242) - result1244 := _t2076 - p.recordSpan(int(span_start1243), "TargetRelations") - return result1244 + _t2080 := p.construct_relations(relation_keys1243, relation_body1244) + result1246 := _t2080 + p.recordSpan(int(span_start1245), "TargetRelations") + return result1246 } -func (p *Parser) parse_relation_keys() []*pb.NamedColumn { - p.consumeLiteral("(") - p.consumeLiteral("keys") - xs1245 := []*pb.NamedColumn{} - cond1246 := p.matchLookaheadLiteral("(", 0) - for cond1246 { - _t2077 := p.parse_named_column() - item1247 := _t2077 - xs1245 = append(xs1245, item1247) - cond1246 = p.matchLookaheadLiteral("(", 0) - } - named_columns1248 := xs1245 - p.consumeLiteral(")") - return named_columns1248 +func (p *Parser) parse_relation_keys() []interface{} { + var _t2081 int64 + if p.matchLookaheadLiteral("(", 0) { + var _t2082 int64 + if p.matchLookaheadLiteral("keys", 1) { + var _t2083 int64 + if p.matchLookaheadLiteral(":", 2) { + _t2083 = 1 + } else { + var _t2084 int64 + if p.matchLookaheadLiteral(")", 2) { + _t2084 = 0 + } else { + var _t2085 int64 + if p.matchLookaheadLiteral("(", 2) { + _t2085 = 0 + } else { + _t2085 = -1 + } + _t2084 = _t2085 + } + _t2083 = _t2084 + } + _t2082 = _t2083 + } else { + _t2082 = -1 + } + _t2081 = _t2082 + } else { + _t2081 = -1 + } + prediction1247 := _t2081 + var _t2086 []interface{} + if prediction1247 == 1 { + p.consumeLiteral("(") + p.consumeLiteral("keys") + p.consumeLiteral(":") + symbol1252 := p.consumeTerminal("SYMBOL").Value.str + p.consumeLiteral(")") + _t2087 := p.construct_synthetic_keys(symbol1252) + _t2086 = _t2087 + } else { + var _t2088 []interface{} + if prediction1247 == 0 { + p.consumeLiteral("(") + p.consumeLiteral("keys") + xs1248 := []*pb.NamedColumn{} + cond1249 := p.matchLookaheadLiteral("(", 0) + for cond1249 { + _t2089 := p.parse_named_column() + item1250 := _t2089 + xs1248 = append(xs1248, item1250) + cond1249 = p.matchLookaheadLiteral("(", 0) + } + named_columns1251 := xs1248 + p.consumeLiteral(")") + _t2088 = []interface{}{named_columns1251, false} + } else { + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_keys", p.lookahead(0).Type, p.lookahead(0).Value)}) + } + _t2086 = _t2088 + } + return _t2086 } func (p *Parser) parse_named_column() *pb.NamedColumn { - span_start1251 := int64(p.spanStart()) + span_start1255 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1249 := p.consumeTerminal("STRING").Value.str - _t2078 := p.parse_type() - type1250 := _t2078 + string1253 := p.consumeTerminal("STRING").Value.str + _t2090 := p.parse_type() + type1254 := _t2090 p.consumeLiteral(")") - _t2079 := &pb.NamedColumn{Name: string1249, Type: type1250} - result1252 := _t2079 - p.recordSpan(int(span_start1251), "NamedColumn") - return result1252 + _t2091 := &pb.NamedColumn{Name: string1253, Type: type1254} + result1256 := _t2091 + p.recordSpan(int(span_start1255), "NamedColumn") + return result1256 } func (p *Parser) parse_relation_body() *pb.TargetRelations { - span_start1257 := int64(p.spanStart()) - var _t2080 int64 + span_start1261 := int64(p.spanStart()) + var _t2092 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2081 int64 + var _t2093 int64 if p.matchLookaheadLiteral("relation", 1) { - _t2081 = 0 + _t2093 = 0 } else { - var _t2082 int64 + var _t2094 int64 if p.matchLookaheadLiteral("inserts", 1) { - _t2082 = 1 + _t2094 = 1 } else { - _t2082 = 0 + _t2094 = 0 } - _t2081 = _t2082 + _t2093 = _t2094 } - _t2080 = _t2081 + _t2092 = _t2093 } else { - _t2080 = 0 - } - prediction1253 := _t2080 - var _t2083 *pb.TargetRelations - if prediction1253 == 1 { - _t2084 := p.parse_cdc_inserts() - cdc_inserts1255 := _t2084 - _t2085 := p.parse_cdc_deletes() - cdc_deletes1256 := _t2085 - _t2086 := p.construct_cdc_relations(cdc_inserts1255, cdc_deletes1256) - _t2083 = _t2086 + _t2092 = 0 + } + prediction1257 := _t2092 + var _t2095 *pb.TargetRelations + if prediction1257 == 1 { + _t2096 := p.parse_cdc_inserts() + cdc_inserts1259 := _t2096 + _t2097 := p.parse_cdc_deletes() + cdc_deletes1260 := _t2097 + _t2098 := p.construct_cdc_relations(cdc_inserts1259, cdc_deletes1260) + _t2095 = _t2098 } else { - var _t2087 *pb.TargetRelations - if prediction1253 == 0 { - _t2088 := p.parse_non_cdc_relations() - non_cdc_relations1254 := _t2088 - _t2089 := p.construct_non_cdc_relations(non_cdc_relations1254) - _t2087 = _t2089 + var _t2099 *pb.TargetRelations + if prediction1257 == 0 { + _t2100 := p.parse_non_cdc_relations() + non_cdc_relations1258 := _t2100 + _t2101 := p.construct_non_cdc_relations(non_cdc_relations1258) + _t2099 = _t2101 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_body", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2083 = _t2087 + _t2095 = _t2099 } - result1258 := _t2083 - p.recordSpan(int(span_start1257), "TargetRelations") - return result1258 + result1262 := _t2095 + p.recordSpan(int(span_start1261), "TargetRelations") + return result1262 } func (p *Parser) parse_non_cdc_relations() []*pb.TargetRelation { - xs1259 := []*pb.TargetRelation{} - cond1260 := p.matchLookaheadLiteral("(", 0) - for cond1260 { - _t2090 := p.parse_target_relation() - item1261 := _t2090 - xs1259 = append(xs1259, item1261) - cond1260 = p.matchLookaheadLiteral("(", 0) - } - return xs1259 -} - -func (p *Parser) parse_target_relation() *pb.TargetRelation { - span_start1267 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("relation") - _t2091 := p.parse_relation_id() - relation_id1262 := _t2091 - xs1263 := []*pb.NamedColumn{} + xs1263 := []*pb.TargetRelation{} cond1264 := p.matchLookaheadLiteral("(", 0) for cond1264 { - _t2092 := p.parse_named_column() - item1265 := _t2092 + _t2102 := p.parse_target_relation() + item1265 := _t2102 xs1263 = append(xs1263, item1265) cond1264 = p.matchLookaheadLiteral("(", 0) } - named_columns1266 := xs1263 - p.consumeLiteral(")") - _t2093 := &pb.TargetRelation{TargetId: relation_id1262, Values: named_columns1266} - result1268 := _t2093 - p.recordSpan(int(span_start1267), "TargetRelation") - return result1268 + return xs1263 } -func (p *Parser) parse_cdc_inserts() []*pb.TargetRelation { +func (p *Parser) parse_target_relation() *pb.TargetRelation { + span_start1271 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("inserts") - xs1269 := []*pb.TargetRelation{} - cond1270 := p.matchLookaheadLiteral("(", 0) - for cond1270 { - _t2094 := p.parse_target_relation() - item1271 := _t2094 - xs1269 = append(xs1269, item1271) - cond1270 = p.matchLookaheadLiteral("(", 0) - } - target_relations1272 := xs1269 + p.consumeLiteral("relation") + _t2103 := p.parse_relation_id() + relation_id1266 := _t2103 + xs1267 := []*pb.NamedColumn{} + cond1268 := p.matchLookaheadLiteral("(", 0) + for cond1268 { + _t2104 := p.parse_named_column() + item1269 := _t2104 + xs1267 = append(xs1267, item1269) + cond1268 = p.matchLookaheadLiteral("(", 0) + } + named_columns1270 := xs1267 p.consumeLiteral(")") - return target_relations1272 + _t2105 := &pb.TargetRelation{TargetId: relation_id1266, Values: named_columns1270} + result1272 := _t2105 + p.recordSpan(int(span_start1271), "TargetRelation") + return result1272 } -func (p *Parser) parse_cdc_deletes() []*pb.TargetRelation { +func (p *Parser) parse_cdc_inserts() []*pb.TargetRelation { p.consumeLiteral("(") - p.consumeLiteral("deletes") + p.consumeLiteral("inserts") xs1273 := []*pb.TargetRelation{} cond1274 := p.matchLookaheadLiteral("(", 0) for cond1274 { - _t2095 := p.parse_target_relation() - item1275 := _t2095 + _t2106 := p.parse_target_relation() + item1275 := _t2106 xs1273 = append(xs1273, item1275) cond1274 = p.matchLookaheadLiteral("(", 0) } @@ -4620,746 +4662,762 @@ func (p *Parser) parse_cdc_deletes() []*pb.TargetRelation { return target_relations1276 } +func (p *Parser) parse_cdc_deletes() []*pb.TargetRelation { + p.consumeLiteral("(") + p.consumeLiteral("deletes") + xs1277 := []*pb.TargetRelation{} + cond1278 := p.matchLookaheadLiteral("(", 0) + for cond1278 { + _t2107 := p.parse_target_relation() + item1279 := _t2107 + xs1277 = append(xs1277, item1279) + cond1278 = p.matchLookaheadLiteral("(", 0) + } + target_relations1280 := xs1277 + p.consumeLiteral(")") + return target_relations1280 +} + func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string1277 := p.consumeTerminal("STRING").Value.str + string1281 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1277 + return string1281 } func (p *Parser) parse_iceberg_data() *pb.IcebergData { - span_start1284 := int64(p.spanStart()) + span_start1288 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_data") - _t2096 := p.parse_iceberg_locator() - iceberg_locator1278 := _t2096 - _t2097 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1279 := _t2097 - _t2098 := p.parse_gnf_columns() - gnf_columns1280 := _t2098 - var _t2099 *string + _t2108 := p.parse_iceberg_locator() + iceberg_locator1282 := _t2108 + _t2109 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1283 := _t2109 + _t2110 := p.parse_gnf_columns() + gnf_columns1284 := _t2110 + var _t2111 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("from_snapshot", 1)) { - _t2100 := p.parse_iceberg_from_snapshot() - _t2099 = ptr(_t2100) + _t2112 := p.parse_iceberg_from_snapshot() + _t2111 = ptr(_t2112) } - iceberg_from_snapshot1281 := _t2099 - var _t2101 *string + iceberg_from_snapshot1285 := _t2111 + var _t2113 *string if p.matchLookaheadLiteral("(", 0) { - _t2102 := p.parse_iceberg_to_snapshot() - _t2101 = ptr(_t2102) + _t2114 := p.parse_iceberg_to_snapshot() + _t2113 = ptr(_t2114) } - iceberg_to_snapshot1282 := _t2101 - _t2103 := p.parse_boolean_value() - boolean_value1283 := _t2103 + iceberg_to_snapshot1286 := _t2113 + _t2115 := p.parse_boolean_value() + boolean_value1287 := _t2115 p.consumeLiteral(")") - _t2104 := p.construct_iceberg_data(iceberg_locator1278, iceberg_catalog_config1279, gnf_columns1280, iceberg_from_snapshot1281, iceberg_to_snapshot1282, boolean_value1283) - result1285 := _t2104 - p.recordSpan(int(span_start1284), "IcebergData") - return result1285 + _t2116 := p.construct_iceberg_data(iceberg_locator1282, iceberg_catalog_config1283, gnf_columns1284, iceberg_from_snapshot1285, iceberg_to_snapshot1286, boolean_value1287) + result1289 := _t2116 + p.recordSpan(int(span_start1288), "IcebergData") + return result1289 } func (p *Parser) parse_iceberg_locator() *pb.IcebergLocator { - span_start1289 := int64(p.spanStart()) + span_start1293 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_locator") - _t2105 := p.parse_iceberg_locator_table_name() - iceberg_locator_table_name1286 := _t2105 - _t2106 := p.parse_iceberg_locator_namespace() - iceberg_locator_namespace1287 := _t2106 - _t2107 := p.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1288 := _t2107 + _t2117 := p.parse_iceberg_locator_table_name() + iceberg_locator_table_name1290 := _t2117 + _t2118 := p.parse_iceberg_locator_namespace() + iceberg_locator_namespace1291 := _t2118 + _t2119 := p.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1292 := _t2119 p.consumeLiteral(")") - _t2108 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1286, Namespace: iceberg_locator_namespace1287, Warehouse: iceberg_locator_warehouse1288} - result1290 := _t2108 - p.recordSpan(int(span_start1289), "IcebergLocator") - return result1290 + _t2120 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1290, Namespace: iceberg_locator_namespace1291, Warehouse: iceberg_locator_warehouse1292} + result1294 := _t2120 + p.recordSpan(int(span_start1293), "IcebergLocator") + return result1294 } func (p *Parser) parse_iceberg_locator_table_name() string { p.consumeLiteral("(") p.consumeLiteral("table_name") - string1291 := p.consumeTerminal("STRING").Value.str + string1295 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1291 + return string1295 } func (p *Parser) parse_iceberg_locator_namespace() []string { p.consumeLiteral("(") p.consumeLiteral("namespace") - xs1292 := []string{} - cond1293 := p.matchLookaheadTerminal("STRING", 0) - for cond1293 { - item1294 := p.consumeTerminal("STRING").Value.str - xs1292 = append(xs1292, item1294) - cond1293 = p.matchLookaheadTerminal("STRING", 0) - } - strings1295 := xs1292 + xs1296 := []string{} + cond1297 := p.matchLookaheadTerminal("STRING", 0) + for cond1297 { + item1298 := p.consumeTerminal("STRING").Value.str + xs1296 = append(xs1296, item1298) + cond1297 = p.matchLookaheadTerminal("STRING", 0) + } + strings1299 := xs1296 p.consumeLiteral(")") - return strings1295 + return strings1299 } func (p *Parser) parse_iceberg_locator_warehouse() string { p.consumeLiteral("(") p.consumeLiteral("warehouse") - string1296 := p.consumeTerminal("STRING").Value.str + string1300 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1296 + return string1300 } func (p *Parser) parse_iceberg_catalog_config() *pb.IcebergCatalogConfig { - span_start1301 := int64(p.spanStart()) + span_start1305 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_catalog_config") - _t2109 := p.parse_iceberg_catalog_uri() - iceberg_catalog_uri1297 := _t2109 - var _t2110 *string + _t2121 := p.parse_iceberg_catalog_uri() + iceberg_catalog_uri1301 := _t2121 + var _t2122 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("scope", 1)) { - _t2111 := p.parse_iceberg_catalog_config_scope() - _t2110 = ptr(_t2111) - } - iceberg_catalog_config_scope1298 := _t2110 - _t2112 := p.parse_iceberg_properties() - iceberg_properties1299 := _t2112 - _t2113 := p.parse_iceberg_auth_properties() - iceberg_auth_properties1300 := _t2113 + _t2123 := p.parse_iceberg_catalog_config_scope() + _t2122 = ptr(_t2123) + } + iceberg_catalog_config_scope1302 := _t2122 + _t2124 := p.parse_iceberg_properties() + iceberg_properties1303 := _t2124 + _t2125 := p.parse_iceberg_auth_properties() + iceberg_auth_properties1304 := _t2125 p.consumeLiteral(")") - _t2114 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1297, iceberg_catalog_config_scope1298, iceberg_properties1299, iceberg_auth_properties1300) - result1302 := _t2114 - p.recordSpan(int(span_start1301), "IcebergCatalogConfig") - return result1302 + _t2126 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1301, iceberg_catalog_config_scope1302, iceberg_properties1303, iceberg_auth_properties1304) + result1306 := _t2126 + p.recordSpan(int(span_start1305), "IcebergCatalogConfig") + return result1306 } func (p *Parser) parse_iceberg_catalog_uri() string { p.consumeLiteral("(") p.consumeLiteral("catalog_uri") - string1303 := p.consumeTerminal("STRING").Value.str + string1307 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1303 + return string1307 } func (p *Parser) parse_iceberg_catalog_config_scope() string { p.consumeLiteral("(") p.consumeLiteral("scope") - string1304 := p.consumeTerminal("STRING").Value.str + string1308 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1304 + return string1308 } func (p *Parser) parse_iceberg_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("properties") - xs1305 := [][]interface{}{} - cond1306 := p.matchLookaheadLiteral("(", 0) - for cond1306 { - _t2115 := p.parse_iceberg_property_entry() - item1307 := _t2115 - xs1305 = append(xs1305, item1307) - cond1306 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1308 := xs1305 + xs1309 := [][]interface{}{} + cond1310 := p.matchLookaheadLiteral("(", 0) + for cond1310 { + _t2127 := p.parse_iceberg_property_entry() + item1311 := _t2127 + xs1309 = append(xs1309, item1311) + cond1310 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1312 := xs1309 p.consumeLiteral(")") - return iceberg_property_entrys1308 + return iceberg_property_entrys1312 } func (p *Parser) parse_iceberg_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1309 := p.consumeTerminal("STRING").Value.str - string_31310 := p.consumeTerminal("STRING").Value.str + string1313 := p.consumeTerminal("STRING").Value.str + string_31314 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1309, string_31310} + return []interface{}{string1313, string_31314} } func (p *Parser) parse_iceberg_auth_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("auth_properties") - xs1311 := [][]interface{}{} - cond1312 := p.matchLookaheadLiteral("(", 0) - for cond1312 { - _t2116 := p.parse_iceberg_masked_property_entry() - item1313 := _t2116 - xs1311 = append(xs1311, item1313) - cond1312 = p.matchLookaheadLiteral("(", 0) - } - iceberg_masked_property_entrys1314 := xs1311 + xs1315 := [][]interface{}{} + cond1316 := p.matchLookaheadLiteral("(", 0) + for cond1316 { + _t2128 := p.parse_iceberg_masked_property_entry() + item1317 := _t2128 + xs1315 = append(xs1315, item1317) + cond1316 = p.matchLookaheadLiteral("(", 0) + } + iceberg_masked_property_entrys1318 := xs1315 p.consumeLiteral(")") - return iceberg_masked_property_entrys1314 + return iceberg_masked_property_entrys1318 } func (p *Parser) parse_iceberg_masked_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1315 := p.consumeTerminal("STRING").Value.str - string_31316 := p.consumeTerminal("STRING").Value.str + string1319 := p.consumeTerminal("STRING").Value.str + string_31320 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1315, string_31316} + return []interface{}{string1319, string_31320} } func (p *Parser) parse_iceberg_from_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("from_snapshot") - string1317 := p.consumeTerminal("STRING").Value.str + string1321 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1317 + return string1321 } func (p *Parser) parse_iceberg_to_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("to_snapshot") - string1318 := p.consumeTerminal("STRING").Value.str + string1322 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1318 + return string1322 } func (p *Parser) parse_undefine() *pb.Undefine { - span_start1320 := int64(p.spanStart()) + span_start1324 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("undefine") - _t2117 := p.parse_fragment_id() - fragment_id1319 := _t2117 + _t2129 := p.parse_fragment_id() + fragment_id1323 := _t2129 p.consumeLiteral(")") - _t2118 := &pb.Undefine{FragmentId: fragment_id1319} - result1321 := _t2118 - p.recordSpan(int(span_start1320), "Undefine") - return result1321 + _t2130 := &pb.Undefine{FragmentId: fragment_id1323} + result1325 := _t2130 + p.recordSpan(int(span_start1324), "Undefine") + return result1325 } func (p *Parser) parse_context() *pb.Context { - span_start1326 := int64(p.spanStart()) + span_start1330 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("context") - xs1322 := []*pb.RelationId{} - cond1323 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1323 { - _t2119 := p.parse_relation_id() - item1324 := _t2119 - xs1322 = append(xs1322, item1324) - cond1323 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1325 := xs1322 + xs1326 := []*pb.RelationId{} + cond1327 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1327 { + _t2131 := p.parse_relation_id() + item1328 := _t2131 + xs1326 = append(xs1326, item1328) + cond1327 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1329 := xs1326 p.consumeLiteral(")") - _t2120 := &pb.Context{Relations: relation_ids1325} - result1327 := _t2120 - p.recordSpan(int(span_start1326), "Context") - return result1327 + _t2132 := &pb.Context{Relations: relation_ids1329} + result1331 := _t2132 + p.recordSpan(int(span_start1330), "Context") + return result1331 } func (p *Parser) parse_snapshot() *pb.Snapshot { - span_start1333 := int64(p.spanStart()) + span_start1337 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t2121 := p.parse_edb_path() - edb_path1328 := _t2121 - xs1329 := []*pb.SnapshotMapping{} - cond1330 := p.matchLookaheadLiteral("[", 0) - for cond1330 { - _t2122 := p.parse_snapshot_mapping() - item1331 := _t2122 - xs1329 = append(xs1329, item1331) - cond1330 = p.matchLookaheadLiteral("[", 0) - } - snapshot_mappings1332 := xs1329 + _t2133 := p.parse_edb_path() + edb_path1332 := _t2133 + xs1333 := []*pb.SnapshotMapping{} + cond1334 := p.matchLookaheadLiteral("[", 0) + for cond1334 { + _t2134 := p.parse_snapshot_mapping() + item1335 := _t2134 + xs1333 = append(xs1333, item1335) + cond1334 = p.matchLookaheadLiteral("[", 0) + } + snapshot_mappings1336 := xs1333 p.consumeLiteral(")") - _t2123 := &pb.Snapshot{Prefix: edb_path1328, Mappings: snapshot_mappings1332} - result1334 := _t2123 - p.recordSpan(int(span_start1333), "Snapshot") - return result1334 + _t2135 := &pb.Snapshot{Prefix: edb_path1332, Mappings: snapshot_mappings1336} + result1338 := _t2135 + p.recordSpan(int(span_start1337), "Snapshot") + return result1338 } func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { - span_start1337 := int64(p.spanStart()) - _t2124 := p.parse_edb_path() - edb_path1335 := _t2124 - _t2125 := p.parse_relation_id() - relation_id1336 := _t2125 - _t2126 := &pb.SnapshotMapping{DestinationPath: edb_path1335, SourceRelation: relation_id1336} - result1338 := _t2126 - p.recordSpan(int(span_start1337), "SnapshotMapping") - return result1338 + span_start1341 := int64(p.spanStart()) + _t2136 := p.parse_edb_path() + edb_path1339 := _t2136 + _t2137 := p.parse_relation_id() + relation_id1340 := _t2137 + _t2138 := &pb.SnapshotMapping{DestinationPath: edb_path1339, SourceRelation: relation_id1340} + result1342 := _t2138 + p.recordSpan(int(span_start1341), "SnapshotMapping") + return result1342 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs1339 := []*pb.Read{} - cond1340 := p.matchLookaheadLiteral("(", 0) - for cond1340 { - _t2127 := p.parse_read() - item1341 := _t2127 - xs1339 = append(xs1339, item1341) - cond1340 = p.matchLookaheadLiteral("(", 0) - } - reads1342 := xs1339 + xs1343 := []*pb.Read{} + cond1344 := p.matchLookaheadLiteral("(", 0) + for cond1344 { + _t2139 := p.parse_read() + item1345 := _t2139 + xs1343 = append(xs1343, item1345) + cond1344 = p.matchLookaheadLiteral("(", 0) + } + reads1346 := xs1343 p.consumeLiteral(")") - return reads1342 + return reads1346 } func (p *Parser) parse_read() *pb.Read { - span_start1349 := int64(p.spanStart()) - var _t2128 int64 + span_start1353 := int64(p.spanStart()) + var _t2140 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2129 int64 + var _t2141 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t2129 = 2 + _t2141 = 2 } else { - var _t2130 int64 + var _t2142 int64 if p.matchLookaheadLiteral("output", 1) { - _t2130 = 1 + _t2142 = 1 } else { - var _t2131 int64 + var _t2143 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2131 = 4 + _t2143 = 4 } else { - var _t2132 int64 + var _t2144 int64 if p.matchLookaheadLiteral("export", 1) { - _t2132 = 4 + _t2144 = 4 } else { - var _t2133 int64 + var _t2145 int64 if p.matchLookaheadLiteral("demand", 1) { - _t2133 = 0 + _t2145 = 0 } else { - var _t2134 int64 + var _t2146 int64 if p.matchLookaheadLiteral("abort", 1) { - _t2134 = 3 + _t2146 = 3 } else { - _t2134 = -1 + _t2146 = -1 } - _t2133 = _t2134 + _t2145 = _t2146 } - _t2132 = _t2133 + _t2144 = _t2145 } - _t2131 = _t2132 + _t2143 = _t2144 } - _t2130 = _t2131 + _t2142 = _t2143 } - _t2129 = _t2130 + _t2141 = _t2142 } - _t2128 = _t2129 + _t2140 = _t2141 } else { - _t2128 = -1 - } - prediction1343 := _t2128 - var _t2135 *pb.Read - if prediction1343 == 4 { - _t2136 := p.parse_export() - export1348 := _t2136 - _t2137 := &pb.Read{} - _t2137.ReadType = &pb.Read_Export{Export: export1348} - _t2135 = _t2137 + _t2140 = -1 + } + prediction1347 := _t2140 + var _t2147 *pb.Read + if prediction1347 == 4 { + _t2148 := p.parse_export() + export1352 := _t2148 + _t2149 := &pb.Read{} + _t2149.ReadType = &pb.Read_Export{Export: export1352} + _t2147 = _t2149 } else { - var _t2138 *pb.Read - if prediction1343 == 3 { - _t2139 := p.parse_abort() - abort1347 := _t2139 - _t2140 := &pb.Read{} - _t2140.ReadType = &pb.Read_Abort{Abort: abort1347} - _t2138 = _t2140 + var _t2150 *pb.Read + if prediction1347 == 3 { + _t2151 := p.parse_abort() + abort1351 := _t2151 + _t2152 := &pb.Read{} + _t2152.ReadType = &pb.Read_Abort{Abort: abort1351} + _t2150 = _t2152 } else { - var _t2141 *pb.Read - if prediction1343 == 2 { - _t2142 := p.parse_what_if() - what_if1346 := _t2142 - _t2143 := &pb.Read{} - _t2143.ReadType = &pb.Read_WhatIf{WhatIf: what_if1346} - _t2141 = _t2143 + var _t2153 *pb.Read + if prediction1347 == 2 { + _t2154 := p.parse_what_if() + what_if1350 := _t2154 + _t2155 := &pb.Read{} + _t2155.ReadType = &pb.Read_WhatIf{WhatIf: what_if1350} + _t2153 = _t2155 } else { - var _t2144 *pb.Read - if prediction1343 == 1 { - _t2145 := p.parse_output() - output1345 := _t2145 - _t2146 := &pb.Read{} - _t2146.ReadType = &pb.Read_Output{Output: output1345} - _t2144 = _t2146 + var _t2156 *pb.Read + if prediction1347 == 1 { + _t2157 := p.parse_output() + output1349 := _t2157 + _t2158 := &pb.Read{} + _t2158.ReadType = &pb.Read_Output{Output: output1349} + _t2156 = _t2158 } else { - var _t2147 *pb.Read - if prediction1343 == 0 { - _t2148 := p.parse_demand() - demand1344 := _t2148 - _t2149 := &pb.Read{} - _t2149.ReadType = &pb.Read_Demand{Demand: demand1344} - _t2147 = _t2149 + var _t2159 *pb.Read + if prediction1347 == 0 { + _t2160 := p.parse_demand() + demand1348 := _t2160 + _t2161 := &pb.Read{} + _t2161.ReadType = &pb.Read_Demand{Demand: demand1348} + _t2159 = _t2161 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2144 = _t2147 + _t2156 = _t2159 } - _t2141 = _t2144 + _t2153 = _t2156 } - _t2138 = _t2141 + _t2150 = _t2153 } - _t2135 = _t2138 + _t2147 = _t2150 } - result1350 := _t2135 - p.recordSpan(int(span_start1349), "Read") - return result1350 + result1354 := _t2147 + p.recordSpan(int(span_start1353), "Read") + return result1354 } func (p *Parser) parse_demand() *pb.Demand { - span_start1352 := int64(p.spanStart()) + span_start1356 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("demand") - _t2150 := p.parse_relation_id() - relation_id1351 := _t2150 + _t2162 := p.parse_relation_id() + relation_id1355 := _t2162 p.consumeLiteral(")") - _t2151 := &pb.Demand{RelationId: relation_id1351} - result1353 := _t2151 - p.recordSpan(int(span_start1352), "Demand") - return result1353 + _t2163 := &pb.Demand{RelationId: relation_id1355} + result1357 := _t2163 + p.recordSpan(int(span_start1356), "Demand") + return result1357 } func (p *Parser) parse_output() *pb.Output { - span_start1356 := int64(p.spanStart()) + span_start1360 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("output") - _t2152 := p.parse_name() - name1354 := _t2152 - _t2153 := p.parse_relation_id() - relation_id1355 := _t2153 + _t2164 := p.parse_name() + name1358 := _t2164 + _t2165 := p.parse_relation_id() + relation_id1359 := _t2165 p.consumeLiteral(")") - _t2154 := &pb.Output{Name: name1354, RelationId: relation_id1355} - result1357 := _t2154 - p.recordSpan(int(span_start1356), "Output") - return result1357 + _t2166 := &pb.Output{Name: name1358, RelationId: relation_id1359} + result1361 := _t2166 + p.recordSpan(int(span_start1360), "Output") + return result1361 } func (p *Parser) parse_what_if() *pb.WhatIf { - span_start1360 := int64(p.spanStart()) + span_start1364 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("what_if") - _t2155 := p.parse_name() - name1358 := _t2155 - _t2156 := p.parse_epoch() - epoch1359 := _t2156 + _t2167 := p.parse_name() + name1362 := _t2167 + _t2168 := p.parse_epoch() + epoch1363 := _t2168 p.consumeLiteral(")") - _t2157 := &pb.WhatIf{Branch: name1358, Epoch: epoch1359} - result1361 := _t2157 - p.recordSpan(int(span_start1360), "WhatIf") - return result1361 + _t2169 := &pb.WhatIf{Branch: name1362, Epoch: epoch1363} + result1365 := _t2169 + p.recordSpan(int(span_start1364), "WhatIf") + return result1365 } func (p *Parser) parse_abort() *pb.Abort { - span_start1364 := int64(p.spanStart()) + span_start1368 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("abort") - var _t2158 *string + var _t2170 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2159 := p.parse_name() - _t2158 = ptr(_t2159) + _t2171 := p.parse_name() + _t2170 = ptr(_t2171) } - name1362 := _t2158 - _t2160 := p.parse_relation_id() - relation_id1363 := _t2160 + name1366 := _t2170 + _t2172 := p.parse_relation_id() + relation_id1367 := _t2172 p.consumeLiteral(")") - _t2161 := &pb.Abort{Name: deref(name1362, "abort"), RelationId: relation_id1363} - result1365 := _t2161 - p.recordSpan(int(span_start1364), "Abort") - return result1365 + _t2173 := &pb.Abort{Name: deref(name1366, "abort"), RelationId: relation_id1367} + result1369 := _t2173 + p.recordSpan(int(span_start1368), "Abort") + return result1369 } func (p *Parser) parse_export() *pb.Export { - span_start1369 := int64(p.spanStart()) - var _t2162 int64 + span_start1373 := int64(p.spanStart()) + var _t2174 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2163 int64 + var _t2175 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2163 = 1 + _t2175 = 1 } else { - var _t2164 int64 + var _t2176 int64 if p.matchLookaheadLiteral("export", 1) { - _t2164 = 0 + _t2176 = 0 } else { - _t2164 = -1 + _t2176 = -1 } - _t2163 = _t2164 + _t2175 = _t2176 } - _t2162 = _t2163 + _t2174 = _t2175 } else { - _t2162 = -1 + _t2174 = -1 } - prediction1366 := _t2162 - var _t2165 *pb.Export - if prediction1366 == 1 { + prediction1370 := _t2174 + var _t2177 *pb.Export + if prediction1370 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_iceberg") - _t2166 := p.parse_export_iceberg_config() - export_iceberg_config1368 := _t2166 + _t2178 := p.parse_export_iceberg_config() + export_iceberg_config1372 := _t2178 p.consumeLiteral(")") - _t2167 := &pb.Export{} - _t2167.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1368} - _t2165 = _t2167 + _t2179 := &pb.Export{} + _t2179.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1372} + _t2177 = _t2179 } else { - var _t2168 *pb.Export - if prediction1366 == 0 { + var _t2180 *pb.Export + if prediction1370 == 0 { p.consumeLiteral("(") p.consumeLiteral("export") - _t2169 := p.parse_export_csv_config() - export_csv_config1367 := _t2169 + _t2181 := p.parse_export_csv_config() + export_csv_config1371 := _t2181 p.consumeLiteral(")") - _t2170 := &pb.Export{} - _t2170.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1367} - _t2168 = _t2170 + _t2182 := &pb.Export{} + _t2182.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1371} + _t2180 = _t2182 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2165 = _t2168 + _t2177 = _t2180 } - result1370 := _t2165 - p.recordSpan(int(span_start1369), "Export") - return result1370 + result1374 := _t2177 + p.recordSpan(int(span_start1373), "Export") + return result1374 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1378 := int64(p.spanStart()) - var _t2171 int64 + span_start1382 := int64(p.spanStart()) + var _t2183 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2172 int64 + var _t2184 int64 if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2172 = 0 + _t2184 = 0 } else { - var _t2173 int64 + var _t2185 int64 if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2173 = 1 + _t2185 = 1 } else { - _t2173 = -1 + _t2185 = -1 } - _t2172 = _t2173 + _t2184 = _t2185 } - _t2171 = _t2172 + _t2183 = _t2184 } else { - _t2171 = -1 + _t2183 = -1 } - prediction1371 := _t2171 - var _t2174 *pb.ExportCSVConfig - if prediction1371 == 1 { + prediction1375 := _t2183 + var _t2186 *pb.ExportCSVConfig + if prediction1375 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t2175 := p.parse_export_csv_path() - export_csv_path1375 := _t2175 - _t2176 := p.parse_export_csv_columns_list() - export_csv_columns_list1376 := _t2176 - _t2177 := p.parse_config_dict() - config_dict1377 := _t2177 + _t2187 := p.parse_export_csv_path() + export_csv_path1379 := _t2187 + _t2188 := p.parse_export_csv_columns_list() + export_csv_columns_list1380 := _t2188 + _t2189 := p.parse_config_dict() + config_dict1381 := _t2189 p.consumeLiteral(")") - _t2178 := p.construct_export_csv_config(export_csv_path1375, export_csv_columns_list1376, config_dict1377) - _t2174 = _t2178 + _t2190 := p.construct_export_csv_config(export_csv_path1379, export_csv_columns_list1380, config_dict1381) + _t2186 = _t2190 } else { - var _t2179 *pb.ExportCSVConfig - if prediction1371 == 0 { + var _t2191 *pb.ExportCSVConfig + if prediction1375 == 0 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config_v2") - _t2180 := p.parse_export_csv_output_location() - export_csv_output_location1372 := _t2180 - _t2181 := p.parse_export_csv_source() - export_csv_source1373 := _t2181 - _t2182 := p.parse_csv_config() - csv_config1374 := _t2182 + _t2192 := p.parse_export_csv_output_location() + export_csv_output_location1376 := _t2192 + _t2193 := p.parse_export_csv_source() + export_csv_source1377 := _t2193 + _t2194 := p.parse_csv_config() + csv_config1378 := _t2194 p.consumeLiteral(")") - _t2183 := p.construct_export_csv_config_with_location(export_csv_output_location1372, export_csv_source1373, csv_config1374) - _t2179 = _t2183 + _t2195 := p.construct_export_csv_config_with_location(export_csv_output_location1376, export_csv_source1377, csv_config1378) + _t2191 = _t2195 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_config", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2174 = _t2179 + _t2186 = _t2191 } - result1379 := _t2174 - p.recordSpan(int(span_start1378), "ExportCSVConfig") - return result1379 + result1383 := _t2186 + p.recordSpan(int(span_start1382), "ExportCSVConfig") + return result1383 } func (p *Parser) parse_export_csv_output_location() []interface{} { - var _t2184 int64 + var _t2196 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2185 int64 + var _t2197 int64 if p.matchLookaheadLiteral("transaction_output_name", 1) { - _t2185 = 1 + _t2197 = 1 } else { - var _t2186 int64 + var _t2198 int64 if p.matchLookaheadLiteral("path", 1) { - _t2186 = 0 + _t2198 = 0 } else { - _t2186 = -1 + _t2198 = -1 } - _t2185 = _t2186 + _t2197 = _t2198 } - _t2184 = _t2185 + _t2196 = _t2197 } else { - _t2184 = -1 + _t2196 = -1 } - prediction1380 := _t2184 - var _t2187 []interface{} - if prediction1380 == 1 { + prediction1384 := _t2196 + var _t2199 []interface{} + if prediction1384 == 1 { p.consumeLiteral("(") p.consumeLiteral("transaction_output_name") - _t2188 := p.parse_name() - name1382 := _t2188 + _t2200 := p.parse_name() + name1386 := _t2200 p.consumeLiteral(")") - _t2187 = []interface{}{"", name1382} + _t2199 = []interface{}{"", name1386} } else { - var _t2189 []interface{} - if prediction1380 == 0 { + var _t2201 []interface{} + if prediction1384 == 0 { p.consumeLiteral("(") p.consumeLiteral("path") - string1381 := p.consumeTerminal("STRING").Value.str + string1385 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - _t2189 = []interface{}{string1381, ""} + _t2201 = []interface{}{string1385, ""} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_output_location", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2187 = _t2189 + _t2199 = _t2201 } - return _t2187 + return _t2199 } func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1389 := int64(p.spanStart()) - var _t2190 int64 + span_start1393 := int64(p.spanStart()) + var _t2202 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2191 int64 + var _t2203 int64 if p.matchLookaheadLiteral("table_def", 1) { - _t2191 = 1 + _t2203 = 1 } else { - var _t2192 int64 + var _t2204 int64 if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2192 = 0 + _t2204 = 0 } else { - _t2192 = -1 + _t2204 = -1 } - _t2191 = _t2192 + _t2203 = _t2204 } - _t2190 = _t2191 + _t2202 = _t2203 } else { - _t2190 = -1 + _t2202 = -1 } - prediction1383 := _t2190 - var _t2193 *pb.ExportCSVSource - if prediction1383 == 1 { + prediction1387 := _t2202 + var _t2205 *pb.ExportCSVSource + if prediction1387 == 1 { p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2194 := p.parse_relation_id() - relation_id1388 := _t2194 + _t2206 := p.parse_relation_id() + relation_id1392 := _t2206 p.consumeLiteral(")") - _t2195 := &pb.ExportCSVSource{} - _t2195.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1388} - _t2193 = _t2195 + _t2207 := &pb.ExportCSVSource{} + _t2207.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1392} + _t2205 = _t2207 } else { - var _t2196 *pb.ExportCSVSource - if prediction1383 == 0 { + var _t2208 *pb.ExportCSVSource + if prediction1387 == 0 { p.consumeLiteral("(") p.consumeLiteral("gnf_columns") - xs1384 := []*pb.ExportCSVColumn{} - cond1385 := p.matchLookaheadLiteral("(", 0) - for cond1385 { - _t2197 := p.parse_export_csv_column() - item1386 := _t2197 - xs1384 = append(xs1384, item1386) - cond1385 = p.matchLookaheadLiteral("(", 0) + xs1388 := []*pb.ExportCSVColumn{} + cond1389 := p.matchLookaheadLiteral("(", 0) + for cond1389 { + _t2209 := p.parse_export_csv_column() + item1390 := _t2209 + xs1388 = append(xs1388, item1390) + cond1389 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns1387 := xs1384 + export_csv_columns1391 := xs1388 p.consumeLiteral(")") - _t2198 := &pb.ExportCSVColumns{Columns: export_csv_columns1387} - _t2199 := &pb.ExportCSVSource{} - _t2199.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2198} - _t2196 = _t2199 + _t2210 := &pb.ExportCSVColumns{Columns: export_csv_columns1391} + _t2211 := &pb.ExportCSVSource{} + _t2211.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2210} + _t2208 = _t2211 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_source", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2193 = _t2196 + _t2205 = _t2208 } - result1390 := _t2193 - p.recordSpan(int(span_start1389), "ExportCSVSource") - return result1390 + result1394 := _t2205 + p.recordSpan(int(span_start1393), "ExportCSVSource") + return result1394 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1393 := int64(p.spanStart()) + span_start1397 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1391 := p.consumeTerminal("STRING").Value.str - _t2200 := p.parse_relation_id() - relation_id1392 := _t2200 + string1395 := p.consumeTerminal("STRING").Value.str + _t2212 := p.parse_relation_id() + relation_id1396 := _t2212 p.consumeLiteral(")") - _t2201 := &pb.ExportCSVColumn{ColumnName: string1391, ColumnData: relation_id1392} - result1394 := _t2201 - p.recordSpan(int(span_start1393), "ExportCSVColumn") - return result1394 + _t2213 := &pb.ExportCSVColumn{ColumnName: string1395, ColumnData: relation_id1396} + result1398 := _t2213 + p.recordSpan(int(span_start1397), "ExportCSVColumn") + return result1398 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") - string1395 := p.consumeTerminal("STRING").Value.str + string1399 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1395 + return string1399 } func (p *Parser) parse_export_csv_columns_list() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1396 := []*pb.ExportCSVColumn{} - cond1397 := p.matchLookaheadLiteral("(", 0) - for cond1397 { - _t2202 := p.parse_export_csv_column() - item1398 := _t2202 - xs1396 = append(xs1396, item1398) - cond1397 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1399 := xs1396 + xs1400 := []*pb.ExportCSVColumn{} + cond1401 := p.matchLookaheadLiteral("(", 0) + for cond1401 { + _t2214 := p.parse_export_csv_column() + item1402 := _t2214 + xs1400 = append(xs1400, item1402) + cond1401 = p.matchLookaheadLiteral("(", 0) + } + export_csv_columns1403 := xs1400 p.consumeLiteral(")") - return export_csv_columns1399 + return export_csv_columns1403 } func (p *Parser) parse_export_iceberg_config() *pb.ExportIcebergConfig { - span_start1405 := int64(p.spanStart()) + span_start1409 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("export_iceberg_config") - _t2203 := p.parse_iceberg_locator() - iceberg_locator1400 := _t2203 - _t2204 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1401 := _t2204 - _t2205 := p.parse_export_iceberg_table_def() - export_iceberg_table_def1402 := _t2205 - _t2206 := p.parse_iceberg_table_properties() - iceberg_table_properties1403 := _t2206 - var _t2207 [][]interface{} + _t2215 := p.parse_iceberg_locator() + iceberg_locator1404 := _t2215 + _t2216 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1405 := _t2216 + _t2217 := p.parse_export_iceberg_table_def() + export_iceberg_table_def1406 := _t2217 + _t2218 := p.parse_iceberg_table_properties() + iceberg_table_properties1407 := _t2218 + var _t2219 [][]interface{} if p.matchLookaheadLiteral("{", 0) { - _t2208 := p.parse_config_dict() - _t2207 = _t2208 + _t2220 := p.parse_config_dict() + _t2219 = _t2220 } - config_dict1404 := _t2207 + config_dict1408 := _t2219 p.consumeLiteral(")") - _t2209 := p.construct_export_iceberg_config_full(iceberg_locator1400, iceberg_catalog_config1401, export_iceberg_table_def1402, iceberg_table_properties1403, config_dict1404) - result1406 := _t2209 - p.recordSpan(int(span_start1405), "ExportIcebergConfig") - return result1406 + _t2221 := p.construct_export_iceberg_config_full(iceberg_locator1404, iceberg_catalog_config1405, export_iceberg_table_def1406, iceberg_table_properties1407, config_dict1408) + result1410 := _t2221 + p.recordSpan(int(span_start1409), "ExportIcebergConfig") + return result1410 } func (p *Parser) parse_export_iceberg_table_def() *pb.RelationId { - span_start1408 := int64(p.spanStart()) + span_start1412 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2210 := p.parse_relation_id() - relation_id1407 := _t2210 + _t2222 := p.parse_relation_id() + relation_id1411 := _t2222 p.consumeLiteral(")") - result1409 := relation_id1407 - p.recordSpan(int(span_start1408), "RelationId") - return result1409 + result1413 := relation_id1411 + p.recordSpan(int(span_start1412), "RelationId") + return result1413 } func (p *Parser) parse_iceberg_table_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("table_properties") - xs1410 := [][]interface{}{} - cond1411 := p.matchLookaheadLiteral("(", 0) - for cond1411 { - _t2211 := p.parse_iceberg_property_entry() - item1412 := _t2211 - xs1410 = append(xs1410, item1412) - cond1411 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1413 := xs1410 + xs1414 := [][]interface{}{} + cond1415 := p.matchLookaheadLiteral("(", 0) + for cond1415 { + _t2223 := p.parse_iceberg_property_entry() + item1416 := _t2223 + xs1414 = append(xs1414, item1416) + cond1415 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1417 := xs1414 p.consumeLiteral(")") - return iceberg_property_entrys1413 + return iceberg_property_entrys1417 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index f9018ec0..8c9f8fd5 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -342,21 +342,25 @@ func formatBool(b bool) string { // --- Helper functions --- +func (p *PrettyPrinter) deconstruct_relation_keys(msg *pb.TargetRelations) []interface{} { + return []interface{}{msg.GetKeys(), msg.GetSyntheticKey()} +} + func (p *PrettyPrinter) deconstruct_csv_data_columns_optional(msg *pb.CSVData) []*pb.GNFColumn { - var _t1845 interface{} + var _t1854 interface{} if hasProtoField(msg, "relations") { return nil } - _ = _t1845 + _ = _t1854 return msg.GetColumns() } func (p *PrettyPrinter) deconstruct_csv_data_relations_optional(msg *pb.CSVData) *pb.TargetRelations { - var _t1846 interface{} + var _t1855 interface{} if hasProtoField(msg, "relations") { return msg.GetRelations() } - _ = _t1846 + _ = _t1855 return nil } @@ -365,188 +369,188 @@ func (p *PrettyPrinter) deconstruct_export_csv_output_location(msg *pb.ExportCSV } func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1847 := &pb.Value{} - _t1847.Value = &pb.Value_Int32Value{Int32Value: v} - return _t1847 + _t1856 := &pb.Value{} + _t1856.Value = &pb.Value_Int32Value{Int32Value: v} + return _t1856 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1848 := &pb.Value{} - _t1848.Value = &pb.Value_IntValue{IntValue: v} - return _t1848 + _t1857 := &pb.Value{} + _t1857.Value = &pb.Value_IntValue{IntValue: v} + return _t1857 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1849 := &pb.Value{} - _t1849.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1849 + _t1858 := &pb.Value{} + _t1858.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1858 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1850 := &pb.Value{} - _t1850.Value = &pb.Value_StringValue{StringValue: v} - return _t1850 + _t1859 := &pb.Value{} + _t1859.Value = &pb.Value_StringValue{StringValue: v} + return _t1859 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1851 := &pb.Value{} - _t1851.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1851 + _t1860 := &pb.Value{} + _t1860.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1860 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1852 := &pb.Value{} - _t1852.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1852 + _t1861 := &pb.Value{} + _t1861.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1861 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { - _t1853 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1853}) + _t1862 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1862}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1854 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1854}) + _t1863 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1863}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1855 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1855}) + _t1864 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1864}) } } } - _t1856 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1856}) + _t1865 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1865}) return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} - _t1857 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1857}) - _t1858 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1858}) + _t1866 := p._make_value_int32(msg.GetHeaderRow()) + result = append(result, []interface{}{"csv_header_row", _t1866}) + _t1867 := p._make_value_int64(msg.GetSkip()) + result = append(result, []interface{}{"csv_skip", _t1867}) if msg.GetNewLine() != "" { - _t1859 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1859}) - } - _t1860 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1860}) - _t1861 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1861}) - _t1862 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1862}) + _t1868 := p._make_value_string(msg.GetNewLine()) + result = append(result, []interface{}{"csv_new_line", _t1868}) + } + _t1869 := p._make_value_string(msg.GetDelimiter()) + result = append(result, []interface{}{"csv_delimiter", _t1869}) + _t1870 := p._make_value_string(msg.GetQuotechar()) + result = append(result, []interface{}{"csv_quotechar", _t1870}) + _t1871 := p._make_value_string(msg.GetEscapechar()) + result = append(result, []interface{}{"csv_escapechar", _t1871}) if msg.GetComment() != "" { - _t1863 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1863}) + _t1872 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1872}) } for _, missing_string := range msg.GetMissingStrings() { - _t1864 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1864}) - } - _t1865 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1865}) - _t1866 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1866}) - _t1867 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1867}) + _t1873 := p._make_value_string(missing_string) + result = append(result, []interface{}{"csv_missing_strings", _t1873}) + } + _t1874 := p._make_value_string(msg.GetDecimalSeparator()) + result = append(result, []interface{}{"csv_decimal_separator", _t1874}) + _t1875 := p._make_value_string(msg.GetEncoding()) + result = append(result, []interface{}{"csv_encoding", _t1875}) + _t1876 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"csv_compression", _t1876}) if msg.GetPartitionSizeMb() != 0 { - _t1868 := p._make_value_int64(msg.GetPartitionSizeMb()) - result = append(result, []interface{}{"csv_partition_size_mb", _t1868}) + _t1877 := p._make_value_int64(msg.GetPartitionSizeMb()) + result = append(result, []interface{}{"csv_partition_size_mb", _t1877}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_storage_integration_optional(msg *pb.CSVConfig) [][]interface{} { - var _t1869 interface{} + var _t1878 interface{} if !(hasProtoField(msg, "storage_integration")) { return nil } - _ = _t1869 + _ = _t1878 si := msg.GetStorageIntegration() result := [][]interface{}{} if si.GetProvider() != "" { - _t1870 := p._make_value_string(si.GetProvider()) - result = append(result, []interface{}{"provider", _t1870}) + _t1879 := p._make_value_string(si.GetProvider()) + result = append(result, []interface{}{"provider", _t1879}) } if si.GetAzureSasToken() != "" { - _t1871 := p._make_value_string("***") - result = append(result, []interface{}{"azure_sas_token", _t1871}) + _t1880 := p._make_value_string("***") + result = append(result, []interface{}{"azure_sas_token", _t1880}) } if si.GetS3Region() != "" { - _t1872 := p._make_value_string(si.GetS3Region()) - result = append(result, []interface{}{"s3_region", _t1872}) + _t1881 := p._make_value_string(si.GetS3Region()) + result = append(result, []interface{}{"s3_region", _t1881}) } if si.GetS3AccessKeyId() != "" { - _t1873 := p._make_value_string("***") - result = append(result, []interface{}{"s3_access_key_id", _t1873}) + _t1882 := p._make_value_string("***") + result = append(result, []interface{}{"s3_access_key_id", _t1882}) } if si.GetS3SecretAccessKey() != "" { - _t1874 := p._make_value_string("***") - result = append(result, []interface{}{"s3_secret_access_key", _t1874}) + _t1883 := p._make_value_string("***") + result = append(result, []interface{}{"s3_secret_access_key", _t1883}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} - _t1875 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1875}) - _t1876 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1876}) - _t1877 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1877}) - _t1878 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1878}) + _t1884 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) + result = append(result, []interface{}{"betree_config_epsilon", _t1884}) + _t1885 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) + result = append(result, []interface{}{"betree_config_max_pivots", _t1885}) + _t1886 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) + result = append(result, []interface{}{"betree_config_max_deltas", _t1886}) + _t1887 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) + result = append(result, []interface{}{"betree_config_max_leaf", _t1887}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1879 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1879}) + _t1888 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1888}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { - _t1880 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1880}) + _t1889 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1889}) } } - _t1881 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1881}) - _t1882 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1882}) + _t1890 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) + result = append(result, []interface{}{"betree_locator_element_count", _t1890}) + _t1891 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) + result = append(result, []interface{}{"betree_locator_tree_height", _t1891}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { - _t1883 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1883}) + _t1892 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1892}) } if msg.Compression != nil { - _t1884 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1884}) + _t1893 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1893}) } if msg.SyntaxHeaderRow != nil { - _t1885 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1885}) + _t1894 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1894}) } if msg.SyntaxMissingString != nil { - _t1886 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1886}) + _t1895 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1895}) } if msg.SyntaxDelim != nil { - _t1887 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1887}) + _t1896 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1896}) } if msg.SyntaxQuotechar != nil { - _t1888 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1888}) + _t1897 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1897}) } if msg.SyntaxEscapechar != nil { - _t1889 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1889}) + _t1898 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1898}) } return listSort(result) } @@ -556,51 +560,51 @@ func (p *PrettyPrinter) mask_secret_value(pair []interface{}) string { } func (p *PrettyPrinter) deconstruct_iceberg_catalog_config_scope_optional(msg *pb.IcebergCatalogConfig) *string { - var _t1890 interface{} + var _t1899 interface{} if *msg.Scope != "" { return ptr(*msg.Scope) } - _ = _t1890 + _ = _t1899 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_from_snapshot_optional(msg *pb.IcebergData) *string { - var _t1891 interface{} + var _t1900 interface{} if *msg.FromSnapshot != "" { return ptr(*msg.FromSnapshot) } - _ = _t1891 + _ = _t1900 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_to_snapshot_optional(msg *pb.IcebergData) *string { - var _t1892 interface{} + var _t1901 interface{} if *msg.ToSnapshot != "" { return ptr(*msg.ToSnapshot) } - _ = _t1892 + _ = _t1901 return nil } func (p *PrettyPrinter) deconstruct_export_iceberg_config_optional(msg *pb.ExportIcebergConfig) [][]interface{} { result := [][]interface{}{} if *msg.Prefix != "" { - _t1893 := p._make_value_string(*msg.Prefix) - result = append(result, []interface{}{"prefix", _t1893}) + _t1902 := p._make_value_string(*msg.Prefix) + result = append(result, []interface{}{"prefix", _t1902}) } if *msg.TargetFileSizeBytes != 0 { - _t1894 := p._make_value_int64(*msg.TargetFileSizeBytes) - result = append(result, []interface{}{"target_file_size_bytes", _t1894}) + _t1903 := p._make_value_int64(*msg.TargetFileSizeBytes) + result = append(result, []interface{}{"target_file_size_bytes", _t1903}) } if msg.GetCompression() != "" { - _t1895 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"compression", _t1895}) + _t1904 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"compression", _t1904}) } - var _t1896 interface{} + var _t1905 interface{} if int64(len(result)) == 0 { return nil } - _ = _t1896 + _ = _t1905 return listSort(result) } @@ -611,11 +615,11 @@ func (p *PrettyPrinter) deconstruct_relation_id_string(msg *pb.RelationId) strin func (p *PrettyPrinter) deconstruct_relation_id_uint128(msg *pb.RelationId) *pb.UInt128Value { name := p.relationIdToString(msg) - var _t1897 interface{} + var _t1906 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1897 + _ = _t1906 return nil } @@ -633,45 +637,45 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { - flat856 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat856 != nil { - p.write(*flat856) + flat859 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat859 != nil { + p.write(*flat859) return nil } else { _dollar_dollar := msg - var _t1694 *pb.Configure + var _t1700 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1694 = _dollar_dollar.GetConfigure() + _t1700 = _dollar_dollar.GetConfigure() } - var _t1695 *pb.Sync + var _t1701 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1695 = _dollar_dollar.GetSync() + _t1701 = _dollar_dollar.GetSync() } - fields847 := []interface{}{_t1694, _t1695, _dollar_dollar.GetEpochs()} - unwrapped_fields848 := fields847 + fields850 := []interface{}{_t1700, _t1701, _dollar_dollar.GetEpochs()} + unwrapped_fields851 := fields850 p.write("(") p.write("transaction") p.indentSexp() - field849 := unwrapped_fields848[0].(*pb.Configure) - if field849 != nil { + field852 := unwrapped_fields851[0].(*pb.Configure) + if field852 != nil { p.newline() - opt_val850 := field849 - p.pretty_configure(opt_val850) + opt_val853 := field852 + p.pretty_configure(opt_val853) } - field851 := unwrapped_fields848[1].(*pb.Sync) - if field851 != nil { + field854 := unwrapped_fields851[1].(*pb.Sync) + if field854 != nil { p.newline() - opt_val852 := field851 - p.pretty_sync(opt_val852) + opt_val855 := field854 + p.pretty_sync(opt_val855) } - field853 := unwrapped_fields848[2].([]*pb.Epoch) - if !(len(field853) == 0) { + field856 := unwrapped_fields851[2].([]*pb.Epoch) + if !(len(field856) == 0) { p.newline() - for i855, elem854 := range field853 { - if (i855 > 0) { + for i858, elem857 := range field856 { + if (i858 > 0) { p.newline() } - p.pretty_epoch(elem854) + p.pretty_epoch(elem857) } } p.dedent() @@ -681,20 +685,20 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - flat859 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat859 != nil { - p.write(*flat859) + flat862 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat862 != nil { + p.write(*flat862) return nil } else { _dollar_dollar := msg - _t1696 := p.deconstruct_configure(_dollar_dollar) - fields857 := _t1696 - unwrapped_fields858 := fields857 + _t1702 := p.deconstruct_configure(_dollar_dollar) + fields860 := _t1702 + unwrapped_fields861 := fields860 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields858) + p.pretty_config_dict(unwrapped_fields861) p.dedent() p.write(")") } @@ -702,21 +706,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - flat863 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat863 != nil { - p.write(*flat863) + flat866 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat866 != nil { + p.write(*flat866) return nil } else { - fields860 := msg + fields863 := msg p.write("{") p.indent() - if !(len(fields860) == 0) { + if !(len(fields863) == 0) { p.newline() - for i862, elem861 := range fields860 { - if (i862 > 0) { + for i865, elem864 := range fields863 { + if (i865 > 0) { p.newline() } - p.pretty_config_key_value(elem861) + p.pretty_config_key_value(elem864) } } p.dedent() @@ -726,152 +730,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - flat868 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat868 != nil { - p.write(*flat868) + flat871 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat871 != nil { + p.write(*flat871) return nil } else { _dollar_dollar := msg - fields864 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} - unwrapped_fields865 := fields864 + fields867 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} + unwrapped_fields868 := fields867 p.write(":") - field866 := unwrapped_fields865[0].(string) - p.write(field866) + field869 := unwrapped_fields868[0].(string) + p.write(field869) p.write(" ") - field867 := unwrapped_fields865[1].(*pb.Value) - p.pretty_raw_value(field867) + field870 := unwrapped_fields868[1].(*pb.Value) + p.pretty_raw_value(field870) } return nil } func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { - flat894 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) - if flat894 != nil { - p.write(*flat894) + flat897 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) + if flat897 != nil { + p.write(*flat897) return nil } else { _dollar_dollar := msg - var _t1697 *pb.DateValue + var _t1703 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1697 = _dollar_dollar.GetDateValue() + _t1703 = _dollar_dollar.GetDateValue() } - deconstruct_result892 := _t1697 - if deconstruct_result892 != nil { - unwrapped893 := deconstruct_result892 - p.pretty_raw_date(unwrapped893) + deconstruct_result895 := _t1703 + if deconstruct_result895 != nil { + unwrapped896 := deconstruct_result895 + p.pretty_raw_date(unwrapped896) } else { _dollar_dollar := msg - var _t1698 *pb.DateTimeValue + var _t1704 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1698 = _dollar_dollar.GetDatetimeValue() + _t1704 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result890 := _t1698 - if deconstruct_result890 != nil { - unwrapped891 := deconstruct_result890 - p.pretty_raw_datetime(unwrapped891) + deconstruct_result893 := _t1704 + if deconstruct_result893 != nil { + unwrapped894 := deconstruct_result893 + p.pretty_raw_datetime(unwrapped894) } else { _dollar_dollar := msg - var _t1699 *string + var _t1705 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1699 = ptr(_dollar_dollar.GetStringValue()) + _t1705 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result888 := _t1699 - if deconstruct_result888 != nil { - unwrapped889 := *deconstruct_result888 - p.write(p.formatStringValue(unwrapped889)) + deconstruct_result891 := _t1705 + if deconstruct_result891 != nil { + unwrapped892 := *deconstruct_result891 + p.write(p.formatStringValue(unwrapped892)) } else { _dollar_dollar := msg - var _t1700 *int32 + var _t1706 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1700 = ptr(_dollar_dollar.GetInt32Value()) + _t1706 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result886 := _t1700 - if deconstruct_result886 != nil { - unwrapped887 := *deconstruct_result886 - p.write(fmt.Sprintf("%di32", unwrapped887)) + deconstruct_result889 := _t1706 + if deconstruct_result889 != nil { + unwrapped890 := *deconstruct_result889 + p.write(fmt.Sprintf("%di32", unwrapped890)) } else { _dollar_dollar := msg - var _t1701 *int64 + var _t1707 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1701 = ptr(_dollar_dollar.GetIntValue()) + _t1707 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result884 := _t1701 - if deconstruct_result884 != nil { - unwrapped885 := *deconstruct_result884 - p.write(fmt.Sprintf("%d", unwrapped885)) + deconstruct_result887 := _t1707 + if deconstruct_result887 != nil { + unwrapped888 := *deconstruct_result887 + p.write(fmt.Sprintf("%d", unwrapped888)) } else { _dollar_dollar := msg - var _t1702 *float32 + var _t1708 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1702 = ptr(_dollar_dollar.GetFloat32Value()) + _t1708 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result882 := _t1702 - if deconstruct_result882 != nil { - unwrapped883 := *deconstruct_result882 - p.write(formatFloat32(unwrapped883)) + deconstruct_result885 := _t1708 + if deconstruct_result885 != nil { + unwrapped886 := *deconstruct_result885 + p.write(formatFloat32(unwrapped886)) } else { _dollar_dollar := msg - var _t1703 *float64 + var _t1709 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1703 = ptr(_dollar_dollar.GetFloatValue()) + _t1709 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result880 := _t1703 - if deconstruct_result880 != nil { - unwrapped881 := *deconstruct_result880 - p.write(formatFloat64(unwrapped881)) + deconstruct_result883 := _t1709 + if deconstruct_result883 != nil { + unwrapped884 := *deconstruct_result883 + p.write(formatFloat64(unwrapped884)) } else { _dollar_dollar := msg - var _t1704 *uint32 + var _t1710 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1704 = ptr(_dollar_dollar.GetUint32Value()) + _t1710 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result878 := _t1704 - if deconstruct_result878 != nil { - unwrapped879 := *deconstruct_result878 - p.write(fmt.Sprintf("%du32", unwrapped879)) + deconstruct_result881 := _t1710 + if deconstruct_result881 != nil { + unwrapped882 := *deconstruct_result881 + p.write(fmt.Sprintf("%du32", unwrapped882)) } else { _dollar_dollar := msg - var _t1705 *pb.UInt128Value + var _t1711 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1705 = _dollar_dollar.GetUint128Value() + _t1711 = _dollar_dollar.GetUint128Value() } - deconstruct_result876 := _t1705 - if deconstruct_result876 != nil { - unwrapped877 := deconstruct_result876 - p.write(p.formatUint128(unwrapped877)) + deconstruct_result879 := _t1711 + if deconstruct_result879 != nil { + unwrapped880 := deconstruct_result879 + p.write(p.formatUint128(unwrapped880)) } else { _dollar_dollar := msg - var _t1706 *pb.Int128Value + var _t1712 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1706 = _dollar_dollar.GetInt128Value() + _t1712 = _dollar_dollar.GetInt128Value() } - deconstruct_result874 := _t1706 - if deconstruct_result874 != nil { - unwrapped875 := deconstruct_result874 - p.write(p.formatInt128(unwrapped875)) + deconstruct_result877 := _t1712 + if deconstruct_result877 != nil { + unwrapped878 := deconstruct_result877 + p.write(p.formatInt128(unwrapped878)) } else { _dollar_dollar := msg - var _t1707 *pb.DecimalValue + var _t1713 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1707 = _dollar_dollar.GetDecimalValue() + _t1713 = _dollar_dollar.GetDecimalValue() } - deconstruct_result872 := _t1707 - if deconstruct_result872 != nil { - unwrapped873 := deconstruct_result872 - p.write(p.formatDecimal(unwrapped873)) + deconstruct_result875 := _t1713 + if deconstruct_result875 != nil { + unwrapped876 := deconstruct_result875 + p.write(p.formatDecimal(unwrapped876)) } else { _dollar_dollar := msg - var _t1708 *bool + var _t1714 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1708 = ptr(_dollar_dollar.GetBooleanValue()) + _t1714 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result870 := _t1708 - if deconstruct_result870 != nil { - unwrapped871 := *deconstruct_result870 - p.pretty_boolean_value(unwrapped871) + deconstruct_result873 := _t1714 + if deconstruct_result873 != nil { + unwrapped874 := *deconstruct_result873 + p.pretty_boolean_value(unwrapped874) } else { - fields869 := msg - _ = fields869 + fields872 := msg + _ = fields872 p.write("missing") } } @@ -890,26 +894,26 @@ func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { - flat900 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) - if flat900 != nil { - p.write(*flat900) + flat903 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) + if flat903 != nil { + p.write(*flat903) return nil } else { _dollar_dollar := msg - fields895 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields896 := fields895 + fields898 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields899 := fields898 p.write("(") p.write("date") p.indentSexp() p.newline() - field897 := unwrapped_fields896[0].(int64) - p.write(fmt.Sprintf("%d", field897)) + field900 := unwrapped_fields899[0].(int64) + p.write(fmt.Sprintf("%d", field900)) p.newline() - field898 := unwrapped_fields896[1].(int64) - p.write(fmt.Sprintf("%d", field898)) + field901 := unwrapped_fields899[1].(int64) + p.write(fmt.Sprintf("%d", field901)) p.newline() - field899 := unwrapped_fields896[2].(int64) - p.write(fmt.Sprintf("%d", field899)) + field902 := unwrapped_fields899[2].(int64) + p.write(fmt.Sprintf("%d", field902)) p.dedent() p.write(")") } @@ -917,40 +921,40 @@ func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { - flat911 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) - if flat911 != nil { - p.write(*flat911) + flat914 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) + if flat914 != nil { + p.write(*flat914) return nil } else { _dollar_dollar := msg - fields901 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay()), int64(_dollar_dollar.GetHour()), int64(_dollar_dollar.GetMinute()), int64(_dollar_dollar.GetSecond()), ptr(int64(_dollar_dollar.GetMicrosecond()))} - unwrapped_fields902 := fields901 + fields904 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay()), int64(_dollar_dollar.GetHour()), int64(_dollar_dollar.GetMinute()), int64(_dollar_dollar.GetSecond()), ptr(int64(_dollar_dollar.GetMicrosecond()))} + unwrapped_fields905 := fields904 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field903 := unwrapped_fields902[0].(int64) - p.write(fmt.Sprintf("%d", field903)) - p.newline() - field904 := unwrapped_fields902[1].(int64) - p.write(fmt.Sprintf("%d", field904)) - p.newline() - field905 := unwrapped_fields902[2].(int64) - p.write(fmt.Sprintf("%d", field905)) - p.newline() - field906 := unwrapped_fields902[3].(int64) + field906 := unwrapped_fields905[0].(int64) p.write(fmt.Sprintf("%d", field906)) p.newline() - field907 := unwrapped_fields902[4].(int64) + field907 := unwrapped_fields905[1].(int64) p.write(fmt.Sprintf("%d", field907)) p.newline() - field908 := unwrapped_fields902[5].(int64) + field908 := unwrapped_fields905[2].(int64) p.write(fmt.Sprintf("%d", field908)) - field909 := unwrapped_fields902[6].(*int64) - if field909 != nil { + p.newline() + field909 := unwrapped_fields905[3].(int64) + p.write(fmt.Sprintf("%d", field909)) + p.newline() + field910 := unwrapped_fields905[4].(int64) + p.write(fmt.Sprintf("%d", field910)) + p.newline() + field911 := unwrapped_fields905[5].(int64) + p.write(fmt.Sprintf("%d", field911)) + field912 := unwrapped_fields905[6].(*int64) + if field912 != nil { p.newline() - opt_val910 := *field909 - p.write(fmt.Sprintf("%d", opt_val910)) + opt_val913 := *field912 + p.write(fmt.Sprintf("%d", opt_val913)) } p.dedent() p.write(")") @@ -960,25 +964,25 @@ func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { _dollar_dollar := msg - var _t1709 []interface{} + var _t1715 []interface{} if _dollar_dollar { - _t1709 = []interface{}{} + _t1715 = []interface{}{} } - deconstruct_result914 := _t1709 - if deconstruct_result914 != nil { - unwrapped915 := deconstruct_result914 - _ = unwrapped915 + deconstruct_result917 := _t1715 + if deconstruct_result917 != nil { + unwrapped918 := deconstruct_result917 + _ = unwrapped918 p.write("true") } else { _dollar_dollar := msg - var _t1710 []interface{} + var _t1716 []interface{} if !(_dollar_dollar) { - _t1710 = []interface{}{} + _t1716 = []interface{}{} } - deconstruct_result912 := _t1710 - if deconstruct_result912 != nil { - unwrapped913 := deconstruct_result912 - _ = unwrapped913 + deconstruct_result915 := _t1716 + if deconstruct_result915 != nil { + unwrapped916 := deconstruct_result915 + _ = unwrapped916 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -988,24 +992,24 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - flat920 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat920 != nil { - p.write(*flat920) + flat923 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat923 != nil { + p.write(*flat923) return nil } else { _dollar_dollar := msg - fields916 := _dollar_dollar.GetFragments() - unwrapped_fields917 := fields916 + fields919 := _dollar_dollar.GetFragments() + unwrapped_fields920 := fields919 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields917) == 0) { + if !(len(unwrapped_fields920) == 0) { p.newline() - for i919, elem918 := range unwrapped_fields917 { - if (i919 > 0) { + for i922, elem921 := range unwrapped_fields920 { + if (i922 > 0) { p.newline() } - p.pretty_fragment_id(elem918) + p.pretty_fragment_id(elem921) } } p.dedent() @@ -1015,51 +1019,51 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - flat923 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat923 != nil { - p.write(*flat923) + flat926 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat926 != nil { + p.write(*flat926) return nil } else { _dollar_dollar := msg - fields921 := p.fragmentIdToString(_dollar_dollar) - unwrapped_fields922 := fields921 + fields924 := p.fragmentIdToString(_dollar_dollar) + unwrapped_fields925 := fields924 p.write(":") - p.write(unwrapped_fields922) + p.write(unwrapped_fields925) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - flat930 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat930 != nil { - p.write(*flat930) + flat933 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat933 != nil { + p.write(*flat933) return nil } else { _dollar_dollar := msg - var _t1711 []*pb.Write + var _t1717 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1711 = _dollar_dollar.GetWrites() + _t1717 = _dollar_dollar.GetWrites() } - var _t1712 []*pb.Read + var _t1718 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1712 = _dollar_dollar.GetReads() + _t1718 = _dollar_dollar.GetReads() } - fields924 := []interface{}{_t1711, _t1712} - unwrapped_fields925 := fields924 + fields927 := []interface{}{_t1717, _t1718} + unwrapped_fields928 := fields927 p.write("(") p.write("epoch") p.indentSexp() - field926 := unwrapped_fields925[0].([]*pb.Write) - if field926 != nil { + field929 := unwrapped_fields928[0].([]*pb.Write) + if field929 != nil { p.newline() - opt_val927 := field926 - p.pretty_epoch_writes(opt_val927) + opt_val930 := field929 + p.pretty_epoch_writes(opt_val930) } - field928 := unwrapped_fields925[1].([]*pb.Read) - if field928 != nil { + field931 := unwrapped_fields928[1].([]*pb.Read) + if field931 != nil { p.newline() - opt_val929 := field928 - p.pretty_epoch_reads(opt_val929) + opt_val932 := field931 + p.pretty_epoch_reads(opt_val932) } p.dedent() p.write(")") @@ -1068,22 +1072,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - flat934 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat934 != nil { - p.write(*flat934) + flat937 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat937 != nil { + p.write(*flat937) return nil } else { - fields931 := msg + fields934 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields931) == 0) { + if !(len(fields934) == 0) { p.newline() - for i933, elem932 := range fields931 { - if (i933 > 0) { + for i936, elem935 := range fields934 { + if (i936 > 0) { p.newline() } - p.pretty_write(elem932) + p.pretty_write(elem935) } } p.dedent() @@ -1093,50 +1097,50 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat943 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat943 != nil { - p.write(*flat943) + flat946 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat946 != nil { + p.write(*flat946) return nil } else { _dollar_dollar := msg - var _t1713 *pb.Define + var _t1719 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1713 = _dollar_dollar.GetDefine() + _t1719 = _dollar_dollar.GetDefine() } - deconstruct_result941 := _t1713 - if deconstruct_result941 != nil { - unwrapped942 := deconstruct_result941 - p.pretty_define(unwrapped942) + deconstruct_result944 := _t1719 + if deconstruct_result944 != nil { + unwrapped945 := deconstruct_result944 + p.pretty_define(unwrapped945) } else { _dollar_dollar := msg - var _t1714 *pb.Undefine + var _t1720 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1714 = _dollar_dollar.GetUndefine() + _t1720 = _dollar_dollar.GetUndefine() } - deconstruct_result939 := _t1714 - if deconstruct_result939 != nil { - unwrapped940 := deconstruct_result939 - p.pretty_undefine(unwrapped940) + deconstruct_result942 := _t1720 + if deconstruct_result942 != nil { + unwrapped943 := deconstruct_result942 + p.pretty_undefine(unwrapped943) } else { _dollar_dollar := msg - var _t1715 *pb.Context + var _t1721 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1715 = _dollar_dollar.GetContext() + _t1721 = _dollar_dollar.GetContext() } - deconstruct_result937 := _t1715 - if deconstruct_result937 != nil { - unwrapped938 := deconstruct_result937 - p.pretty_context(unwrapped938) + deconstruct_result940 := _t1721 + if deconstruct_result940 != nil { + unwrapped941 := deconstruct_result940 + p.pretty_context(unwrapped941) } else { _dollar_dollar := msg - var _t1716 *pb.Snapshot + var _t1722 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1716 = _dollar_dollar.GetSnapshot() + _t1722 = _dollar_dollar.GetSnapshot() } - deconstruct_result935 := _t1716 - if deconstruct_result935 != nil { - unwrapped936 := deconstruct_result935 - p.pretty_snapshot(unwrapped936) + deconstruct_result938 := _t1722 + if deconstruct_result938 != nil { + unwrapped939 := deconstruct_result938 + p.pretty_snapshot(unwrapped939) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1148,19 +1152,19 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - flat946 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat946 != nil { - p.write(*flat946) + flat949 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat949 != nil { + p.write(*flat949) return nil } else { _dollar_dollar := msg - fields944 := _dollar_dollar.GetFragment() - unwrapped_fields945 := fields944 + fields947 := _dollar_dollar.GetFragment() + unwrapped_fields948 := fields947 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields945) + p.pretty_fragment(unwrapped_fields948) p.dedent() p.write(")") } @@ -1168,29 +1172,29 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat953 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat953 != nil { - p.write(*flat953) + flat956 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat956 != nil { + p.write(*flat956) return nil } else { _dollar_dollar := msg p.startPrettyFragment(_dollar_dollar) - fields947 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} - unwrapped_fields948 := fields947 + fields950 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} + unwrapped_fields951 := fields950 p.write("(") p.write("fragment") p.indentSexp() p.newline() - field949 := unwrapped_fields948[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field949) - field950 := unwrapped_fields948[1].([]*pb.Declaration) - if !(len(field950) == 0) { + field952 := unwrapped_fields951[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field952) + field953 := unwrapped_fields951[1].([]*pb.Declaration) + if !(len(field953) == 0) { p.newline() - for i952, elem951 := range field950 { - if (i952 > 0) { + for i955, elem954 := range field953 { + if (i955 > 0) { p.newline() } - p.pretty_declaration(elem951) + p.pretty_declaration(elem954) } } p.dedent() @@ -1200,62 +1204,62 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - flat955 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat955 != nil { - p.write(*flat955) + flat958 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat958 != nil { + p.write(*flat958) return nil } else { - fields954 := msg - p.pretty_fragment_id(fields954) + fields957 := msg + p.pretty_fragment_id(fields957) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - flat964 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat964 != nil { - p.write(*flat964) + flat967 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat967 != nil { + p.write(*flat967) return nil } else { _dollar_dollar := msg - var _t1717 *pb.Def + var _t1723 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1717 = _dollar_dollar.GetDef() + _t1723 = _dollar_dollar.GetDef() } - deconstruct_result962 := _t1717 - if deconstruct_result962 != nil { - unwrapped963 := deconstruct_result962 - p.pretty_def(unwrapped963) + deconstruct_result965 := _t1723 + if deconstruct_result965 != nil { + unwrapped966 := deconstruct_result965 + p.pretty_def(unwrapped966) } else { _dollar_dollar := msg - var _t1718 *pb.Algorithm + var _t1724 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1718 = _dollar_dollar.GetAlgorithm() + _t1724 = _dollar_dollar.GetAlgorithm() } - deconstruct_result960 := _t1718 - if deconstruct_result960 != nil { - unwrapped961 := deconstruct_result960 - p.pretty_algorithm(unwrapped961) + deconstruct_result963 := _t1724 + if deconstruct_result963 != nil { + unwrapped964 := deconstruct_result963 + p.pretty_algorithm(unwrapped964) } else { _dollar_dollar := msg - var _t1719 *pb.Constraint + var _t1725 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1719 = _dollar_dollar.GetConstraint() + _t1725 = _dollar_dollar.GetConstraint() } - deconstruct_result958 := _t1719 - if deconstruct_result958 != nil { - unwrapped959 := deconstruct_result958 - p.pretty_constraint(unwrapped959) + deconstruct_result961 := _t1725 + if deconstruct_result961 != nil { + unwrapped962 := deconstruct_result961 + p.pretty_constraint(unwrapped962) } else { _dollar_dollar := msg - var _t1720 *pb.Data + var _t1726 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1720 = _dollar_dollar.GetData() + _t1726 = _dollar_dollar.GetData() } - deconstruct_result956 := _t1720 - if deconstruct_result956 != nil { - unwrapped957 := deconstruct_result956 - p.pretty_data(unwrapped957) + deconstruct_result959 := _t1726 + if deconstruct_result959 != nil { + unwrapped960 := deconstruct_result959 + p.pretty_data(unwrapped960) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1267,32 +1271,32 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - flat971 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat971 != nil { - p.write(*flat971) + flat974 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat974 != nil { + p.write(*flat974) return nil } else { _dollar_dollar := msg - var _t1721 []*pb.Attribute + var _t1727 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1721 = _dollar_dollar.GetAttrs() + _t1727 = _dollar_dollar.GetAttrs() } - fields965 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1721} - unwrapped_fields966 := fields965 + fields968 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1727} + unwrapped_fields969 := fields968 p.write("(") p.write("def") p.indentSexp() p.newline() - field967 := unwrapped_fields966[0].(*pb.RelationId) - p.pretty_relation_id(field967) + field970 := unwrapped_fields969[0].(*pb.RelationId) + p.pretty_relation_id(field970) p.newline() - field968 := unwrapped_fields966[1].(*pb.Abstraction) - p.pretty_abstraction(field968) - field969 := unwrapped_fields966[2].([]*pb.Attribute) - if field969 != nil { + field971 := unwrapped_fields969[1].(*pb.Abstraction) + p.pretty_abstraction(field971) + field972 := unwrapped_fields969[2].([]*pb.Attribute) + if field972 != nil { p.newline() - opt_val970 := field969 - p.pretty_attrs(opt_val970) + opt_val973 := field972 + p.pretty_attrs(opt_val973) } p.dedent() p.write(")") @@ -1301,29 +1305,29 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - flat976 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat976 != nil { - p.write(*flat976) + flat979 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat979 != nil { + p.write(*flat979) return nil } else { _dollar_dollar := msg - var _t1722 *string + var _t1728 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1723 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1722 = ptr(_t1723) + _t1729 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1728 = ptr(_t1729) } - deconstruct_result974 := _t1722 - if deconstruct_result974 != nil { - unwrapped975 := *deconstruct_result974 + deconstruct_result977 := _t1728 + if deconstruct_result977 != nil { + unwrapped978 := *deconstruct_result977 p.write(":") - p.write(unwrapped975) + p.write(unwrapped978) } else { _dollar_dollar := msg - _t1724 := p.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result972 := _t1724 - if deconstruct_result972 != nil { - unwrapped973 := deconstruct_result972 - p.write(p.formatUint128(unwrapped973)) + _t1730 := p.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result975 := _t1730 + if deconstruct_result975 != nil { + unwrapped976 := deconstruct_result975 + p.write(p.formatUint128(unwrapped976)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -1333,22 +1337,22 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - flat981 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat981 != nil { - p.write(*flat981) + flat984 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat984 != nil { + p.write(*flat984) return nil } else { _dollar_dollar := msg - _t1725 := p.deconstruct_bindings(_dollar_dollar) - fields977 := []interface{}{_t1725, _dollar_dollar.GetValue()} - unwrapped_fields978 := fields977 + _t1731 := p.deconstruct_bindings(_dollar_dollar) + fields980 := []interface{}{_t1731, _dollar_dollar.GetValue()} + unwrapped_fields981 := fields980 p.write("(") p.indent() - field979 := unwrapped_fields978[0].([]interface{}) - p.pretty_bindings(field979) + field982 := unwrapped_fields981[0].([]interface{}) + p.pretty_bindings(field982) p.newline() - field980 := unwrapped_fields978[1].(*pb.Formula) - p.pretty_formula(field980) + field983 := unwrapped_fields981[1].(*pb.Formula) + p.pretty_formula(field983) p.dedent() p.write(")") } @@ -1356,32 +1360,32 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - flat989 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat989 != nil { - p.write(*flat989) + flat992 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat992 != nil { + p.write(*flat992) return nil } else { _dollar_dollar := msg - var _t1726 []*pb.Binding + var _t1732 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1726 = _dollar_dollar[1].([]*pb.Binding) + _t1732 = _dollar_dollar[1].([]*pb.Binding) } - fields982 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1726} - unwrapped_fields983 := fields982 + fields985 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1732} + unwrapped_fields986 := fields985 p.write("[") p.indent() - field984 := unwrapped_fields983[0].([]*pb.Binding) - for i986, elem985 := range field984 { - if (i986 > 0) { + field987 := unwrapped_fields986[0].([]*pb.Binding) + for i989, elem988 := range field987 { + if (i989 > 0) { p.newline() } - p.pretty_binding(elem985) + p.pretty_binding(elem988) } - field987 := unwrapped_fields983[1].([]*pb.Binding) - if field987 != nil { + field990 := unwrapped_fields986[1].([]*pb.Binding) + if field990 != nil { p.newline() - opt_val988 := field987 - p.pretty_value_bindings(opt_val988) + opt_val991 := field990 + p.pretty_value_bindings(opt_val991) } p.dedent() p.write("]") @@ -1390,168 +1394,168 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - flat994 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat994 != nil { - p.write(*flat994) + flat997 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat997 != nil { + p.write(*flat997) return nil } else { _dollar_dollar := msg - fields990 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} - unwrapped_fields991 := fields990 - field992 := unwrapped_fields991[0].(string) - p.write(field992) + fields993 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} + unwrapped_fields994 := fields993 + field995 := unwrapped_fields994[0].(string) + p.write(field995) p.write("::") - field993 := unwrapped_fields991[1].(*pb.Type) - p.pretty_type(field993) + field996 := unwrapped_fields994[1].(*pb.Type) + p.pretty_type(field996) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - flat1023 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat1023 != nil { - p.write(*flat1023) + flat1026 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat1026 != nil { + p.write(*flat1026) return nil } else { _dollar_dollar := msg - var _t1727 *pb.UnspecifiedType + var _t1733 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1727 = _dollar_dollar.GetUnspecifiedType() + _t1733 = _dollar_dollar.GetUnspecifiedType() } - deconstruct_result1021 := _t1727 - if deconstruct_result1021 != nil { - unwrapped1022 := deconstruct_result1021 - p.pretty_unspecified_type(unwrapped1022) + deconstruct_result1024 := _t1733 + if deconstruct_result1024 != nil { + unwrapped1025 := deconstruct_result1024 + p.pretty_unspecified_type(unwrapped1025) } else { _dollar_dollar := msg - var _t1728 *pb.StringType + var _t1734 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1728 = _dollar_dollar.GetStringType() + _t1734 = _dollar_dollar.GetStringType() } - deconstruct_result1019 := _t1728 - if deconstruct_result1019 != nil { - unwrapped1020 := deconstruct_result1019 - p.pretty_string_type(unwrapped1020) + deconstruct_result1022 := _t1734 + if deconstruct_result1022 != nil { + unwrapped1023 := deconstruct_result1022 + p.pretty_string_type(unwrapped1023) } else { _dollar_dollar := msg - var _t1729 *pb.IntType + var _t1735 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1729 = _dollar_dollar.GetIntType() + _t1735 = _dollar_dollar.GetIntType() } - deconstruct_result1017 := _t1729 - if deconstruct_result1017 != nil { - unwrapped1018 := deconstruct_result1017 - p.pretty_int_type(unwrapped1018) + deconstruct_result1020 := _t1735 + if deconstruct_result1020 != nil { + unwrapped1021 := deconstruct_result1020 + p.pretty_int_type(unwrapped1021) } else { _dollar_dollar := msg - var _t1730 *pb.FloatType + var _t1736 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1730 = _dollar_dollar.GetFloatType() + _t1736 = _dollar_dollar.GetFloatType() } - deconstruct_result1015 := _t1730 - if deconstruct_result1015 != nil { - unwrapped1016 := deconstruct_result1015 - p.pretty_float_type(unwrapped1016) + deconstruct_result1018 := _t1736 + if deconstruct_result1018 != nil { + unwrapped1019 := deconstruct_result1018 + p.pretty_float_type(unwrapped1019) } else { _dollar_dollar := msg - var _t1731 *pb.UInt128Type + var _t1737 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1731 = _dollar_dollar.GetUint128Type() + _t1737 = _dollar_dollar.GetUint128Type() } - deconstruct_result1013 := _t1731 - if deconstruct_result1013 != nil { - unwrapped1014 := deconstruct_result1013 - p.pretty_uint128_type(unwrapped1014) + deconstruct_result1016 := _t1737 + if deconstruct_result1016 != nil { + unwrapped1017 := deconstruct_result1016 + p.pretty_uint128_type(unwrapped1017) } else { _dollar_dollar := msg - var _t1732 *pb.Int128Type + var _t1738 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1732 = _dollar_dollar.GetInt128Type() + _t1738 = _dollar_dollar.GetInt128Type() } - deconstruct_result1011 := _t1732 - if deconstruct_result1011 != nil { - unwrapped1012 := deconstruct_result1011 - p.pretty_int128_type(unwrapped1012) + deconstruct_result1014 := _t1738 + if deconstruct_result1014 != nil { + unwrapped1015 := deconstruct_result1014 + p.pretty_int128_type(unwrapped1015) } else { _dollar_dollar := msg - var _t1733 *pb.DateType + var _t1739 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1733 = _dollar_dollar.GetDateType() + _t1739 = _dollar_dollar.GetDateType() } - deconstruct_result1009 := _t1733 - if deconstruct_result1009 != nil { - unwrapped1010 := deconstruct_result1009 - p.pretty_date_type(unwrapped1010) + deconstruct_result1012 := _t1739 + if deconstruct_result1012 != nil { + unwrapped1013 := deconstruct_result1012 + p.pretty_date_type(unwrapped1013) } else { _dollar_dollar := msg - var _t1734 *pb.DateTimeType + var _t1740 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1734 = _dollar_dollar.GetDatetimeType() + _t1740 = _dollar_dollar.GetDatetimeType() } - deconstruct_result1007 := _t1734 - if deconstruct_result1007 != nil { - unwrapped1008 := deconstruct_result1007 - p.pretty_datetime_type(unwrapped1008) + deconstruct_result1010 := _t1740 + if deconstruct_result1010 != nil { + unwrapped1011 := deconstruct_result1010 + p.pretty_datetime_type(unwrapped1011) } else { _dollar_dollar := msg - var _t1735 *pb.MissingType + var _t1741 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1735 = _dollar_dollar.GetMissingType() + _t1741 = _dollar_dollar.GetMissingType() } - deconstruct_result1005 := _t1735 - if deconstruct_result1005 != nil { - unwrapped1006 := deconstruct_result1005 - p.pretty_missing_type(unwrapped1006) + deconstruct_result1008 := _t1741 + if deconstruct_result1008 != nil { + unwrapped1009 := deconstruct_result1008 + p.pretty_missing_type(unwrapped1009) } else { _dollar_dollar := msg - var _t1736 *pb.DecimalType + var _t1742 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1736 = _dollar_dollar.GetDecimalType() + _t1742 = _dollar_dollar.GetDecimalType() } - deconstruct_result1003 := _t1736 - if deconstruct_result1003 != nil { - unwrapped1004 := deconstruct_result1003 - p.pretty_decimal_type(unwrapped1004) + deconstruct_result1006 := _t1742 + if deconstruct_result1006 != nil { + unwrapped1007 := deconstruct_result1006 + p.pretty_decimal_type(unwrapped1007) } else { _dollar_dollar := msg - var _t1737 *pb.BooleanType + var _t1743 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1737 = _dollar_dollar.GetBooleanType() + _t1743 = _dollar_dollar.GetBooleanType() } - deconstruct_result1001 := _t1737 - if deconstruct_result1001 != nil { - unwrapped1002 := deconstruct_result1001 - p.pretty_boolean_type(unwrapped1002) + deconstruct_result1004 := _t1743 + if deconstruct_result1004 != nil { + unwrapped1005 := deconstruct_result1004 + p.pretty_boolean_type(unwrapped1005) } else { _dollar_dollar := msg - var _t1738 *pb.Int32Type + var _t1744 *pb.Int32Type if hasProtoField(_dollar_dollar, "int32_type") { - _t1738 = _dollar_dollar.GetInt32Type() + _t1744 = _dollar_dollar.GetInt32Type() } - deconstruct_result999 := _t1738 - if deconstruct_result999 != nil { - unwrapped1000 := deconstruct_result999 - p.pretty_int32_type(unwrapped1000) + deconstruct_result1002 := _t1744 + if deconstruct_result1002 != nil { + unwrapped1003 := deconstruct_result1002 + p.pretty_int32_type(unwrapped1003) } else { _dollar_dollar := msg - var _t1739 *pb.Float32Type + var _t1745 *pb.Float32Type if hasProtoField(_dollar_dollar, "float32_type") { - _t1739 = _dollar_dollar.GetFloat32Type() + _t1745 = _dollar_dollar.GetFloat32Type() } - deconstruct_result997 := _t1739 - if deconstruct_result997 != nil { - unwrapped998 := deconstruct_result997 - p.pretty_float32_type(unwrapped998) + deconstruct_result1000 := _t1745 + if deconstruct_result1000 != nil { + unwrapped1001 := deconstruct_result1000 + p.pretty_float32_type(unwrapped1001) } else { _dollar_dollar := msg - var _t1740 *pb.UInt32Type + var _t1746 *pb.UInt32Type if hasProtoField(_dollar_dollar, "uint32_type") { - _t1740 = _dollar_dollar.GetUint32Type() + _t1746 = _dollar_dollar.GetUint32Type() } - deconstruct_result995 := _t1740 - if deconstruct_result995 != nil { - unwrapped996 := deconstruct_result995 - p.pretty_uint32_type(unwrapped996) + deconstruct_result998 := _t1746 + if deconstruct_result998 != nil { + unwrapped999 := deconstruct_result998 + p.pretty_uint32_type(unwrapped999) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -1573,86 +1577,86 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields1024 := msg - _ = fields1024 + fields1027 := msg + _ = fields1027 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields1025 := msg - _ = fields1025 + fields1028 := msg + _ = fields1028 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields1026 := msg - _ = fields1026 + fields1029 := msg + _ = fields1029 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields1027 := msg - _ = fields1027 + fields1030 := msg + _ = fields1030 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields1028 := msg - _ = fields1028 + fields1031 := msg + _ = fields1031 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields1029 := msg - _ = fields1029 + fields1032 := msg + _ = fields1032 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields1030 := msg - _ = fields1030 + fields1033 := msg + _ = fields1033 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields1031 := msg - _ = fields1031 + fields1034 := msg + _ = fields1034 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields1032 := msg - _ = fields1032 + fields1035 := msg + _ = fields1035 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - flat1037 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat1037 != nil { - p.write(*flat1037) + flat1040 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat1040 != nil { + p.write(*flat1040) return nil } else { _dollar_dollar := msg - fields1033 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} - unwrapped_fields1034 := fields1033 + fields1036 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} + unwrapped_fields1037 := fields1036 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - field1035 := unwrapped_fields1034[0].(int64) - p.write(fmt.Sprintf("%d", field1035)) + field1038 := unwrapped_fields1037[0].(int64) + p.write(fmt.Sprintf("%d", field1038)) p.newline() - field1036 := unwrapped_fields1034[1].(int64) - p.write(fmt.Sprintf("%d", field1036)) + field1039 := unwrapped_fields1037[1].(int64) + p.write(fmt.Sprintf("%d", field1039)) p.dedent() p.write(")") } @@ -1660,48 +1664,48 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields1038 := msg - _ = fields1038 + fields1041 := msg + _ = fields1041 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_int32_type(msg *pb.Int32Type) interface{} { - fields1039 := msg - _ = fields1039 + fields1042 := msg + _ = fields1042 p.write("INT32") return nil } func (p *PrettyPrinter) pretty_float32_type(msg *pb.Float32Type) interface{} { - fields1040 := msg - _ = fields1040 + fields1043 := msg + _ = fields1043 p.write("FLOAT32") return nil } func (p *PrettyPrinter) pretty_uint32_type(msg *pb.UInt32Type) interface{} { - fields1041 := msg - _ = fields1041 + fields1044 := msg + _ = fields1044 p.write("UINT32") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - flat1045 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat1045 != nil { - p.write(*flat1045) + flat1048 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat1048 != nil { + p.write(*flat1048) return nil } else { - fields1042 := msg + fields1045 := msg p.write("|") - if !(len(fields1042) == 0) { + if !(len(fields1045) == 0) { p.write(" ") - for i1044, elem1043 := range fields1042 { - if (i1044 > 0) { + for i1047, elem1046 := range fields1045 { + if (i1047 > 0) { p.newline() } - p.pretty_binding(elem1043) + p.pretty_binding(elem1046) } } } @@ -1709,140 +1713,140 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - flat1072 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat1072 != nil { - p.write(*flat1072) + flat1075 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat1075 != nil { + p.write(*flat1075) return nil } else { _dollar_dollar := msg - var _t1741 *pb.Conjunction + var _t1747 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1741 = _dollar_dollar.GetConjunction() + _t1747 = _dollar_dollar.GetConjunction() } - deconstruct_result1070 := _t1741 - if deconstruct_result1070 != nil { - unwrapped1071 := deconstruct_result1070 - p.pretty_true(unwrapped1071) + deconstruct_result1073 := _t1747 + if deconstruct_result1073 != nil { + unwrapped1074 := deconstruct_result1073 + p.pretty_true(unwrapped1074) } else { _dollar_dollar := msg - var _t1742 *pb.Disjunction + var _t1748 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1742 = _dollar_dollar.GetDisjunction() + _t1748 = _dollar_dollar.GetDisjunction() } - deconstruct_result1068 := _t1742 - if deconstruct_result1068 != nil { - unwrapped1069 := deconstruct_result1068 - p.pretty_false(unwrapped1069) + deconstruct_result1071 := _t1748 + if deconstruct_result1071 != nil { + unwrapped1072 := deconstruct_result1071 + p.pretty_false(unwrapped1072) } else { _dollar_dollar := msg - var _t1743 *pb.Exists + var _t1749 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1743 = _dollar_dollar.GetExists() + _t1749 = _dollar_dollar.GetExists() } - deconstruct_result1066 := _t1743 - if deconstruct_result1066 != nil { - unwrapped1067 := deconstruct_result1066 - p.pretty_exists(unwrapped1067) + deconstruct_result1069 := _t1749 + if deconstruct_result1069 != nil { + unwrapped1070 := deconstruct_result1069 + p.pretty_exists(unwrapped1070) } else { _dollar_dollar := msg - var _t1744 *pb.Reduce + var _t1750 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1744 = _dollar_dollar.GetReduce() + _t1750 = _dollar_dollar.GetReduce() } - deconstruct_result1064 := _t1744 - if deconstruct_result1064 != nil { - unwrapped1065 := deconstruct_result1064 - p.pretty_reduce(unwrapped1065) + deconstruct_result1067 := _t1750 + if deconstruct_result1067 != nil { + unwrapped1068 := deconstruct_result1067 + p.pretty_reduce(unwrapped1068) } else { _dollar_dollar := msg - var _t1745 *pb.Conjunction + var _t1751 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1745 = _dollar_dollar.GetConjunction() + _t1751 = _dollar_dollar.GetConjunction() } - deconstruct_result1062 := _t1745 - if deconstruct_result1062 != nil { - unwrapped1063 := deconstruct_result1062 - p.pretty_conjunction(unwrapped1063) + deconstruct_result1065 := _t1751 + if deconstruct_result1065 != nil { + unwrapped1066 := deconstruct_result1065 + p.pretty_conjunction(unwrapped1066) } else { _dollar_dollar := msg - var _t1746 *pb.Disjunction + var _t1752 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1746 = _dollar_dollar.GetDisjunction() + _t1752 = _dollar_dollar.GetDisjunction() } - deconstruct_result1060 := _t1746 - if deconstruct_result1060 != nil { - unwrapped1061 := deconstruct_result1060 - p.pretty_disjunction(unwrapped1061) + deconstruct_result1063 := _t1752 + if deconstruct_result1063 != nil { + unwrapped1064 := deconstruct_result1063 + p.pretty_disjunction(unwrapped1064) } else { _dollar_dollar := msg - var _t1747 *pb.Not + var _t1753 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1747 = _dollar_dollar.GetNot() + _t1753 = _dollar_dollar.GetNot() } - deconstruct_result1058 := _t1747 - if deconstruct_result1058 != nil { - unwrapped1059 := deconstruct_result1058 - p.pretty_not(unwrapped1059) + deconstruct_result1061 := _t1753 + if deconstruct_result1061 != nil { + unwrapped1062 := deconstruct_result1061 + p.pretty_not(unwrapped1062) } else { _dollar_dollar := msg - var _t1748 *pb.FFI + var _t1754 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1748 = _dollar_dollar.GetFfi() + _t1754 = _dollar_dollar.GetFfi() } - deconstruct_result1056 := _t1748 - if deconstruct_result1056 != nil { - unwrapped1057 := deconstruct_result1056 - p.pretty_ffi(unwrapped1057) + deconstruct_result1059 := _t1754 + if deconstruct_result1059 != nil { + unwrapped1060 := deconstruct_result1059 + p.pretty_ffi(unwrapped1060) } else { _dollar_dollar := msg - var _t1749 *pb.Atom + var _t1755 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1749 = _dollar_dollar.GetAtom() + _t1755 = _dollar_dollar.GetAtom() } - deconstruct_result1054 := _t1749 - if deconstruct_result1054 != nil { - unwrapped1055 := deconstruct_result1054 - p.pretty_atom(unwrapped1055) + deconstruct_result1057 := _t1755 + if deconstruct_result1057 != nil { + unwrapped1058 := deconstruct_result1057 + p.pretty_atom(unwrapped1058) } else { _dollar_dollar := msg - var _t1750 *pb.Pragma + var _t1756 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1750 = _dollar_dollar.GetPragma() + _t1756 = _dollar_dollar.GetPragma() } - deconstruct_result1052 := _t1750 - if deconstruct_result1052 != nil { - unwrapped1053 := deconstruct_result1052 - p.pretty_pragma(unwrapped1053) + deconstruct_result1055 := _t1756 + if deconstruct_result1055 != nil { + unwrapped1056 := deconstruct_result1055 + p.pretty_pragma(unwrapped1056) } else { _dollar_dollar := msg - var _t1751 *pb.Primitive + var _t1757 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1751 = _dollar_dollar.GetPrimitive() + _t1757 = _dollar_dollar.GetPrimitive() } - deconstruct_result1050 := _t1751 - if deconstruct_result1050 != nil { - unwrapped1051 := deconstruct_result1050 - p.pretty_primitive(unwrapped1051) + deconstruct_result1053 := _t1757 + if deconstruct_result1053 != nil { + unwrapped1054 := deconstruct_result1053 + p.pretty_primitive(unwrapped1054) } else { _dollar_dollar := msg - var _t1752 *pb.RelAtom + var _t1758 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1752 = _dollar_dollar.GetRelAtom() + _t1758 = _dollar_dollar.GetRelAtom() } - deconstruct_result1048 := _t1752 - if deconstruct_result1048 != nil { - unwrapped1049 := deconstruct_result1048 - p.pretty_rel_atom(unwrapped1049) + deconstruct_result1051 := _t1758 + if deconstruct_result1051 != nil { + unwrapped1052 := deconstruct_result1051 + p.pretty_rel_atom(unwrapped1052) } else { _dollar_dollar := msg - var _t1753 *pb.Cast + var _t1759 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1753 = _dollar_dollar.GetCast() + _t1759 = _dollar_dollar.GetCast() } - deconstruct_result1046 := _t1753 - if deconstruct_result1046 != nil { - unwrapped1047 := deconstruct_result1046 - p.pretty_cast(unwrapped1047) + deconstruct_result1049 := _t1759 + if deconstruct_result1049 != nil { + unwrapped1050 := deconstruct_result1049 + p.pretty_cast(unwrapped1050) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1863,8 +1867,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields1073 := msg - _ = fields1073 + fields1076 := msg + _ = fields1076 p.write("(") p.write("true") p.write(")") @@ -1872,8 +1876,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields1074 := msg - _ = fields1074 + fields1077 := msg + _ = fields1077 p.write("(") p.write("false") p.write(")") @@ -1881,24 +1885,24 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - flat1079 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat1079 != nil { - p.write(*flat1079) + flat1082 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat1082 != nil { + p.write(*flat1082) return nil } else { _dollar_dollar := msg - _t1754 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - fields1075 := []interface{}{_t1754, _dollar_dollar.GetBody().GetValue()} - unwrapped_fields1076 := fields1075 + _t1760 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + fields1078 := []interface{}{_t1760, _dollar_dollar.GetBody().GetValue()} + unwrapped_fields1079 := fields1078 p.write("(") p.write("exists") p.indentSexp() p.newline() - field1077 := unwrapped_fields1076[0].([]interface{}) - p.pretty_bindings(field1077) + field1080 := unwrapped_fields1079[0].([]interface{}) + p.pretty_bindings(field1080) p.newline() - field1078 := unwrapped_fields1076[1].(*pb.Formula) - p.pretty_formula(field1078) + field1081 := unwrapped_fields1079[1].(*pb.Formula) + p.pretty_formula(field1081) p.dedent() p.write(")") } @@ -1906,26 +1910,26 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat1085 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat1085 != nil { - p.write(*flat1085) + flat1088 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat1088 != nil { + p.write(*flat1088) return nil } else { _dollar_dollar := msg - fields1080 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} - unwrapped_fields1081 := fields1080 + fields1083 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} + unwrapped_fields1084 := fields1083 p.write("(") p.write("reduce") p.indentSexp() p.newline() - field1082 := unwrapped_fields1081[0].(*pb.Abstraction) - p.pretty_abstraction(field1082) + field1085 := unwrapped_fields1084[0].(*pb.Abstraction) + p.pretty_abstraction(field1085) p.newline() - field1083 := unwrapped_fields1081[1].(*pb.Abstraction) - p.pretty_abstraction(field1083) + field1086 := unwrapped_fields1084[1].(*pb.Abstraction) + p.pretty_abstraction(field1086) p.newline() - field1084 := unwrapped_fields1081[2].([]*pb.Term) - p.pretty_terms(field1084) + field1087 := unwrapped_fields1084[2].([]*pb.Term) + p.pretty_terms(field1087) p.dedent() p.write(")") } @@ -1933,22 +1937,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - flat1089 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat1089 != nil { - p.write(*flat1089) + flat1092 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat1092 != nil { + p.write(*flat1092) return nil } else { - fields1086 := msg + fields1089 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields1086) == 0) { + if !(len(fields1089) == 0) { p.newline() - for i1088, elem1087 := range fields1086 { - if (i1088 > 0) { + for i1091, elem1090 := range fields1089 { + if (i1091 > 0) { p.newline() } - p.pretty_term(elem1087) + p.pretty_term(elem1090) } } p.dedent() @@ -1958,30 +1962,30 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat1094 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat1094 != nil { - p.write(*flat1094) + flat1097 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat1097 != nil { + p.write(*flat1097) return nil } else { _dollar_dollar := msg - var _t1755 *pb.Var + var _t1761 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1755 = _dollar_dollar.GetVar() + _t1761 = _dollar_dollar.GetVar() } - deconstruct_result1092 := _t1755 - if deconstruct_result1092 != nil { - unwrapped1093 := deconstruct_result1092 - p.pretty_var(unwrapped1093) + deconstruct_result1095 := _t1761 + if deconstruct_result1095 != nil { + unwrapped1096 := deconstruct_result1095 + p.pretty_var(unwrapped1096) } else { _dollar_dollar := msg - var _t1756 *pb.Value + var _t1762 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1756 = _dollar_dollar.GetConstant() + _t1762 = _dollar_dollar.GetConstant() } - deconstruct_result1090 := _t1756 - if deconstruct_result1090 != nil { - unwrapped1091 := deconstruct_result1090 - p.pretty_value(unwrapped1091) + deconstruct_result1093 := _t1762 + if deconstruct_result1093 != nil { + unwrapped1094 := deconstruct_result1093 + p.pretty_value(unwrapped1094) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -1991,147 +1995,147 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - flat1097 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat1097 != nil { - p.write(*flat1097) + flat1100 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat1100 != nil { + p.write(*flat1100) return nil } else { _dollar_dollar := msg - fields1095 := _dollar_dollar.GetName() - unwrapped_fields1096 := fields1095 - p.write(unwrapped_fields1096) + fields1098 := _dollar_dollar.GetName() + unwrapped_fields1099 := fields1098 + p.write(unwrapped_fields1099) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat1123 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat1123 != nil { - p.write(*flat1123) + flat1126 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat1126 != nil { + p.write(*flat1126) return nil } else { _dollar_dollar := msg - var _t1757 *pb.DateValue + var _t1763 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1757 = _dollar_dollar.GetDateValue() + _t1763 = _dollar_dollar.GetDateValue() } - deconstruct_result1121 := _t1757 - if deconstruct_result1121 != nil { - unwrapped1122 := deconstruct_result1121 - p.pretty_date(unwrapped1122) + deconstruct_result1124 := _t1763 + if deconstruct_result1124 != nil { + unwrapped1125 := deconstruct_result1124 + p.pretty_date(unwrapped1125) } else { _dollar_dollar := msg - var _t1758 *pb.DateTimeValue + var _t1764 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1758 = _dollar_dollar.GetDatetimeValue() + _t1764 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result1119 := _t1758 - if deconstruct_result1119 != nil { - unwrapped1120 := deconstruct_result1119 - p.pretty_datetime(unwrapped1120) + deconstruct_result1122 := _t1764 + if deconstruct_result1122 != nil { + unwrapped1123 := deconstruct_result1122 + p.pretty_datetime(unwrapped1123) } else { _dollar_dollar := msg - var _t1759 *string + var _t1765 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1759 = ptr(_dollar_dollar.GetStringValue()) + _t1765 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result1117 := _t1759 - if deconstruct_result1117 != nil { - unwrapped1118 := *deconstruct_result1117 - p.write(p.formatStringValue(unwrapped1118)) + deconstruct_result1120 := _t1765 + if deconstruct_result1120 != nil { + unwrapped1121 := *deconstruct_result1120 + p.write(p.formatStringValue(unwrapped1121)) } else { _dollar_dollar := msg - var _t1760 *int32 + var _t1766 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1760 = ptr(_dollar_dollar.GetInt32Value()) + _t1766 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result1115 := _t1760 - if deconstruct_result1115 != nil { - unwrapped1116 := *deconstruct_result1115 - p.write(fmt.Sprintf("%di32", unwrapped1116)) + deconstruct_result1118 := _t1766 + if deconstruct_result1118 != nil { + unwrapped1119 := *deconstruct_result1118 + p.write(fmt.Sprintf("%di32", unwrapped1119)) } else { _dollar_dollar := msg - var _t1761 *int64 + var _t1767 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1761 = ptr(_dollar_dollar.GetIntValue()) + _t1767 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result1113 := _t1761 - if deconstruct_result1113 != nil { - unwrapped1114 := *deconstruct_result1113 - p.write(fmt.Sprintf("%d", unwrapped1114)) + deconstruct_result1116 := _t1767 + if deconstruct_result1116 != nil { + unwrapped1117 := *deconstruct_result1116 + p.write(fmt.Sprintf("%d", unwrapped1117)) } else { _dollar_dollar := msg - var _t1762 *float32 + var _t1768 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1762 = ptr(_dollar_dollar.GetFloat32Value()) + _t1768 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result1111 := _t1762 - if deconstruct_result1111 != nil { - unwrapped1112 := *deconstruct_result1111 - p.write(formatFloat32(unwrapped1112)) + deconstruct_result1114 := _t1768 + if deconstruct_result1114 != nil { + unwrapped1115 := *deconstruct_result1114 + p.write(formatFloat32(unwrapped1115)) } else { _dollar_dollar := msg - var _t1763 *float64 + var _t1769 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1763 = ptr(_dollar_dollar.GetFloatValue()) + _t1769 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result1109 := _t1763 - if deconstruct_result1109 != nil { - unwrapped1110 := *deconstruct_result1109 - p.write(formatFloat64(unwrapped1110)) + deconstruct_result1112 := _t1769 + if deconstruct_result1112 != nil { + unwrapped1113 := *deconstruct_result1112 + p.write(formatFloat64(unwrapped1113)) } else { _dollar_dollar := msg - var _t1764 *uint32 + var _t1770 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1764 = ptr(_dollar_dollar.GetUint32Value()) + _t1770 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result1107 := _t1764 - if deconstruct_result1107 != nil { - unwrapped1108 := *deconstruct_result1107 - p.write(fmt.Sprintf("%du32", unwrapped1108)) + deconstruct_result1110 := _t1770 + if deconstruct_result1110 != nil { + unwrapped1111 := *deconstruct_result1110 + p.write(fmt.Sprintf("%du32", unwrapped1111)) } else { _dollar_dollar := msg - var _t1765 *pb.UInt128Value + var _t1771 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1765 = _dollar_dollar.GetUint128Value() + _t1771 = _dollar_dollar.GetUint128Value() } - deconstruct_result1105 := _t1765 - if deconstruct_result1105 != nil { - unwrapped1106 := deconstruct_result1105 - p.write(p.formatUint128(unwrapped1106)) + deconstruct_result1108 := _t1771 + if deconstruct_result1108 != nil { + unwrapped1109 := deconstruct_result1108 + p.write(p.formatUint128(unwrapped1109)) } else { _dollar_dollar := msg - var _t1766 *pb.Int128Value + var _t1772 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1766 = _dollar_dollar.GetInt128Value() + _t1772 = _dollar_dollar.GetInt128Value() } - deconstruct_result1103 := _t1766 - if deconstruct_result1103 != nil { - unwrapped1104 := deconstruct_result1103 - p.write(p.formatInt128(unwrapped1104)) + deconstruct_result1106 := _t1772 + if deconstruct_result1106 != nil { + unwrapped1107 := deconstruct_result1106 + p.write(p.formatInt128(unwrapped1107)) } else { _dollar_dollar := msg - var _t1767 *pb.DecimalValue + var _t1773 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1767 = _dollar_dollar.GetDecimalValue() + _t1773 = _dollar_dollar.GetDecimalValue() } - deconstruct_result1101 := _t1767 - if deconstruct_result1101 != nil { - unwrapped1102 := deconstruct_result1101 - p.write(p.formatDecimal(unwrapped1102)) + deconstruct_result1104 := _t1773 + if deconstruct_result1104 != nil { + unwrapped1105 := deconstruct_result1104 + p.write(p.formatDecimal(unwrapped1105)) } else { _dollar_dollar := msg - var _t1768 *bool + var _t1774 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1768 = ptr(_dollar_dollar.GetBooleanValue()) + _t1774 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result1099 := _t1768 - if deconstruct_result1099 != nil { - unwrapped1100 := *deconstruct_result1099 - p.pretty_boolean_value(unwrapped1100) + deconstruct_result1102 := _t1774 + if deconstruct_result1102 != nil { + unwrapped1103 := *deconstruct_result1102 + p.pretty_boolean_value(unwrapped1103) } else { - fields1098 := msg - _ = fields1098 + fields1101 := msg + _ = fields1101 p.write("missing") } } @@ -2150,26 +2154,26 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - flat1129 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat1129 != nil { - p.write(*flat1129) + flat1132 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat1132 != nil { + p.write(*flat1132) return nil } else { _dollar_dollar := msg - fields1124 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields1125 := fields1124 + fields1127 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields1128 := fields1127 p.write("(") p.write("date") p.indentSexp() p.newline() - field1126 := unwrapped_fields1125[0].(int64) - p.write(fmt.Sprintf("%d", field1126)) + field1129 := unwrapped_fields1128[0].(int64) + p.write(fmt.Sprintf("%d", field1129)) p.newline() - field1127 := unwrapped_fields1125[1].(int64) - p.write(fmt.Sprintf("%d", field1127)) + field1130 := unwrapped_fields1128[1].(int64) + p.write(fmt.Sprintf("%d", field1130)) p.newline() - field1128 := unwrapped_fields1125[2].(int64) - p.write(fmt.Sprintf("%d", field1128)) + field1131 := unwrapped_fields1128[2].(int64) + p.write(fmt.Sprintf("%d", field1131)) p.dedent() p.write(")") } @@ -2177,40 +2181,40 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - flat1140 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat1140 != nil { - p.write(*flat1140) + flat1143 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat1143 != nil { + p.write(*flat1143) return nil } else { _dollar_dollar := msg - fields1130 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay()), int64(_dollar_dollar.GetHour()), int64(_dollar_dollar.GetMinute()), int64(_dollar_dollar.GetSecond()), ptr(int64(_dollar_dollar.GetMicrosecond()))} - unwrapped_fields1131 := fields1130 + fields1133 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay()), int64(_dollar_dollar.GetHour()), int64(_dollar_dollar.GetMinute()), int64(_dollar_dollar.GetSecond()), ptr(int64(_dollar_dollar.GetMicrosecond()))} + unwrapped_fields1134 := fields1133 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field1132 := unwrapped_fields1131[0].(int64) - p.write(fmt.Sprintf("%d", field1132)) - p.newline() - field1133 := unwrapped_fields1131[1].(int64) - p.write(fmt.Sprintf("%d", field1133)) - p.newline() - field1134 := unwrapped_fields1131[2].(int64) - p.write(fmt.Sprintf("%d", field1134)) - p.newline() - field1135 := unwrapped_fields1131[3].(int64) + field1135 := unwrapped_fields1134[0].(int64) p.write(fmt.Sprintf("%d", field1135)) p.newline() - field1136 := unwrapped_fields1131[4].(int64) + field1136 := unwrapped_fields1134[1].(int64) p.write(fmt.Sprintf("%d", field1136)) p.newline() - field1137 := unwrapped_fields1131[5].(int64) + field1137 := unwrapped_fields1134[2].(int64) p.write(fmt.Sprintf("%d", field1137)) - field1138 := unwrapped_fields1131[6].(*int64) - if field1138 != nil { + p.newline() + field1138 := unwrapped_fields1134[3].(int64) + p.write(fmt.Sprintf("%d", field1138)) + p.newline() + field1139 := unwrapped_fields1134[4].(int64) + p.write(fmt.Sprintf("%d", field1139)) + p.newline() + field1140 := unwrapped_fields1134[5].(int64) + p.write(fmt.Sprintf("%d", field1140)) + field1141 := unwrapped_fields1134[6].(*int64) + if field1141 != nil { p.newline() - opt_val1139 := *field1138 - p.write(fmt.Sprintf("%d", opt_val1139)) + opt_val1142 := *field1141 + p.write(fmt.Sprintf("%d", opt_val1142)) } p.dedent() p.write(")") @@ -2219,24 +2223,24 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat1145 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat1145 != nil { - p.write(*flat1145) + flat1148 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat1148 != nil { + p.write(*flat1148) return nil } else { _dollar_dollar := msg - fields1141 := _dollar_dollar.GetArgs() - unwrapped_fields1142 := fields1141 + fields1144 := _dollar_dollar.GetArgs() + unwrapped_fields1145 := fields1144 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields1142) == 0) { + if !(len(unwrapped_fields1145) == 0) { p.newline() - for i1144, elem1143 := range unwrapped_fields1142 { - if (i1144 > 0) { + for i1147, elem1146 := range unwrapped_fields1145 { + if (i1147 > 0) { p.newline() } - p.pretty_formula(elem1143) + p.pretty_formula(elem1146) } } p.dedent() @@ -2246,24 +2250,24 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat1150 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat1150 != nil { - p.write(*flat1150) + flat1153 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat1153 != nil { + p.write(*flat1153) return nil } else { _dollar_dollar := msg - fields1146 := _dollar_dollar.GetArgs() - unwrapped_fields1147 := fields1146 + fields1149 := _dollar_dollar.GetArgs() + unwrapped_fields1150 := fields1149 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields1147) == 0) { + if !(len(unwrapped_fields1150) == 0) { p.newline() - for i1149, elem1148 := range unwrapped_fields1147 { - if (i1149 > 0) { + for i1152, elem1151 := range unwrapped_fields1150 { + if (i1152 > 0) { p.newline() } - p.pretty_formula(elem1148) + p.pretty_formula(elem1151) } } p.dedent() @@ -2273,19 +2277,19 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat1153 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat1153 != nil { - p.write(*flat1153) + flat1156 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat1156 != nil { + p.write(*flat1156) return nil } else { _dollar_dollar := msg - fields1151 := _dollar_dollar.GetArg() - unwrapped_fields1152 := fields1151 + fields1154 := _dollar_dollar.GetArg() + unwrapped_fields1155 := fields1154 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields1152) + p.pretty_formula(unwrapped_fields1155) p.dedent() p.write(")") } @@ -2293,26 +2297,26 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat1159 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat1159 != nil { - p.write(*flat1159) + flat1162 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat1162 != nil { + p.write(*flat1162) return nil } else { _dollar_dollar := msg - fields1154 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} - unwrapped_fields1155 := fields1154 + fields1157 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} + unwrapped_fields1158 := fields1157 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field1156 := unwrapped_fields1155[0].(string) - p.pretty_name(field1156) + field1159 := unwrapped_fields1158[0].(string) + p.pretty_name(field1159) p.newline() - field1157 := unwrapped_fields1155[1].([]*pb.Abstraction) - p.pretty_ffi_args(field1157) + field1160 := unwrapped_fields1158[1].([]*pb.Abstraction) + p.pretty_ffi_args(field1160) p.newline() - field1158 := unwrapped_fields1155[2].([]*pb.Term) - p.pretty_terms(field1158) + field1161 := unwrapped_fields1158[2].([]*pb.Term) + p.pretty_terms(field1161) p.dedent() p.write(")") } @@ -2320,35 +2324,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - flat1161 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat1161 != nil { - p.write(*flat1161) + flat1164 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat1164 != nil { + p.write(*flat1164) return nil } else { - fields1160 := msg + fields1163 := msg p.write(":") - p.write(fields1160) + p.write(fields1163) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - flat1165 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat1165 != nil { - p.write(*flat1165) + flat1168 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat1168 != nil { + p.write(*flat1168) return nil } else { - fields1162 := msg + fields1165 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields1162) == 0) { + if !(len(fields1165) == 0) { p.newline() - for i1164, elem1163 := range fields1162 { - if (i1164 > 0) { + for i1167, elem1166 := range fields1165 { + if (i1167 > 0) { p.newline() } - p.pretty_abstraction(elem1163) + p.pretty_abstraction(elem1166) } } p.dedent() @@ -2358,28 +2362,28 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - flat1172 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat1172 != nil { - p.write(*flat1172) + flat1175 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat1175 != nil { + p.write(*flat1175) return nil } else { _dollar_dollar := msg - fields1166 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1167 := fields1166 + fields1169 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1170 := fields1169 p.write("(") p.write("atom") p.indentSexp() p.newline() - field1168 := unwrapped_fields1167[0].(*pb.RelationId) - p.pretty_relation_id(field1168) - field1169 := unwrapped_fields1167[1].([]*pb.Term) - if !(len(field1169) == 0) { + field1171 := unwrapped_fields1170[0].(*pb.RelationId) + p.pretty_relation_id(field1171) + field1172 := unwrapped_fields1170[1].([]*pb.Term) + if !(len(field1172) == 0) { p.newline() - for i1171, elem1170 := range field1169 { - if (i1171 > 0) { + for i1174, elem1173 := range field1172 { + if (i1174 > 0) { p.newline() } - p.pretty_term(elem1170) + p.pretty_term(elem1173) } } p.dedent() @@ -2389,28 +2393,28 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - flat1179 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat1179 != nil { - p.write(*flat1179) + flat1182 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat1182 != nil { + p.write(*flat1182) return nil } else { _dollar_dollar := msg - fields1173 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1174 := fields1173 + fields1176 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1177 := fields1176 p.write("(") p.write("pragma") p.indentSexp() p.newline() - field1175 := unwrapped_fields1174[0].(string) - p.pretty_name(field1175) - field1176 := unwrapped_fields1174[1].([]*pb.Term) - if !(len(field1176) == 0) { + field1178 := unwrapped_fields1177[0].(string) + p.pretty_name(field1178) + field1179 := unwrapped_fields1177[1].([]*pb.Term) + if !(len(field1179) == 0) { p.newline() - for i1178, elem1177 := range field1176 { - if (i1178 > 0) { + for i1181, elem1180 := range field1179 { + if (i1181 > 0) { p.newline() } - p.pretty_term(elem1177) + p.pretty_term(elem1180) } } p.dedent() @@ -2420,109 +2424,109 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - flat1195 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat1195 != nil { - p.write(*flat1195) + flat1198 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat1198 != nil { + p.write(*flat1198) return nil } else { _dollar_dollar := msg - var _t1769 []interface{} + var _t1775 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1769 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1775 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1194 := _t1769 - if guard_result1194 != nil { + guard_result1197 := _t1775 + if guard_result1197 != nil { p.pretty_eq(msg) } else { _dollar_dollar := msg - var _t1770 []interface{} + var _t1776 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1770 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1776 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1193 := _t1770 - if guard_result1193 != nil { + guard_result1196 := _t1776 + if guard_result1196 != nil { p.pretty_lt(msg) } else { _dollar_dollar := msg - var _t1771 []interface{} + var _t1777 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1771 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1777 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1192 := _t1771 - if guard_result1192 != nil { + guard_result1195 := _t1777 + if guard_result1195 != nil { p.pretty_lt_eq(msg) } else { _dollar_dollar := msg - var _t1772 []interface{} + var _t1778 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1772 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1778 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1191 := _t1772 - if guard_result1191 != nil { + guard_result1194 := _t1778 + if guard_result1194 != nil { p.pretty_gt(msg) } else { _dollar_dollar := msg - var _t1773 []interface{} + var _t1779 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1773 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1779 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1190 := _t1773 - if guard_result1190 != nil { + guard_result1193 := _t1779 + if guard_result1193 != nil { p.pretty_gt_eq(msg) } else { _dollar_dollar := msg - var _t1774 []interface{} + var _t1780 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1774 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1780 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1189 := _t1774 - if guard_result1189 != nil { + guard_result1192 := _t1780 + if guard_result1192 != nil { p.pretty_add(msg) } else { _dollar_dollar := msg - var _t1775 []interface{} + var _t1781 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1775 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1781 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1188 := _t1775 - if guard_result1188 != nil { + guard_result1191 := _t1781 + if guard_result1191 != nil { p.pretty_minus(msg) } else { _dollar_dollar := msg - var _t1776 []interface{} + var _t1782 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1776 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1782 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1187 := _t1776 - if guard_result1187 != nil { + guard_result1190 := _t1782 + if guard_result1190 != nil { p.pretty_multiply(msg) } else { _dollar_dollar := msg - var _t1777 []interface{} + var _t1783 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1777 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1783 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1186 := _t1777 - if guard_result1186 != nil { + guard_result1189 := _t1783 + if guard_result1189 != nil { p.pretty_divide(msg) } else { _dollar_dollar := msg - fields1180 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1181 := fields1180 + fields1183 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1184 := fields1183 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field1182 := unwrapped_fields1181[0].(string) - p.pretty_name(field1182) - field1183 := unwrapped_fields1181[1].([]*pb.RelTerm) - if !(len(field1183) == 0) { + field1185 := unwrapped_fields1184[0].(string) + p.pretty_name(field1185) + field1186 := unwrapped_fields1184[1].([]*pb.RelTerm) + if !(len(field1186) == 0) { p.newline() - for i1185, elem1184 := range field1183 { - if (i1185 > 0) { + for i1188, elem1187 := range field1186 { + if (i1188 > 0) { p.newline() } - p.pretty_rel_term(elem1184) + p.pretty_rel_term(elem1187) } } p.dedent() @@ -2541,27 +2545,27 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat1200 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat1200 != nil { - p.write(*flat1200) + flat1203 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) + if flat1203 != nil { + p.write(*flat1203) return nil } else { _dollar_dollar := msg - var _t1778 []interface{} + var _t1784 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1778 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1784 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1196 := _t1778 - unwrapped_fields1197 := fields1196 + fields1199 := _t1784 + unwrapped_fields1200 := fields1199 p.write("(") p.write("=") p.indentSexp() p.newline() - field1198 := unwrapped_fields1197[0].(*pb.Term) - p.pretty_term(field1198) + field1201 := unwrapped_fields1200[0].(*pb.Term) + p.pretty_term(field1201) p.newline() - field1199 := unwrapped_fields1197[1].(*pb.Term) - p.pretty_term(field1199) + field1202 := unwrapped_fields1200[1].(*pb.Term) + p.pretty_term(field1202) p.dedent() p.write(")") } @@ -2569,27 +2573,27 @@ func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat1205 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) - if flat1205 != nil { - p.write(*flat1205) + flat1208 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + if flat1208 != nil { + p.write(*flat1208) return nil } else { _dollar_dollar := msg - var _t1779 []interface{} + var _t1785 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1779 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1785 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1201 := _t1779 - unwrapped_fields1202 := fields1201 + fields1204 := _t1785 + unwrapped_fields1205 := fields1204 p.write("(") p.write("<") p.indentSexp() p.newline() - field1203 := unwrapped_fields1202[0].(*pb.Term) - p.pretty_term(field1203) + field1206 := unwrapped_fields1205[0].(*pb.Term) + p.pretty_term(field1206) p.newline() - field1204 := unwrapped_fields1202[1].(*pb.Term) - p.pretty_term(field1204) + field1207 := unwrapped_fields1205[1].(*pb.Term) + p.pretty_term(field1207) p.dedent() p.write(")") } @@ -2597,27 +2601,27 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat1210 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) - if flat1210 != nil { - p.write(*flat1210) + flat1213 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) + if flat1213 != nil { + p.write(*flat1213) return nil } else { _dollar_dollar := msg - var _t1780 []interface{} + var _t1786 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1780 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1786 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1206 := _t1780 - unwrapped_fields1207 := fields1206 + fields1209 := _t1786 + unwrapped_fields1210 := fields1209 p.write("(") p.write("<=") p.indentSexp() p.newline() - field1208 := unwrapped_fields1207[0].(*pb.Term) - p.pretty_term(field1208) + field1211 := unwrapped_fields1210[0].(*pb.Term) + p.pretty_term(field1211) p.newline() - field1209 := unwrapped_fields1207[1].(*pb.Term) - p.pretty_term(field1209) + field1212 := unwrapped_fields1210[1].(*pb.Term) + p.pretty_term(field1212) p.dedent() p.write(")") } @@ -2625,27 +2629,27 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat1215 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) - if flat1215 != nil { - p.write(*flat1215) + flat1218 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) + if flat1218 != nil { + p.write(*flat1218) return nil } else { _dollar_dollar := msg - var _t1781 []interface{} + var _t1787 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1781 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1787 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1211 := _t1781 - unwrapped_fields1212 := fields1211 + fields1214 := _t1787 + unwrapped_fields1215 := fields1214 p.write("(") p.write(">") p.indentSexp() p.newline() - field1213 := unwrapped_fields1212[0].(*pb.Term) - p.pretty_term(field1213) + field1216 := unwrapped_fields1215[0].(*pb.Term) + p.pretty_term(field1216) p.newline() - field1214 := unwrapped_fields1212[1].(*pb.Term) - p.pretty_term(field1214) + field1217 := unwrapped_fields1215[1].(*pb.Term) + p.pretty_term(field1217) p.dedent() p.write(")") } @@ -2653,27 +2657,27 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat1220 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) - if flat1220 != nil { - p.write(*flat1220) + flat1223 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) + if flat1223 != nil { + p.write(*flat1223) return nil } else { _dollar_dollar := msg - var _t1782 []interface{} + var _t1788 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1782 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1788 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1216 := _t1782 - unwrapped_fields1217 := fields1216 + fields1219 := _t1788 + unwrapped_fields1220 := fields1219 p.write("(") p.write(">=") p.indentSexp() p.newline() - field1218 := unwrapped_fields1217[0].(*pb.Term) - p.pretty_term(field1218) + field1221 := unwrapped_fields1220[0].(*pb.Term) + p.pretty_term(field1221) p.newline() - field1219 := unwrapped_fields1217[1].(*pb.Term) - p.pretty_term(field1219) + field1222 := unwrapped_fields1220[1].(*pb.Term) + p.pretty_term(field1222) p.dedent() p.write(")") } @@ -2681,30 +2685,30 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat1226 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat1226 != nil { - p.write(*flat1226) + flat1229 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat1229 != nil { + p.write(*flat1229) return nil } else { _dollar_dollar := msg - var _t1783 []interface{} + var _t1789 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1783 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1789 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1221 := _t1783 - unwrapped_fields1222 := fields1221 + fields1224 := _t1789 + unwrapped_fields1225 := fields1224 p.write("(") p.write("+") p.indentSexp() p.newline() - field1223 := unwrapped_fields1222[0].(*pb.Term) - p.pretty_term(field1223) + field1226 := unwrapped_fields1225[0].(*pb.Term) + p.pretty_term(field1226) p.newline() - field1224 := unwrapped_fields1222[1].(*pb.Term) - p.pretty_term(field1224) + field1227 := unwrapped_fields1225[1].(*pb.Term) + p.pretty_term(field1227) p.newline() - field1225 := unwrapped_fields1222[2].(*pb.Term) - p.pretty_term(field1225) + field1228 := unwrapped_fields1225[2].(*pb.Term) + p.pretty_term(field1228) p.dedent() p.write(")") } @@ -2712,30 +2716,30 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat1232 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat1232 != nil { - p.write(*flat1232) + flat1235 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat1235 != nil { + p.write(*flat1235) return nil } else { _dollar_dollar := msg - var _t1784 []interface{} + var _t1790 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1784 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1790 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1227 := _t1784 - unwrapped_fields1228 := fields1227 + fields1230 := _t1790 + unwrapped_fields1231 := fields1230 p.write("(") p.write("-") p.indentSexp() p.newline() - field1229 := unwrapped_fields1228[0].(*pb.Term) - p.pretty_term(field1229) + field1232 := unwrapped_fields1231[0].(*pb.Term) + p.pretty_term(field1232) p.newline() - field1230 := unwrapped_fields1228[1].(*pb.Term) - p.pretty_term(field1230) + field1233 := unwrapped_fields1231[1].(*pb.Term) + p.pretty_term(field1233) p.newline() - field1231 := unwrapped_fields1228[2].(*pb.Term) - p.pretty_term(field1231) + field1234 := unwrapped_fields1231[2].(*pb.Term) + p.pretty_term(field1234) p.dedent() p.write(")") } @@ -2743,30 +2747,30 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat1238 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat1238 != nil { - p.write(*flat1238) + flat1241 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat1241 != nil { + p.write(*flat1241) return nil } else { _dollar_dollar := msg - var _t1785 []interface{} + var _t1791 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1785 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1791 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1233 := _t1785 - unwrapped_fields1234 := fields1233 + fields1236 := _t1791 + unwrapped_fields1237 := fields1236 p.write("(") p.write("*") p.indentSexp() p.newline() - field1235 := unwrapped_fields1234[0].(*pb.Term) - p.pretty_term(field1235) + field1238 := unwrapped_fields1237[0].(*pb.Term) + p.pretty_term(field1238) p.newline() - field1236 := unwrapped_fields1234[1].(*pb.Term) - p.pretty_term(field1236) + field1239 := unwrapped_fields1237[1].(*pb.Term) + p.pretty_term(field1239) p.newline() - field1237 := unwrapped_fields1234[2].(*pb.Term) - p.pretty_term(field1237) + field1240 := unwrapped_fields1237[2].(*pb.Term) + p.pretty_term(field1240) p.dedent() p.write(")") } @@ -2774,30 +2778,30 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat1244 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat1244 != nil { - p.write(*flat1244) + flat1247 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat1247 != nil { + p.write(*flat1247) return nil } else { _dollar_dollar := msg - var _t1786 []interface{} + var _t1792 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1786 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1792 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1239 := _t1786 - unwrapped_fields1240 := fields1239 + fields1242 := _t1792 + unwrapped_fields1243 := fields1242 p.write("(") p.write("/") p.indentSexp() p.newline() - field1241 := unwrapped_fields1240[0].(*pb.Term) - p.pretty_term(field1241) + field1244 := unwrapped_fields1243[0].(*pb.Term) + p.pretty_term(field1244) p.newline() - field1242 := unwrapped_fields1240[1].(*pb.Term) - p.pretty_term(field1242) + field1245 := unwrapped_fields1243[1].(*pb.Term) + p.pretty_term(field1245) p.newline() - field1243 := unwrapped_fields1240[2].(*pb.Term) - p.pretty_term(field1243) + field1246 := unwrapped_fields1243[2].(*pb.Term) + p.pretty_term(field1246) p.dedent() p.write(")") } @@ -2805,30 +2809,30 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat1249 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat1249 != nil { - p.write(*flat1249) + flat1252 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat1252 != nil { + p.write(*flat1252) return nil } else { _dollar_dollar := msg - var _t1787 *pb.Value + var _t1793 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1787 = _dollar_dollar.GetSpecializedValue() + _t1793 = _dollar_dollar.GetSpecializedValue() } - deconstruct_result1247 := _t1787 - if deconstruct_result1247 != nil { - unwrapped1248 := deconstruct_result1247 - p.pretty_specialized_value(unwrapped1248) + deconstruct_result1250 := _t1793 + if deconstruct_result1250 != nil { + unwrapped1251 := deconstruct_result1250 + p.pretty_specialized_value(unwrapped1251) } else { _dollar_dollar := msg - var _t1788 *pb.Term + var _t1794 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1788 = _dollar_dollar.GetTerm() + _t1794 = _dollar_dollar.GetTerm() } - deconstruct_result1245 := _t1788 - if deconstruct_result1245 != nil { - unwrapped1246 := deconstruct_result1245 - p.pretty_term(unwrapped1246) + deconstruct_result1248 := _t1794 + if deconstruct_result1248 != nil { + unwrapped1249 := deconstruct_result1248 + p.pretty_term(unwrapped1249) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -2838,41 +2842,41 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat1251 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat1251 != nil { - p.write(*flat1251) + flat1254 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat1254 != nil { + p.write(*flat1254) return nil } else { - fields1250 := msg + fields1253 := msg p.write("#") - p.pretty_raw_value(fields1250) + p.pretty_raw_value(fields1253) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat1258 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat1258 != nil { - p.write(*flat1258) + flat1261 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat1261 != nil { + p.write(*flat1261) return nil } else { _dollar_dollar := msg - fields1252 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1253 := fields1252 + fields1255 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1256 := fields1255 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field1254 := unwrapped_fields1253[0].(string) - p.pretty_name(field1254) - field1255 := unwrapped_fields1253[1].([]*pb.RelTerm) - if !(len(field1255) == 0) { + field1257 := unwrapped_fields1256[0].(string) + p.pretty_name(field1257) + field1258 := unwrapped_fields1256[1].([]*pb.RelTerm) + if !(len(field1258) == 0) { p.newline() - for i1257, elem1256 := range field1255 { - if (i1257 > 0) { + for i1260, elem1259 := range field1258 { + if (i1260 > 0) { p.newline() } - p.pretty_rel_term(elem1256) + p.pretty_rel_term(elem1259) } } p.dedent() @@ -2882,23 +2886,23 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat1263 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat1263 != nil { - p.write(*flat1263) + flat1266 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat1266 != nil { + p.write(*flat1266) return nil } else { _dollar_dollar := msg - fields1259 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} - unwrapped_fields1260 := fields1259 + fields1262 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} + unwrapped_fields1263 := fields1262 p.write("(") p.write("cast") p.indentSexp() p.newline() - field1261 := unwrapped_fields1260[0].(*pb.Term) - p.pretty_term(field1261) + field1264 := unwrapped_fields1263[0].(*pb.Term) + p.pretty_term(field1264) p.newline() - field1262 := unwrapped_fields1260[1].(*pb.Term) - p.pretty_term(field1262) + field1265 := unwrapped_fields1263[1].(*pb.Term) + p.pretty_term(field1265) p.dedent() p.write(")") } @@ -2906,22 +2910,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1267 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1267 != nil { - p.write(*flat1267) + flat1270 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1270 != nil { + p.write(*flat1270) return nil } else { - fields1264 := msg + fields1267 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields1264) == 0) { + if !(len(fields1267) == 0) { p.newline() - for i1266, elem1265 := range fields1264 { - if (i1266 > 0) { + for i1269, elem1268 := range fields1267 { + if (i1269 > 0) { p.newline() } - p.pretty_attribute(elem1265) + p.pretty_attribute(elem1268) } } p.dedent() @@ -2931,28 +2935,28 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1274 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1274 != nil { - p.write(*flat1274) + flat1277 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1277 != nil { + p.write(*flat1277) return nil } else { _dollar_dollar := msg - fields1268 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} - unwrapped_fields1269 := fields1268 + fields1271 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} + unwrapped_fields1272 := fields1271 p.write("(") p.write("attribute") p.indentSexp() p.newline() - field1270 := unwrapped_fields1269[0].(string) - p.pretty_name(field1270) - field1271 := unwrapped_fields1269[1].([]*pb.Value) - if !(len(field1271) == 0) { + field1273 := unwrapped_fields1272[0].(string) + p.pretty_name(field1273) + field1274 := unwrapped_fields1272[1].([]*pb.Value) + if !(len(field1274) == 0) { p.newline() - for i1273, elem1272 := range field1271 { - if (i1273 > 0) { + for i1276, elem1275 := range field1274 { + if (i1276 > 0) { p.newline() } - p.pretty_raw_value(elem1272) + p.pretty_raw_value(elem1275) } } p.dedent() @@ -2962,39 +2966,39 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - flat1283 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1283 != nil { - p.write(*flat1283) + flat1286 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1286 != nil { + p.write(*flat1286) return nil } else { _dollar_dollar := msg - var _t1789 []*pb.Attribute + var _t1795 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1789 = _dollar_dollar.GetAttrs() + _t1795 = _dollar_dollar.GetAttrs() } - fields1275 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1789} - unwrapped_fields1276 := fields1275 + fields1278 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1795} + unwrapped_fields1279 := fields1278 p.write("(") p.write("algorithm") p.indentSexp() - field1277 := unwrapped_fields1276[0].([]*pb.RelationId) - if !(len(field1277) == 0) { + field1280 := unwrapped_fields1279[0].([]*pb.RelationId) + if !(len(field1280) == 0) { p.newline() - for i1279, elem1278 := range field1277 { - if (i1279 > 0) { + for i1282, elem1281 := range field1280 { + if (i1282 > 0) { p.newline() } - p.pretty_relation_id(elem1278) + p.pretty_relation_id(elem1281) } } p.newline() - field1280 := unwrapped_fields1276[1].(*pb.Script) - p.pretty_script(field1280) - field1281 := unwrapped_fields1276[2].([]*pb.Attribute) - if field1281 != nil { + field1283 := unwrapped_fields1279[1].(*pb.Script) + p.pretty_script(field1283) + field1284 := unwrapped_fields1279[2].([]*pb.Attribute) + if field1284 != nil { p.newline() - opt_val1282 := field1281 - p.pretty_attrs(opt_val1282) + opt_val1285 := field1284 + p.pretty_attrs(opt_val1285) } p.dedent() p.write(")") @@ -3003,24 +3007,24 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - flat1288 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1288 != nil { - p.write(*flat1288) + flat1291 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1291 != nil { + p.write(*flat1291) return nil } else { _dollar_dollar := msg - fields1284 := _dollar_dollar.GetConstructs() - unwrapped_fields1285 := fields1284 + fields1287 := _dollar_dollar.GetConstructs() + unwrapped_fields1288 := fields1287 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1285) == 0) { + if !(len(unwrapped_fields1288) == 0) { p.newline() - for i1287, elem1286 := range unwrapped_fields1285 { - if (i1287 > 0) { + for i1290, elem1289 := range unwrapped_fields1288 { + if (i1290 > 0) { p.newline() } - p.pretty_construct(elem1286) + p.pretty_construct(elem1289) } } p.dedent() @@ -3030,30 +3034,30 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - flat1293 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1293 != nil { - p.write(*flat1293) + flat1296 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1296 != nil { + p.write(*flat1296) return nil } else { _dollar_dollar := msg - var _t1790 *pb.Loop + var _t1796 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1790 = _dollar_dollar.GetLoop() + _t1796 = _dollar_dollar.GetLoop() } - deconstruct_result1291 := _t1790 - if deconstruct_result1291 != nil { - unwrapped1292 := deconstruct_result1291 - p.pretty_loop(unwrapped1292) + deconstruct_result1294 := _t1796 + if deconstruct_result1294 != nil { + unwrapped1295 := deconstruct_result1294 + p.pretty_loop(unwrapped1295) } else { _dollar_dollar := msg - var _t1791 *pb.Instruction + var _t1797 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1791 = _dollar_dollar.GetInstruction() + _t1797 = _dollar_dollar.GetInstruction() } - deconstruct_result1289 := _t1791 - if deconstruct_result1289 != nil { - unwrapped1290 := deconstruct_result1289 - p.pretty_instruction(unwrapped1290) + deconstruct_result1292 := _t1797 + if deconstruct_result1292 != nil { + unwrapped1293 := deconstruct_result1292 + p.pretty_instruction(unwrapped1293) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -3063,32 +3067,32 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - flat1300 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1300 != nil { - p.write(*flat1300) + flat1303 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1303 != nil { + p.write(*flat1303) return nil } else { _dollar_dollar := msg - var _t1792 []*pb.Attribute + var _t1798 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1792 = _dollar_dollar.GetAttrs() + _t1798 = _dollar_dollar.GetAttrs() } - fields1294 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1792} - unwrapped_fields1295 := fields1294 + fields1297 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1798} + unwrapped_fields1298 := fields1297 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1296 := unwrapped_fields1295[0].([]*pb.Instruction) - p.pretty_init(field1296) + field1299 := unwrapped_fields1298[0].([]*pb.Instruction) + p.pretty_init(field1299) p.newline() - field1297 := unwrapped_fields1295[1].(*pb.Script) - p.pretty_script(field1297) - field1298 := unwrapped_fields1295[2].([]*pb.Attribute) - if field1298 != nil { + field1300 := unwrapped_fields1298[1].(*pb.Script) + p.pretty_script(field1300) + field1301 := unwrapped_fields1298[2].([]*pb.Attribute) + if field1301 != nil { p.newline() - opt_val1299 := field1298 - p.pretty_attrs(opt_val1299) + opt_val1302 := field1301 + p.pretty_attrs(opt_val1302) } p.dedent() p.write(")") @@ -3097,22 +3101,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - flat1304 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1304 != nil { - p.write(*flat1304) + flat1307 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1307 != nil { + p.write(*flat1307) return nil } else { - fields1301 := msg + fields1304 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1301) == 0) { + if !(len(fields1304) == 0) { p.newline() - for i1303, elem1302 := range fields1301 { - if (i1303 > 0) { + for i1306, elem1305 := range fields1304 { + if (i1306 > 0) { p.newline() } - p.pretty_instruction(elem1302) + p.pretty_instruction(elem1305) } } p.dedent() @@ -3122,60 +3126,60 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - flat1315 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1315 != nil { - p.write(*flat1315) + flat1318 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1318 != nil { + p.write(*flat1318) return nil } else { _dollar_dollar := msg - var _t1793 *pb.Assign + var _t1799 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1793 = _dollar_dollar.GetAssign() + _t1799 = _dollar_dollar.GetAssign() } - deconstruct_result1313 := _t1793 - if deconstruct_result1313 != nil { - unwrapped1314 := deconstruct_result1313 - p.pretty_assign(unwrapped1314) + deconstruct_result1316 := _t1799 + if deconstruct_result1316 != nil { + unwrapped1317 := deconstruct_result1316 + p.pretty_assign(unwrapped1317) } else { _dollar_dollar := msg - var _t1794 *pb.Upsert + var _t1800 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1794 = _dollar_dollar.GetUpsert() + _t1800 = _dollar_dollar.GetUpsert() } - deconstruct_result1311 := _t1794 - if deconstruct_result1311 != nil { - unwrapped1312 := deconstruct_result1311 - p.pretty_upsert(unwrapped1312) + deconstruct_result1314 := _t1800 + if deconstruct_result1314 != nil { + unwrapped1315 := deconstruct_result1314 + p.pretty_upsert(unwrapped1315) } else { _dollar_dollar := msg - var _t1795 *pb.Break + var _t1801 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1795 = _dollar_dollar.GetBreak() + _t1801 = _dollar_dollar.GetBreak() } - deconstruct_result1309 := _t1795 - if deconstruct_result1309 != nil { - unwrapped1310 := deconstruct_result1309 - p.pretty_break(unwrapped1310) + deconstruct_result1312 := _t1801 + if deconstruct_result1312 != nil { + unwrapped1313 := deconstruct_result1312 + p.pretty_break(unwrapped1313) } else { _dollar_dollar := msg - var _t1796 *pb.MonoidDef + var _t1802 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1796 = _dollar_dollar.GetMonoidDef() + _t1802 = _dollar_dollar.GetMonoidDef() } - deconstruct_result1307 := _t1796 - if deconstruct_result1307 != nil { - unwrapped1308 := deconstruct_result1307 - p.pretty_monoid_def(unwrapped1308) + deconstruct_result1310 := _t1802 + if deconstruct_result1310 != nil { + unwrapped1311 := deconstruct_result1310 + p.pretty_monoid_def(unwrapped1311) } else { _dollar_dollar := msg - var _t1797 *pb.MonusDef + var _t1803 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1797 = _dollar_dollar.GetMonusDef() + _t1803 = _dollar_dollar.GetMonusDef() } - deconstruct_result1305 := _t1797 - if deconstruct_result1305 != nil { - unwrapped1306 := deconstruct_result1305 - p.pretty_monus_def(unwrapped1306) + deconstruct_result1308 := _t1803 + if deconstruct_result1308 != nil { + unwrapped1309 := deconstruct_result1308 + p.pretty_monus_def(unwrapped1309) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3188,32 +3192,32 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - flat1322 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1322 != nil { - p.write(*flat1322) + flat1325 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1325 != nil { + p.write(*flat1325) return nil } else { _dollar_dollar := msg - var _t1798 []*pb.Attribute + var _t1804 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1798 = _dollar_dollar.GetAttrs() + _t1804 = _dollar_dollar.GetAttrs() } - fields1316 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1798} - unwrapped_fields1317 := fields1316 + fields1319 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1804} + unwrapped_fields1320 := fields1319 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1318 := unwrapped_fields1317[0].(*pb.RelationId) - p.pretty_relation_id(field1318) + field1321 := unwrapped_fields1320[0].(*pb.RelationId) + p.pretty_relation_id(field1321) p.newline() - field1319 := unwrapped_fields1317[1].(*pb.Abstraction) - p.pretty_abstraction(field1319) - field1320 := unwrapped_fields1317[2].([]*pb.Attribute) - if field1320 != nil { + field1322 := unwrapped_fields1320[1].(*pb.Abstraction) + p.pretty_abstraction(field1322) + field1323 := unwrapped_fields1320[2].([]*pb.Attribute) + if field1323 != nil { p.newline() - opt_val1321 := field1320 - p.pretty_attrs(opt_val1321) + opt_val1324 := field1323 + p.pretty_attrs(opt_val1324) } p.dedent() p.write(")") @@ -3222,32 +3226,32 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - flat1329 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1329 != nil { - p.write(*flat1329) + flat1332 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1332 != nil { + p.write(*flat1332) return nil } else { _dollar_dollar := msg - var _t1799 []*pb.Attribute + var _t1805 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1799 = _dollar_dollar.GetAttrs() + _t1805 = _dollar_dollar.GetAttrs() } - fields1323 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1799} - unwrapped_fields1324 := fields1323 + fields1326 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1805} + unwrapped_fields1327 := fields1326 p.write("(") p.write("upsert") p.indentSexp() p.newline() - field1325 := unwrapped_fields1324[0].(*pb.RelationId) - p.pretty_relation_id(field1325) + field1328 := unwrapped_fields1327[0].(*pb.RelationId) + p.pretty_relation_id(field1328) p.newline() - field1326 := unwrapped_fields1324[1].([]interface{}) - p.pretty_abstraction_with_arity(field1326) - field1327 := unwrapped_fields1324[2].([]*pb.Attribute) - if field1327 != nil { + field1329 := unwrapped_fields1327[1].([]interface{}) + p.pretty_abstraction_with_arity(field1329) + field1330 := unwrapped_fields1327[2].([]*pb.Attribute) + if field1330 != nil { p.newline() - opt_val1328 := field1327 - p.pretty_attrs(opt_val1328) + opt_val1331 := field1330 + p.pretty_attrs(opt_val1331) } p.dedent() p.write(")") @@ -3256,22 +3260,22 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - flat1334 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1334 != nil { - p.write(*flat1334) + flat1337 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1337 != nil { + p.write(*flat1337) return nil } else { _dollar_dollar := msg - _t1800 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - fields1330 := []interface{}{_t1800, _dollar_dollar[0].(*pb.Abstraction).GetValue()} - unwrapped_fields1331 := fields1330 + _t1806 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) + fields1333 := []interface{}{_t1806, _dollar_dollar[0].(*pb.Abstraction).GetValue()} + unwrapped_fields1334 := fields1333 p.write("(") p.indent() - field1332 := unwrapped_fields1331[0].([]interface{}) - p.pretty_bindings(field1332) + field1335 := unwrapped_fields1334[0].([]interface{}) + p.pretty_bindings(field1335) p.newline() - field1333 := unwrapped_fields1331[1].(*pb.Formula) - p.pretty_formula(field1333) + field1336 := unwrapped_fields1334[1].(*pb.Formula) + p.pretty_formula(field1336) p.dedent() p.write(")") } @@ -3279,32 +3283,32 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1341 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1341 != nil { - p.write(*flat1341) + flat1344 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1344 != nil { + p.write(*flat1344) return nil } else { _dollar_dollar := msg - var _t1801 []*pb.Attribute + var _t1807 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1801 = _dollar_dollar.GetAttrs() + _t1807 = _dollar_dollar.GetAttrs() } - fields1335 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1801} - unwrapped_fields1336 := fields1335 + fields1338 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1807} + unwrapped_fields1339 := fields1338 p.write("(") p.write("break") p.indentSexp() p.newline() - field1337 := unwrapped_fields1336[0].(*pb.RelationId) - p.pretty_relation_id(field1337) + field1340 := unwrapped_fields1339[0].(*pb.RelationId) + p.pretty_relation_id(field1340) p.newline() - field1338 := unwrapped_fields1336[1].(*pb.Abstraction) - p.pretty_abstraction(field1338) - field1339 := unwrapped_fields1336[2].([]*pb.Attribute) - if field1339 != nil { + field1341 := unwrapped_fields1339[1].(*pb.Abstraction) + p.pretty_abstraction(field1341) + field1342 := unwrapped_fields1339[2].([]*pb.Attribute) + if field1342 != nil { p.newline() - opt_val1340 := field1339 - p.pretty_attrs(opt_val1340) + opt_val1343 := field1342 + p.pretty_attrs(opt_val1343) } p.dedent() p.write(")") @@ -3313,35 +3317,35 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - flat1349 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1349 != nil { - p.write(*flat1349) + flat1352 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1352 != nil { + p.write(*flat1352) return nil } else { _dollar_dollar := msg - var _t1802 []*pb.Attribute + var _t1808 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1802 = _dollar_dollar.GetAttrs() + _t1808 = _dollar_dollar.GetAttrs() } - fields1342 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1802} - unwrapped_fields1343 := fields1342 + fields1345 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1808} + unwrapped_fields1346 := fields1345 p.write("(") p.write("monoid") p.indentSexp() p.newline() - field1344 := unwrapped_fields1343[0].(*pb.Monoid) - p.pretty_monoid(field1344) + field1347 := unwrapped_fields1346[0].(*pb.Monoid) + p.pretty_monoid(field1347) p.newline() - field1345 := unwrapped_fields1343[1].(*pb.RelationId) - p.pretty_relation_id(field1345) + field1348 := unwrapped_fields1346[1].(*pb.RelationId) + p.pretty_relation_id(field1348) p.newline() - field1346 := unwrapped_fields1343[2].([]interface{}) - p.pretty_abstraction_with_arity(field1346) - field1347 := unwrapped_fields1343[3].([]*pb.Attribute) - if field1347 != nil { + field1349 := unwrapped_fields1346[2].([]interface{}) + p.pretty_abstraction_with_arity(field1349) + field1350 := unwrapped_fields1346[3].([]*pb.Attribute) + if field1350 != nil { p.newline() - opt_val1348 := field1347 - p.pretty_attrs(opt_val1348) + opt_val1351 := field1350 + p.pretty_attrs(opt_val1351) } p.dedent() p.write(")") @@ -3350,50 +3354,50 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - flat1358 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1358 != nil { - p.write(*flat1358) + flat1361 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1361 != nil { + p.write(*flat1361) return nil } else { _dollar_dollar := msg - var _t1803 *pb.OrMonoid + var _t1809 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1803 = _dollar_dollar.GetOrMonoid() + _t1809 = _dollar_dollar.GetOrMonoid() } - deconstruct_result1356 := _t1803 - if deconstruct_result1356 != nil { - unwrapped1357 := deconstruct_result1356 - p.pretty_or_monoid(unwrapped1357) + deconstruct_result1359 := _t1809 + if deconstruct_result1359 != nil { + unwrapped1360 := deconstruct_result1359 + p.pretty_or_monoid(unwrapped1360) } else { _dollar_dollar := msg - var _t1804 *pb.MinMonoid + var _t1810 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1804 = _dollar_dollar.GetMinMonoid() + _t1810 = _dollar_dollar.GetMinMonoid() } - deconstruct_result1354 := _t1804 - if deconstruct_result1354 != nil { - unwrapped1355 := deconstruct_result1354 - p.pretty_min_monoid(unwrapped1355) + deconstruct_result1357 := _t1810 + if deconstruct_result1357 != nil { + unwrapped1358 := deconstruct_result1357 + p.pretty_min_monoid(unwrapped1358) } else { _dollar_dollar := msg - var _t1805 *pb.MaxMonoid + var _t1811 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1805 = _dollar_dollar.GetMaxMonoid() + _t1811 = _dollar_dollar.GetMaxMonoid() } - deconstruct_result1352 := _t1805 - if deconstruct_result1352 != nil { - unwrapped1353 := deconstruct_result1352 - p.pretty_max_monoid(unwrapped1353) + deconstruct_result1355 := _t1811 + if deconstruct_result1355 != nil { + unwrapped1356 := deconstruct_result1355 + p.pretty_max_monoid(unwrapped1356) } else { _dollar_dollar := msg - var _t1806 *pb.SumMonoid + var _t1812 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1806 = _dollar_dollar.GetSumMonoid() + _t1812 = _dollar_dollar.GetSumMonoid() } - deconstruct_result1350 := _t1806 - if deconstruct_result1350 != nil { - unwrapped1351 := deconstruct_result1350 - p.pretty_sum_monoid(unwrapped1351) + deconstruct_result1353 := _t1812 + if deconstruct_result1353 != nil { + unwrapped1354 := deconstruct_result1353 + p.pretty_sum_monoid(unwrapped1354) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3405,8 +3409,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1359 := msg - _ = fields1359 + fields1362 := msg + _ = fields1362 p.write("(") p.write("or") p.write(")") @@ -3414,19 +3418,19 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1362 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1362 != nil { - p.write(*flat1362) + flat1365 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1365 != nil { + p.write(*flat1365) return nil } else { _dollar_dollar := msg - fields1360 := _dollar_dollar.GetType() - unwrapped_fields1361 := fields1360 + fields1363 := _dollar_dollar.GetType() + unwrapped_fields1364 := fields1363 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1361) + p.pretty_type(unwrapped_fields1364) p.dedent() p.write(")") } @@ -3434,19 +3438,19 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - flat1365 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1365 != nil { - p.write(*flat1365) + flat1368 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1368 != nil { + p.write(*flat1368) return nil } else { _dollar_dollar := msg - fields1363 := _dollar_dollar.GetType() - unwrapped_fields1364 := fields1363 + fields1366 := _dollar_dollar.GetType() + unwrapped_fields1367 := fields1366 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1364) + p.pretty_type(unwrapped_fields1367) p.dedent() p.write(")") } @@ -3454,19 +3458,19 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1368 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1368 != nil { - p.write(*flat1368) + flat1371 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1371 != nil { + p.write(*flat1371) return nil } else { _dollar_dollar := msg - fields1366 := _dollar_dollar.GetType() - unwrapped_fields1367 := fields1366 + fields1369 := _dollar_dollar.GetType() + unwrapped_fields1370 := fields1369 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1367) + p.pretty_type(unwrapped_fields1370) p.dedent() p.write(")") } @@ -3474,35 +3478,35 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - flat1376 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1376 != nil { - p.write(*flat1376) + flat1379 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1379 != nil { + p.write(*flat1379) return nil } else { _dollar_dollar := msg - var _t1807 []*pb.Attribute + var _t1813 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1807 = _dollar_dollar.GetAttrs() + _t1813 = _dollar_dollar.GetAttrs() } - fields1369 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1807} - unwrapped_fields1370 := fields1369 + fields1372 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1813} + unwrapped_fields1373 := fields1372 p.write("(") p.write("monus") p.indentSexp() p.newline() - field1371 := unwrapped_fields1370[0].(*pb.Monoid) - p.pretty_monoid(field1371) + field1374 := unwrapped_fields1373[0].(*pb.Monoid) + p.pretty_monoid(field1374) p.newline() - field1372 := unwrapped_fields1370[1].(*pb.RelationId) - p.pretty_relation_id(field1372) + field1375 := unwrapped_fields1373[1].(*pb.RelationId) + p.pretty_relation_id(field1375) p.newline() - field1373 := unwrapped_fields1370[2].([]interface{}) - p.pretty_abstraction_with_arity(field1373) - field1374 := unwrapped_fields1370[3].([]*pb.Attribute) - if field1374 != nil { + field1376 := unwrapped_fields1373[2].([]interface{}) + p.pretty_abstraction_with_arity(field1376) + field1377 := unwrapped_fields1373[3].([]*pb.Attribute) + if field1377 != nil { p.newline() - opt_val1375 := field1374 - p.pretty_attrs(opt_val1375) + opt_val1378 := field1377 + p.pretty_attrs(opt_val1378) } p.dedent() p.write(")") @@ -3511,29 +3515,29 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - flat1383 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1383 != nil { - p.write(*flat1383) + flat1386 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1386 != nil { + p.write(*flat1386) return nil } else { _dollar_dollar := msg - fields1377 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} - unwrapped_fields1378 := fields1377 + fields1380 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} + unwrapped_fields1381 := fields1380 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() - field1379 := unwrapped_fields1378[0].(*pb.RelationId) - p.pretty_relation_id(field1379) + field1382 := unwrapped_fields1381[0].(*pb.RelationId) + p.pretty_relation_id(field1382) p.newline() - field1380 := unwrapped_fields1378[1].(*pb.Abstraction) - p.pretty_abstraction(field1380) + field1383 := unwrapped_fields1381[1].(*pb.Abstraction) + p.pretty_abstraction(field1383) p.newline() - field1381 := unwrapped_fields1378[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1381) + field1384 := unwrapped_fields1381[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1384) p.newline() - field1382 := unwrapped_fields1378[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1382) + field1385 := unwrapped_fields1381[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1385) p.dedent() p.write(")") } @@ -3541,22 +3545,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - flat1387 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1387 != nil { - p.write(*flat1387) + flat1390 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1390 != nil { + p.write(*flat1390) return nil } else { - fields1384 := msg + fields1387 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1384) == 0) { + if !(len(fields1387) == 0) { p.newline() - for i1386, elem1385 := range fields1384 { - if (i1386 > 0) { + for i1389, elem1388 := range fields1387 { + if (i1389 > 0) { p.newline() } - p.pretty_var(elem1385) + p.pretty_var(elem1388) } } p.dedent() @@ -3566,22 +3570,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - flat1391 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1391 != nil { - p.write(*flat1391) + flat1394 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1394 != nil { + p.write(*flat1394) return nil } else { - fields1388 := msg + fields1391 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1388) == 0) { + if !(len(fields1391) == 0) { p.newline() - for i1390, elem1389 := range fields1388 { - if (i1390 > 0) { + for i1393, elem1392 := range fields1391 { + if (i1393 > 0) { p.newline() } - p.pretty_var(elem1389) + p.pretty_var(elem1392) } } p.dedent() @@ -3591,50 +3595,50 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - flat1400 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1400 != nil { - p.write(*flat1400) + flat1403 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1403 != nil { + p.write(*flat1403) return nil } else { _dollar_dollar := msg - var _t1808 *pb.EDB + var _t1814 *pb.EDB if hasProtoField(_dollar_dollar, "edb") { - _t1808 = _dollar_dollar.GetEdb() + _t1814 = _dollar_dollar.GetEdb() } - deconstruct_result1398 := _t1808 - if deconstruct_result1398 != nil { - unwrapped1399 := deconstruct_result1398 - p.pretty_edb(unwrapped1399) + deconstruct_result1401 := _t1814 + if deconstruct_result1401 != nil { + unwrapped1402 := deconstruct_result1401 + p.pretty_edb(unwrapped1402) } else { _dollar_dollar := msg - var _t1809 *pb.BeTreeRelation + var _t1815 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1809 = _dollar_dollar.GetBetreeRelation() + _t1815 = _dollar_dollar.GetBetreeRelation() } - deconstruct_result1396 := _t1809 - if deconstruct_result1396 != nil { - unwrapped1397 := deconstruct_result1396 - p.pretty_betree_relation(unwrapped1397) + deconstruct_result1399 := _t1815 + if deconstruct_result1399 != nil { + unwrapped1400 := deconstruct_result1399 + p.pretty_betree_relation(unwrapped1400) } else { _dollar_dollar := msg - var _t1810 *pb.CSVData + var _t1816 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1810 = _dollar_dollar.GetCsvData() + _t1816 = _dollar_dollar.GetCsvData() } - deconstruct_result1394 := _t1810 - if deconstruct_result1394 != nil { - unwrapped1395 := deconstruct_result1394 - p.pretty_csv_data(unwrapped1395) + deconstruct_result1397 := _t1816 + if deconstruct_result1397 != nil { + unwrapped1398 := deconstruct_result1397 + p.pretty_csv_data(unwrapped1398) } else { _dollar_dollar := msg - var _t1811 *pb.IcebergData + var _t1817 *pb.IcebergData if hasProtoField(_dollar_dollar, "iceberg_data") { - _t1811 = _dollar_dollar.GetIcebergData() + _t1817 = _dollar_dollar.GetIcebergData() } - deconstruct_result1392 := _t1811 - if deconstruct_result1392 != nil { - unwrapped1393 := deconstruct_result1392 - p.pretty_iceberg_data(unwrapped1393) + deconstruct_result1395 := _t1817 + if deconstruct_result1395 != nil { + unwrapped1396 := deconstruct_result1395 + p.pretty_iceberg_data(unwrapped1396) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3646,26 +3650,26 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { - flat1406 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) - if flat1406 != nil { - p.write(*flat1406) + flat1409 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) + if flat1409 != nil { + p.write(*flat1409) return nil } else { _dollar_dollar := msg - fields1401 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} - unwrapped_fields1402 := fields1401 + fields1404 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} + unwrapped_fields1405 := fields1404 p.write("(") p.write("edb") p.indentSexp() p.newline() - field1403 := unwrapped_fields1402[0].(*pb.RelationId) - p.pretty_relation_id(field1403) + field1406 := unwrapped_fields1405[0].(*pb.RelationId) + p.pretty_relation_id(field1406) p.newline() - field1404 := unwrapped_fields1402[1].([]string) - p.pretty_edb_path(field1404) + field1407 := unwrapped_fields1405[1].([]string) + p.pretty_edb_path(field1407) p.newline() - field1405 := unwrapped_fields1402[2].([]*pb.Type) - p.pretty_edb_types(field1405) + field1408 := unwrapped_fields1405[2].([]*pb.Type) + p.pretty_edb_types(field1408) p.dedent() p.write(")") } @@ -3673,19 +3677,19 @@ func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { } func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { - flat1410 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) - if flat1410 != nil { - p.write(*flat1410) + flat1413 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) + if flat1413 != nil { + p.write(*flat1413) return nil } else { - fields1407 := msg + fields1410 := msg p.write("[") p.indent() - for i1409, elem1408 := range fields1407 { - if (i1409 > 0) { + for i1412, elem1411 := range fields1410 { + if (i1412 > 0) { p.newline() } - p.write(p.formatStringValue(elem1408)) + p.write(p.formatStringValue(elem1411)) } p.dedent() p.write("]") @@ -3694,19 +3698,19 @@ func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { - flat1414 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) - if flat1414 != nil { - p.write(*flat1414) + flat1417 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) + if flat1417 != nil { + p.write(*flat1417) return nil } else { - fields1411 := msg + fields1414 := msg p.write("[") p.indent() - for i1413, elem1412 := range fields1411 { - if (i1413 > 0) { + for i1416, elem1415 := range fields1414 { + if (i1416 > 0) { p.newline() } - p.pretty_type(elem1412) + p.pretty_type(elem1415) } p.dedent() p.write("]") @@ -3715,23 +3719,23 @@ func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - flat1419 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1419 != nil { - p.write(*flat1419) + flat1422 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1422 != nil { + p.write(*flat1422) return nil } else { _dollar_dollar := msg - fields1415 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} - unwrapped_fields1416 := fields1415 + fields1418 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} + unwrapped_fields1419 := fields1418 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - field1417 := unwrapped_fields1416[0].(*pb.RelationId) - p.pretty_relation_id(field1417) + field1420 := unwrapped_fields1419[0].(*pb.RelationId) + p.pretty_relation_id(field1420) p.newline() - field1418 := unwrapped_fields1416[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1418) + field1421 := unwrapped_fields1419[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1421) p.dedent() p.write(")") } @@ -3739,27 +3743,27 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - flat1425 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1425 != nil { - p.write(*flat1425) + flat1428 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1428 != nil { + p.write(*flat1428) return nil } else { _dollar_dollar := msg - _t1812 := p.deconstruct_betree_info_config(_dollar_dollar) - fields1420 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1812} - unwrapped_fields1421 := fields1420 + _t1818 := p.deconstruct_betree_info_config(_dollar_dollar) + fields1423 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1818} + unwrapped_fields1424 := fields1423 p.write("(") p.write("betree_info") p.indentSexp() p.newline() - field1422 := unwrapped_fields1421[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1422) + field1425 := unwrapped_fields1424[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1425) p.newline() - field1423 := unwrapped_fields1421[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1423) + field1426 := unwrapped_fields1424[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1426) p.newline() - field1424 := unwrapped_fields1421[2].([][]interface{}) - p.pretty_config_dict(field1424) + field1427 := unwrapped_fields1424[2].([][]interface{}) + p.pretty_config_dict(field1427) p.dedent() p.write(")") } @@ -3767,22 +3771,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - flat1429 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1429 != nil { - p.write(*flat1429) + flat1432 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1432 != nil { + p.write(*flat1432) return nil } else { - fields1426 := msg + fields1429 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1426) == 0) { + if !(len(fields1429) == 0) { p.newline() - for i1428, elem1427 := range fields1426 { - if (i1428 > 0) { + for i1431, elem1430 := range fields1429 { + if (i1431 > 0) { p.newline() } - p.pretty_type(elem1427) + p.pretty_type(elem1430) } } p.dedent() @@ -3792,22 +3796,22 @@ func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} } func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface{} { - flat1433 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1433 != nil { - p.write(*flat1433) + flat1436 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1436 != nil { + p.write(*flat1436) return nil } else { - fields1430 := msg + fields1433 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1430) == 0) { + if !(len(fields1433) == 0) { p.newline() - for i1432, elem1431 := range fields1430 { - if (i1432 > 0) { + for i1435, elem1434 := range fields1433 { + if (i1435 > 0) { p.newline() } - p.pretty_type(elem1431) + p.pretty_type(elem1434) } } p.dedent() @@ -3817,40 +3821,40 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - flat1443 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1443 != nil { - p.write(*flat1443) + flat1446 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1446 != nil { + p.write(*flat1446) return nil } else { _dollar_dollar := msg - _t1813 := p.deconstruct_csv_data_columns_optional(_dollar_dollar) - _t1814 := p.deconstruct_csv_data_relations_optional(_dollar_dollar) - fields1434 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _t1813, _t1814, _dollar_dollar.GetAsof()} - unwrapped_fields1435 := fields1434 + _t1819 := p.deconstruct_csv_data_columns_optional(_dollar_dollar) + _t1820 := p.deconstruct_csv_data_relations_optional(_dollar_dollar) + fields1437 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _t1819, _t1820, _dollar_dollar.GetAsof()} + unwrapped_fields1438 := fields1437 p.write("(") p.write("csv_data") p.indentSexp() p.newline() - field1436 := unwrapped_fields1435[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1436) + field1439 := unwrapped_fields1438[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1439) p.newline() - field1437 := unwrapped_fields1435[1].(*pb.CSVConfig) - p.pretty_csv_config(field1437) - field1438 := unwrapped_fields1435[2].([]*pb.GNFColumn) - if field1438 != nil { + field1440 := unwrapped_fields1438[1].(*pb.CSVConfig) + p.pretty_csv_config(field1440) + field1441 := unwrapped_fields1438[2].([]*pb.GNFColumn) + if field1441 != nil { p.newline() - opt_val1439 := field1438 - p.pretty_gnf_columns(opt_val1439) + opt_val1442 := field1441 + p.pretty_gnf_columns(opt_val1442) } - field1440 := unwrapped_fields1435[3].(*pb.TargetRelations) - if field1440 != nil { + field1443 := unwrapped_fields1438[3].(*pb.TargetRelations) + if field1443 != nil { p.newline() - opt_val1441 := field1440 - p.pretty_target_relations(opt_val1441) + opt_val1444 := field1443 + p.pretty_target_relations(opt_val1444) } p.newline() - field1442 := unwrapped_fields1435[4].(string) - p.pretty_csv_asof(field1442) + field1445 := unwrapped_fields1438[4].(string) + p.pretty_csv_asof(field1445) p.dedent() p.write(")") } @@ -3858,36 +3862,36 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - flat1450 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1450 != nil { - p.write(*flat1450) + flat1453 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1453 != nil { + p.write(*flat1453) return nil } else { _dollar_dollar := msg - var _t1815 []string + var _t1821 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1815 = _dollar_dollar.GetPaths() + _t1821 = _dollar_dollar.GetPaths() } - var _t1816 *string + var _t1822 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1816 = ptr(string(_dollar_dollar.GetInlineData())) + _t1822 = ptr(string(_dollar_dollar.GetInlineData())) } - fields1444 := []interface{}{_t1815, _t1816} - unwrapped_fields1445 := fields1444 + fields1447 := []interface{}{_t1821, _t1822} + unwrapped_fields1448 := fields1447 p.write("(") p.write("csv_locator") p.indentSexp() - field1446 := unwrapped_fields1445[0].([]string) - if field1446 != nil { + field1449 := unwrapped_fields1448[0].([]string) + if field1449 != nil { p.newline() - opt_val1447 := field1446 - p.pretty_csv_locator_paths(opt_val1447) + opt_val1450 := field1449 + p.pretty_csv_locator_paths(opt_val1450) } - field1448 := unwrapped_fields1445[1].(*string) - if field1448 != nil { + field1451 := unwrapped_fields1448[1].(*string) + if field1451 != nil { p.newline() - opt_val1449 := *field1448 - p.pretty_csv_locator_inline_data(opt_val1449) + opt_val1452 := *field1451 + p.pretty_csv_locator_inline_data(opt_val1452) } p.dedent() p.write(")") @@ -3896,22 +3900,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - flat1454 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1454 != nil { - p.write(*flat1454) + flat1457 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1457 != nil { + p.write(*flat1457) return nil } else { - fields1451 := msg + fields1454 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1451) == 0) { + if !(len(fields1454) == 0) { p.newline() - for i1453, elem1452 := range fields1451 { - if (i1453 > 0) { + for i1456, elem1455 := range fields1454 { + if (i1456 > 0) { p.newline() } - p.write(p.formatStringValue(elem1452)) + p.write(p.formatStringValue(elem1455)) } } p.dedent() @@ -3921,17 +3925,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - flat1456 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1456 != nil { - p.write(*flat1456) + flat1459 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1459 != nil { + p.write(*flat1459) return nil } else { - fields1455 := msg + fields1458 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1455)) + p.write(p.formatStringValue(fields1458)) p.dedent() p.write(")") } @@ -3939,27 +3943,27 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - flat1462 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1462 != nil { - p.write(*flat1462) + flat1465 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1465 != nil { + p.write(*flat1465) return nil } else { _dollar_dollar := msg - _t1817 := p.deconstruct_csv_config(_dollar_dollar) - _t1818 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1457 := []interface{}{_t1817, _t1818} - unwrapped_fields1458 := fields1457 + _t1823 := p.deconstruct_csv_config(_dollar_dollar) + _t1824 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1460 := []interface{}{_t1823, _t1824} + unwrapped_fields1461 := fields1460 p.write("(") p.write("csv_config") p.indentSexp() p.newline() - field1459 := unwrapped_fields1458[0].([][]interface{}) - p.pretty_config_dict(field1459) - field1460 := unwrapped_fields1458[1].([][]interface{}) - if field1460 != nil { + field1462 := unwrapped_fields1461[0].([][]interface{}) + p.pretty_config_dict(field1462) + field1463 := unwrapped_fields1461[1].([][]interface{}) + if field1463 != nil { p.newline() - opt_val1461 := field1460 - p.pretty__storage_integration(opt_val1461) + opt_val1464 := field1463 + p.pretty__storage_integration(opt_val1464) } p.dedent() p.write(")") @@ -3968,17 +3972,17 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interface{} { - flat1464 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) - if flat1464 != nil { - p.write(*flat1464) + flat1467 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) + if flat1467 != nil { + p.write(*flat1467) return nil } else { - fields1463 := msg + fields1466 := msg p.write("(") p.write("storage_integration") p.indentSexp() p.newline() - p.pretty_config_dict(fields1463) + p.pretty_config_dict(fields1466) p.dedent() p.write(")") } @@ -3986,22 +3990,22 @@ func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interfa } func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { - flat1468 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) - if flat1468 != nil { - p.write(*flat1468) + flat1471 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) + if flat1471 != nil { + p.write(*flat1471) return nil } else { - fields1465 := msg + fields1468 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1465) == 0) { + if !(len(fields1468) == 0) { p.newline() - for i1467, elem1466 := range fields1465 { - if (i1467 > 0) { + for i1470, elem1469 := range fields1468 { + if (i1470 > 0) { p.newline() } - p.pretty_gnf_column(elem1466) + p.pretty_gnf_column(elem1469) } } p.dedent() @@ -4011,38 +4015,38 @@ func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { - flat1477 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) - if flat1477 != nil { - p.write(*flat1477) + flat1480 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) + if flat1480 != nil { + p.write(*flat1480) return nil } else { _dollar_dollar := msg - var _t1819 *pb.RelationId + var _t1825 *pb.RelationId if hasProtoField(_dollar_dollar, "target_id") { - _t1819 = _dollar_dollar.GetTargetId() + _t1825 = _dollar_dollar.GetTargetId() } - fields1469 := []interface{}{_dollar_dollar.GetColumnPath(), _t1819, _dollar_dollar.GetTypes()} - unwrapped_fields1470 := fields1469 + fields1472 := []interface{}{_dollar_dollar.GetColumnPath(), _t1825, _dollar_dollar.GetTypes()} + unwrapped_fields1473 := fields1472 p.write("(") p.write("column") p.indentSexp() p.newline() - field1471 := unwrapped_fields1470[0].([]string) - p.pretty_gnf_column_path(field1471) - field1472 := unwrapped_fields1470[1].(*pb.RelationId) - if field1472 != nil { + field1474 := unwrapped_fields1473[0].([]string) + p.pretty_gnf_column_path(field1474) + field1475 := unwrapped_fields1473[1].(*pb.RelationId) + if field1475 != nil { p.newline() - opt_val1473 := field1472 - p.pretty_relation_id(opt_val1473) + opt_val1476 := field1475 + p.pretty_relation_id(opt_val1476) } p.newline() p.write("[") - field1474 := unwrapped_fields1470[2].([]*pb.Type) - for i1476, elem1475 := range field1474 { - if (i1476 > 0) { + field1477 := unwrapped_fields1473[2].([]*pb.Type) + for i1479, elem1478 := range field1477 { + if (i1479 > 0) { p.newline() } - p.pretty_type(elem1475) + p.pretty_type(elem1478) } p.write("]") p.dedent() @@ -4052,36 +4056,36 @@ func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { - flat1484 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) - if flat1484 != nil { - p.write(*flat1484) + flat1487 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) + if flat1487 != nil { + p.write(*flat1487) return nil } else { _dollar_dollar := msg - var _t1820 *string + var _t1826 *string if int64(len(_dollar_dollar)) == 1 { - _t1820 = ptr(_dollar_dollar[0]) + _t1826 = ptr(_dollar_dollar[0]) } - deconstruct_result1482 := _t1820 - if deconstruct_result1482 != nil { - unwrapped1483 := *deconstruct_result1482 - p.write(p.formatStringValue(unwrapped1483)) + deconstruct_result1485 := _t1826 + if deconstruct_result1485 != nil { + unwrapped1486 := *deconstruct_result1485 + p.write(p.formatStringValue(unwrapped1486)) } else { _dollar_dollar := msg - var _t1821 []string + var _t1827 []string if int64(len(_dollar_dollar)) != 1 { - _t1821 = _dollar_dollar + _t1827 = _dollar_dollar } - deconstruct_result1478 := _t1821 - if deconstruct_result1478 != nil { - unwrapped1479 := deconstruct_result1478 + deconstruct_result1481 := _t1827 + if deconstruct_result1481 != nil { + unwrapped1482 := deconstruct_result1481 p.write("[") p.indent() - for i1481, elem1480 := range unwrapped1479 { - if (i1481 > 0) { + for i1484, elem1483 := range unwrapped1482 { + if (i1484 > 0) { p.newline() } - p.write(p.formatStringValue(elem1480)) + p.write(p.formatStringValue(elem1483)) } p.dedent() p.write("]") @@ -4094,72 +4098,101 @@ func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_target_relations(msg *pb.TargetRelations) interface{} { - flat1489 := p.tryFlat(msg, func() { p.pretty_target_relations(msg) }) - if flat1489 != nil { - p.write(*flat1489) + flat1492 := p.tryFlat(msg, func() { p.pretty_target_relations(msg) }) + if flat1492 != nil { + p.write(*flat1492) return nil } else { _dollar_dollar := msg - fields1485 := []interface{}{_dollar_dollar.GetKeys(), _dollar_dollar} - unwrapped_fields1486 := fields1485 + _t1828 := p.deconstruct_relation_keys(_dollar_dollar) + fields1488 := []interface{}{_t1828, _dollar_dollar} + unwrapped_fields1489 := fields1488 p.write("(") p.write("relations") p.indentSexp() p.newline() - field1487 := unwrapped_fields1486[0].([]*pb.NamedColumn) - p.pretty_relation_keys(field1487) + field1490 := unwrapped_fields1489[0].([]interface{}) + p.pretty_relation_keys(field1490) p.newline() - field1488 := unwrapped_fields1486[1].(*pb.TargetRelations) - p.pretty_relation_body(field1488) + field1491 := unwrapped_fields1489[1].(*pb.TargetRelations) + p.pretty_relation_body(field1491) p.dedent() p.write(")") } return nil } -func (p *PrettyPrinter) pretty_relation_keys(msg []*pb.NamedColumn) interface{} { - flat1493 := p.tryFlat(msg, func() { p.pretty_relation_keys(msg) }) - if flat1493 != nil { - p.write(*flat1493) +func (p *PrettyPrinter) pretty_relation_keys(msg []interface{}) interface{} { + flat1499 := p.tryFlat(msg, func() { p.pretty_relation_keys(msg) }) + if flat1499 != nil { + p.write(*flat1499) return nil } else { - fields1490 := msg - p.write("(") - p.write("keys") - p.indentSexp() - if !(len(fields1490) == 0) { - p.newline() - for i1492, elem1491 := range fields1490 { - if (i1492 > 0) { - p.newline() + _dollar_dollar := msg + var _t1829 []*pb.NamedColumn + if !(_dollar_dollar[1].(bool)) { + _t1829 = _dollar_dollar[0].([]*pb.NamedColumn) + } + deconstruct_result1495 := _t1829 + if deconstruct_result1495 != nil { + unwrapped1496 := deconstruct_result1495 + p.write("(") + p.write("keys") + p.indentSexp() + if !(len(unwrapped1496) == 0) { + p.newline() + for i1498, elem1497 := range unwrapped1496 { + if (i1498 > 0) { + p.newline() + } + p.pretty_named_column(elem1497) } - p.pretty_named_column(elem1491) + } + p.dedent() + p.write(")") + } else { + _dollar_dollar := msg + var _t1830 *string + if _dollar_dollar[1].(bool) { + _t1830 = ptr("synthetic_key") + } + deconstruct_result1493 := _t1830 + if deconstruct_result1493 != nil { + unwrapped1494 := *deconstruct_result1493 + p.write("(") + p.write("keys") + p.indentSexp() + p.newline() + p.write(":") + p.write(unwrapped1494) + p.dedent() + p.write(")") + } else { + panic(ParseError{msg: "No matching rule for relation_keys"}) } } - p.dedent() - p.write(")") } return nil } func (p *PrettyPrinter) pretty_named_column(msg *pb.NamedColumn) interface{} { - flat1498 := p.tryFlat(msg, func() { p.pretty_named_column(msg) }) - if flat1498 != nil { - p.write(*flat1498) + flat1504 := p.tryFlat(msg, func() { p.pretty_named_column(msg) }) + if flat1504 != nil { + p.write(*flat1504) return nil } else { _dollar_dollar := msg - fields1494 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetType()} - unwrapped_fields1495 := fields1494 + fields1500 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetType()} + unwrapped_fields1501 := fields1500 p.write("(") p.write("column") p.indentSexp() p.newline() - field1496 := unwrapped_fields1495[0].(string) - p.write(p.formatStringValue(field1496)) + field1502 := unwrapped_fields1501[0].(string) + p.write(p.formatStringValue(field1502)) p.newline() - field1497 := unwrapped_fields1495[1].(*pb.Type) - p.pretty_type(field1497) + field1503 := unwrapped_fields1501[1].(*pb.Type) + p.pretty_type(field1503) p.dedent() p.write(")") } @@ -4167,34 +4200,34 @@ func (p *PrettyPrinter) pretty_named_column(msg *pb.NamedColumn) interface{} { } func (p *PrettyPrinter) pretty_relation_body(msg *pb.TargetRelations) interface{} { - flat1505 := p.tryFlat(msg, func() { p.pretty_relation_body(msg) }) - if flat1505 != nil { - p.write(*flat1505) + flat1511 := p.tryFlat(msg, func() { p.pretty_relation_body(msg) }) + if flat1511 != nil { + p.write(*flat1511) return nil } else { _dollar_dollar := msg - var _t1822 []*pb.TargetRelation + var _t1831 []*pb.TargetRelation if hasProtoField(_dollar_dollar, "plain") { - _t1822 = _dollar_dollar.GetPlain().GetTargets() + _t1831 = _dollar_dollar.GetPlain().GetTargets() } - deconstruct_result1503 := _t1822 - if deconstruct_result1503 != nil { - unwrapped1504 := deconstruct_result1503 - p.pretty_non_cdc_relations(unwrapped1504) + deconstruct_result1509 := _t1831 + if deconstruct_result1509 != nil { + unwrapped1510 := deconstruct_result1509 + p.pretty_non_cdc_relations(unwrapped1510) } else { _dollar_dollar := msg - var _t1823 []interface{} + var _t1832 []interface{} if hasProtoField(_dollar_dollar, "cdc") { - _t1823 = []interface{}{_dollar_dollar.GetCdc().GetInserts(), _dollar_dollar.GetCdc().GetDeletes()} + _t1832 = []interface{}{_dollar_dollar.GetCdc().GetInserts(), _dollar_dollar.GetCdc().GetDeletes()} } - deconstruct_result1499 := _t1823 - if deconstruct_result1499 != nil { - unwrapped1500 := deconstruct_result1499 - field1501 := unwrapped1500[0].([]*pb.TargetRelation) - p.pretty_cdc_inserts(field1501) + deconstruct_result1505 := _t1832 + if deconstruct_result1505 != nil { + unwrapped1506 := deconstruct_result1505 + field1507 := unwrapped1506[0].([]*pb.TargetRelation) + p.pretty_cdc_inserts(field1507) p.write(" ") - field1502 := unwrapped1500[1].([]*pb.TargetRelation) - p.pretty_cdc_deletes(field1502) + field1508 := unwrapped1506[1].([]*pb.TargetRelation) + p.pretty_cdc_deletes(field1508) } else { panic(ParseError{msg: "No matching rule for relation_body"}) } @@ -4204,45 +4237,45 @@ func (p *PrettyPrinter) pretty_relation_body(msg *pb.TargetRelations) interface{ } func (p *PrettyPrinter) pretty_non_cdc_relations(msg []*pb.TargetRelation) interface{} { - flat1509 := p.tryFlat(msg, func() { p.pretty_non_cdc_relations(msg) }) - if flat1509 != nil { - p.write(*flat1509) + flat1515 := p.tryFlat(msg, func() { p.pretty_non_cdc_relations(msg) }) + if flat1515 != nil { + p.write(*flat1515) return nil } else { - fields1506 := msg - for i1508, elem1507 := range fields1506 { - if (i1508 > 0) { + fields1512 := msg + for i1514, elem1513 := range fields1512 { + if (i1514 > 0) { p.newline() } - p.pretty_target_relation(elem1507) + p.pretty_target_relation(elem1513) } } return nil } func (p *PrettyPrinter) pretty_target_relation(msg *pb.TargetRelation) interface{} { - flat1516 := p.tryFlat(msg, func() { p.pretty_target_relation(msg) }) - if flat1516 != nil { - p.write(*flat1516) + flat1522 := p.tryFlat(msg, func() { p.pretty_target_relation(msg) }) + if flat1522 != nil { + p.write(*flat1522) return nil } else { _dollar_dollar := msg - fields1510 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetValues()} - unwrapped_fields1511 := fields1510 + fields1516 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetValues()} + unwrapped_fields1517 := fields1516 p.write("(") p.write("relation") p.indentSexp() p.newline() - field1512 := unwrapped_fields1511[0].(*pb.RelationId) - p.pretty_relation_id(field1512) - field1513 := unwrapped_fields1511[1].([]*pb.NamedColumn) - if !(len(field1513) == 0) { + field1518 := unwrapped_fields1517[0].(*pb.RelationId) + p.pretty_relation_id(field1518) + field1519 := unwrapped_fields1517[1].([]*pb.NamedColumn) + if !(len(field1519) == 0) { p.newline() - for i1515, elem1514 := range field1513 { - if (i1515 > 0) { + for i1521, elem1520 := range field1519 { + if (i1521 > 0) { p.newline() } - p.pretty_named_column(elem1514) + p.pretty_named_column(elem1520) } } p.dedent() @@ -4252,22 +4285,22 @@ func (p *PrettyPrinter) pretty_target_relation(msg *pb.TargetRelation) interface } func (p *PrettyPrinter) pretty_cdc_inserts(msg []*pb.TargetRelation) interface{} { - flat1520 := p.tryFlat(msg, func() { p.pretty_cdc_inserts(msg) }) - if flat1520 != nil { - p.write(*flat1520) + flat1526 := p.tryFlat(msg, func() { p.pretty_cdc_inserts(msg) }) + if flat1526 != nil { + p.write(*flat1526) return nil } else { - fields1517 := msg + fields1523 := msg p.write("(") p.write("inserts") p.indentSexp() - if !(len(fields1517) == 0) { + if !(len(fields1523) == 0) { p.newline() - for i1519, elem1518 := range fields1517 { - if (i1519 > 0) { + for i1525, elem1524 := range fields1523 { + if (i1525 > 0) { p.newline() } - p.pretty_target_relation(elem1518) + p.pretty_target_relation(elem1524) } } p.dedent() @@ -4277,22 +4310,22 @@ func (p *PrettyPrinter) pretty_cdc_inserts(msg []*pb.TargetRelation) interface{} } func (p *PrettyPrinter) pretty_cdc_deletes(msg []*pb.TargetRelation) interface{} { - flat1524 := p.tryFlat(msg, func() { p.pretty_cdc_deletes(msg) }) - if flat1524 != nil { - p.write(*flat1524) + flat1530 := p.tryFlat(msg, func() { p.pretty_cdc_deletes(msg) }) + if flat1530 != nil { + p.write(*flat1530) return nil } else { - fields1521 := msg + fields1527 := msg p.write("(") p.write("deletes") p.indentSexp() - if !(len(fields1521) == 0) { + if !(len(fields1527) == 0) { p.newline() - for i1523, elem1522 := range fields1521 { - if (i1523 > 0) { + for i1529, elem1528 := range fields1527 { + if (i1529 > 0) { p.newline() } - p.pretty_target_relation(elem1522) + p.pretty_target_relation(elem1528) } } p.dedent() @@ -4302,17 +4335,17 @@ func (p *PrettyPrinter) pretty_cdc_deletes(msg []*pb.TargetRelation) interface{} } func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1526 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1526 != nil { - p.write(*flat1526) + flat1532 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1532 != nil { + p.write(*flat1532) return nil } else { - fields1525 := msg + fields1531 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1525)) + p.write(p.formatStringValue(fields1531)) p.dedent() p.write(")") } @@ -4320,43 +4353,43 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { - flat1537 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) - if flat1537 != nil { - p.write(*flat1537) + flat1543 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) + if flat1543 != nil { + p.write(*flat1543) return nil } else { _dollar_dollar := msg - _t1824 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1825 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1527 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1824, _t1825, _dollar_dollar.GetReturnsDelta()} - unwrapped_fields1528 := fields1527 + _t1833 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1834 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1533 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1833, _t1834, _dollar_dollar.GetReturnsDelta()} + unwrapped_fields1534 := fields1533 p.write("(") p.write("iceberg_data") p.indentSexp() p.newline() - field1529 := unwrapped_fields1528[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1529) + field1535 := unwrapped_fields1534[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1535) p.newline() - field1530 := unwrapped_fields1528[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1530) + field1536 := unwrapped_fields1534[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1536) p.newline() - field1531 := unwrapped_fields1528[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1531) - field1532 := unwrapped_fields1528[3].(*string) - if field1532 != nil { + field1537 := unwrapped_fields1534[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1537) + field1538 := unwrapped_fields1534[3].(*string) + if field1538 != nil { p.newline() - opt_val1533 := *field1532 - p.pretty_iceberg_from_snapshot(opt_val1533) + opt_val1539 := *field1538 + p.pretty_iceberg_from_snapshot(opt_val1539) } - field1534 := unwrapped_fields1528[4].(*string) - if field1534 != nil { + field1540 := unwrapped_fields1534[4].(*string) + if field1540 != nil { p.newline() - opt_val1535 := *field1534 - p.pretty_iceberg_to_snapshot(opt_val1535) + opt_val1541 := *field1540 + p.pretty_iceberg_to_snapshot(opt_val1541) } p.newline() - field1536 := unwrapped_fields1528[5].(bool) - p.pretty_boolean_value(field1536) + field1542 := unwrapped_fields1534[5].(bool) + p.pretty_boolean_value(field1542) p.dedent() p.write(")") } @@ -4364,26 +4397,26 @@ func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { } func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface{} { - flat1543 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) - if flat1543 != nil { - p.write(*flat1543) + flat1549 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) + if flat1549 != nil { + p.write(*flat1549) return nil } else { _dollar_dollar := msg - fields1538 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} - unwrapped_fields1539 := fields1538 + fields1544 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} + unwrapped_fields1545 := fields1544 p.write("(") p.write("iceberg_locator") p.indentSexp() p.newline() - field1540 := unwrapped_fields1539[0].(string) - p.pretty_iceberg_locator_table_name(field1540) + field1546 := unwrapped_fields1545[0].(string) + p.pretty_iceberg_locator_table_name(field1546) p.newline() - field1541 := unwrapped_fields1539[1].([]string) - p.pretty_iceberg_locator_namespace(field1541) + field1547 := unwrapped_fields1545[1].([]string) + p.pretty_iceberg_locator_namespace(field1547) p.newline() - field1542 := unwrapped_fields1539[2].(string) - p.pretty_iceberg_locator_warehouse(field1542) + field1548 := unwrapped_fields1545[2].(string) + p.pretty_iceberg_locator_warehouse(field1548) p.dedent() p.write(")") } @@ -4391,17 +4424,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface } func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{} { - flat1545 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) - if flat1545 != nil { - p.write(*flat1545) + flat1551 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) + if flat1551 != nil { + p.write(*flat1551) return nil } else { - fields1544 := msg + fields1550 := msg p.write("(") p.write("table_name") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1544)) + p.write(p.formatStringValue(fields1550)) p.dedent() p.write(")") } @@ -4409,22 +4442,22 @@ func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{ } func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface{} { - flat1549 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) - if flat1549 != nil { - p.write(*flat1549) + flat1555 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) + if flat1555 != nil { + p.write(*flat1555) return nil } else { - fields1546 := msg + fields1552 := msg p.write("(") p.write("namespace") p.indentSexp() - if !(len(fields1546) == 0) { + if !(len(fields1552) == 0) { p.newline() - for i1548, elem1547 := range fields1546 { - if (i1548 > 0) { + for i1554, elem1553 := range fields1552 { + if (i1554 > 0) { p.newline() } - p.write(p.formatStringValue(elem1547)) + p.write(p.formatStringValue(elem1553)) } } p.dedent() @@ -4434,17 +4467,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface } func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} { - flat1551 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) - if flat1551 != nil { - p.write(*flat1551) + flat1557 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) + if flat1557 != nil { + p.write(*flat1557) return nil } else { - fields1550 := msg + fields1556 := msg p.write("(") p.write("warehouse") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1550)) + p.write(p.formatStringValue(fields1556)) p.dedent() p.write(")") } @@ -4452,33 +4485,33 @@ func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} } func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConfig) interface{} { - flat1559 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) - if flat1559 != nil { - p.write(*flat1559) + flat1565 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) + if flat1565 != nil { + p.write(*flat1565) return nil } else { _dollar_dollar := msg - _t1826 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1552 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1826, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} - unwrapped_fields1553 := fields1552 + _t1835 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1558 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1835, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} + unwrapped_fields1559 := fields1558 p.write("(") p.write("iceberg_catalog_config") p.indentSexp() p.newline() - field1554 := unwrapped_fields1553[0].(string) - p.pretty_iceberg_catalog_uri(field1554) - field1555 := unwrapped_fields1553[1].(*string) - if field1555 != nil { + field1560 := unwrapped_fields1559[0].(string) + p.pretty_iceberg_catalog_uri(field1560) + field1561 := unwrapped_fields1559[1].(*string) + if field1561 != nil { p.newline() - opt_val1556 := *field1555 - p.pretty_iceberg_catalog_config_scope(opt_val1556) + opt_val1562 := *field1561 + p.pretty_iceberg_catalog_config_scope(opt_val1562) } p.newline() - field1557 := unwrapped_fields1553[2].([][]interface{}) - p.pretty_iceberg_properties(field1557) + field1563 := unwrapped_fields1559[2].([][]interface{}) + p.pretty_iceberg_properties(field1563) p.newline() - field1558 := unwrapped_fields1553[3].([][]interface{}) - p.pretty_iceberg_auth_properties(field1558) + field1564 := unwrapped_fields1559[3].([][]interface{}) + p.pretty_iceberg_auth_properties(field1564) p.dedent() p.write(")") } @@ -4486,17 +4519,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConf } func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { - flat1561 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) - if flat1561 != nil { - p.write(*flat1561) + flat1567 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) + if flat1567 != nil { + p.write(*flat1567) return nil } else { - fields1560 := msg + fields1566 := msg p.write("(") p.write("catalog_uri") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1560)) + p.write(p.formatStringValue(fields1566)) p.dedent() p.write(")") } @@ -4504,17 +4537,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interface{} { - flat1563 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) - if flat1563 != nil { - p.write(*flat1563) + flat1569 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) + if flat1569 != nil { + p.write(*flat1569) return nil } else { - fields1562 := msg + fields1568 := msg p.write("(") p.write("scope") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1562)) + p.write(p.formatStringValue(fields1568)) p.dedent() p.write(")") } @@ -4522,22 +4555,22 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interfac } func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface{} { - flat1567 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) - if flat1567 != nil { - p.write(*flat1567) + flat1573 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) + if flat1573 != nil { + p.write(*flat1573) return nil } else { - fields1564 := msg + fields1570 := msg p.write("(") p.write("properties") p.indentSexp() - if !(len(fields1564) == 0) { + if !(len(fields1570) == 0) { p.newline() - for i1566, elem1565 := range fields1564 { - if (i1566 > 0) { + for i1572, elem1571 := range fields1570 { + if (i1572 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1565) + p.pretty_iceberg_property_entry(elem1571) } } p.dedent() @@ -4547,23 +4580,23 @@ func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface } func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interface{} { - flat1572 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) - if flat1572 != nil { - p.write(*flat1572) + flat1578 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) + if flat1578 != nil { + p.write(*flat1578) return nil } else { _dollar_dollar := msg - fields1568 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} - unwrapped_fields1569 := fields1568 + fields1574 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} + unwrapped_fields1575 := fields1574 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1570 := unwrapped_fields1569[0].(string) - p.write(p.formatStringValue(field1570)) + field1576 := unwrapped_fields1575[0].(string) + p.write(p.formatStringValue(field1576)) p.newline() - field1571 := unwrapped_fields1569[1].(string) - p.write(p.formatStringValue(field1571)) + field1577 := unwrapped_fields1575[1].(string) + p.write(p.formatStringValue(field1577)) p.dedent() p.write(")") } @@ -4571,22 +4604,22 @@ func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) interface{} { - flat1576 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) - if flat1576 != nil { - p.write(*flat1576) + flat1582 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) + if flat1582 != nil { + p.write(*flat1582) return nil } else { - fields1573 := msg + fields1579 := msg p.write("(") p.write("auth_properties") p.indentSexp() - if !(len(fields1573) == 0) { + if !(len(fields1579) == 0) { p.newline() - for i1575, elem1574 := range fields1573 { - if (i1575 > 0) { + for i1581, elem1580 := range fields1579 { + if (i1581 > 0) { p.newline() } - p.pretty_iceberg_masked_property_entry(elem1574) + p.pretty_iceberg_masked_property_entry(elem1580) } } p.dedent() @@ -4596,24 +4629,24 @@ func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) inte } func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) interface{} { - flat1581 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) - if flat1581 != nil { - p.write(*flat1581) + flat1587 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) + if flat1587 != nil { + p.write(*flat1587) return nil } else { _dollar_dollar := msg - _t1827 := p.mask_secret_value(_dollar_dollar) - fields1577 := []interface{}{_dollar_dollar[0].(string), _t1827} - unwrapped_fields1578 := fields1577 + _t1836 := p.mask_secret_value(_dollar_dollar) + fields1583 := []interface{}{_dollar_dollar[0].(string), _t1836} + unwrapped_fields1584 := fields1583 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1579 := unwrapped_fields1578[0].(string) - p.write(p.formatStringValue(field1579)) + field1585 := unwrapped_fields1584[0].(string) + p.write(p.formatStringValue(field1585)) p.newline() - field1580 := unwrapped_fields1578[1].(string) - p.write(p.formatStringValue(field1580)) + field1586 := unwrapped_fields1584[1].(string) + p.write(p.formatStringValue(field1586)) p.dedent() p.write(")") } @@ -4621,17 +4654,17 @@ func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) } func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { - flat1583 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) - if flat1583 != nil { - p.write(*flat1583) + flat1589 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) + if flat1589 != nil { + p.write(*flat1589) return nil } else { - fields1582 := msg + fields1588 := msg p.write("(") p.write("from_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1582)) + p.write(p.formatStringValue(fields1588)) p.dedent() p.write(")") } @@ -4639,17 +4672,17 @@ func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { - flat1585 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) - if flat1585 != nil { - p.write(*flat1585) + flat1591 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) + if flat1591 != nil { + p.write(*flat1591) return nil } else { - fields1584 := msg + fields1590 := msg p.write("(") p.write("to_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1584)) + p.write(p.formatStringValue(fields1590)) p.dedent() p.write(")") } @@ -4657,19 +4690,19 @@ func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - flat1588 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1588 != nil { - p.write(*flat1588) + flat1594 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1594 != nil { + p.write(*flat1594) return nil } else { _dollar_dollar := msg - fields1586 := _dollar_dollar.GetFragmentId() - unwrapped_fields1587 := fields1586 + fields1592 := _dollar_dollar.GetFragmentId() + unwrapped_fields1593 := fields1592 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1587) + p.pretty_fragment_id(unwrapped_fields1593) p.dedent() p.write(")") } @@ -4677,24 +4710,24 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1593 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1593 != nil { - p.write(*flat1593) + flat1599 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1599 != nil { + p.write(*flat1599) return nil } else { _dollar_dollar := msg - fields1589 := _dollar_dollar.GetRelations() - unwrapped_fields1590 := fields1589 + fields1595 := _dollar_dollar.GetRelations() + unwrapped_fields1596 := fields1595 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1590) == 0) { + if !(len(unwrapped_fields1596) == 0) { p.newline() - for i1592, elem1591 := range unwrapped_fields1590 { - if (i1592 > 0) { + for i1598, elem1597 := range unwrapped_fields1596 { + if (i1598 > 0) { p.newline() } - p.pretty_relation_id(elem1591) + p.pretty_relation_id(elem1597) } } p.dedent() @@ -4704,28 +4737,28 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - flat1600 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1600 != nil { - p.write(*flat1600) + flat1606 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1606 != nil { + p.write(*flat1606) return nil } else { _dollar_dollar := msg - fields1594 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} - unwrapped_fields1595 := fields1594 + fields1600 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} + unwrapped_fields1601 := fields1600 p.write("(") p.write("snapshot") p.indentSexp() p.newline() - field1596 := unwrapped_fields1595[0].([]string) - p.pretty_edb_path(field1596) - field1597 := unwrapped_fields1595[1].([]*pb.SnapshotMapping) - if !(len(field1597) == 0) { + field1602 := unwrapped_fields1601[0].([]string) + p.pretty_edb_path(field1602) + field1603 := unwrapped_fields1601[1].([]*pb.SnapshotMapping) + if !(len(field1603) == 0) { p.newline() - for i1599, elem1598 := range field1597 { - if (i1599 > 0) { + for i1605, elem1604 := range field1603 { + if (i1605 > 0) { p.newline() } - p.pretty_snapshot_mapping(elem1598) + p.pretty_snapshot_mapping(elem1604) } } p.dedent() @@ -4735,40 +4768,40 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} { - flat1605 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) - if flat1605 != nil { - p.write(*flat1605) + flat1611 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) + if flat1611 != nil { + p.write(*flat1611) return nil } else { _dollar_dollar := msg - fields1601 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} - unwrapped_fields1602 := fields1601 - field1603 := unwrapped_fields1602[0].([]string) - p.pretty_edb_path(field1603) + fields1607 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} + unwrapped_fields1608 := fields1607 + field1609 := unwrapped_fields1608[0].([]string) + p.pretty_edb_path(field1609) p.write(" ") - field1604 := unwrapped_fields1602[1].(*pb.RelationId) - p.pretty_relation_id(field1604) + field1610 := unwrapped_fields1608[1].(*pb.RelationId) + p.pretty_relation_id(field1610) } return nil } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - flat1609 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1609 != nil { - p.write(*flat1609) + flat1615 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1615 != nil { + p.write(*flat1615) return nil } else { - fields1606 := msg + fields1612 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1606) == 0) { + if !(len(fields1612) == 0) { p.newline() - for i1608, elem1607 := range fields1606 { - if (i1608 > 0) { + for i1614, elem1613 := range fields1612 { + if (i1614 > 0) { p.newline() } - p.pretty_read(elem1607) + p.pretty_read(elem1613) } } p.dedent() @@ -4778,60 +4811,60 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - flat1620 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1620 != nil { - p.write(*flat1620) + flat1626 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1626 != nil { + p.write(*flat1626) return nil } else { _dollar_dollar := msg - var _t1828 *pb.Demand + var _t1837 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1828 = _dollar_dollar.GetDemand() + _t1837 = _dollar_dollar.GetDemand() } - deconstruct_result1618 := _t1828 - if deconstruct_result1618 != nil { - unwrapped1619 := deconstruct_result1618 - p.pretty_demand(unwrapped1619) + deconstruct_result1624 := _t1837 + if deconstruct_result1624 != nil { + unwrapped1625 := deconstruct_result1624 + p.pretty_demand(unwrapped1625) } else { _dollar_dollar := msg - var _t1829 *pb.Output + var _t1838 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1829 = _dollar_dollar.GetOutput() + _t1838 = _dollar_dollar.GetOutput() } - deconstruct_result1616 := _t1829 - if deconstruct_result1616 != nil { - unwrapped1617 := deconstruct_result1616 - p.pretty_output(unwrapped1617) + deconstruct_result1622 := _t1838 + if deconstruct_result1622 != nil { + unwrapped1623 := deconstruct_result1622 + p.pretty_output(unwrapped1623) } else { _dollar_dollar := msg - var _t1830 *pb.WhatIf + var _t1839 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1830 = _dollar_dollar.GetWhatIf() + _t1839 = _dollar_dollar.GetWhatIf() } - deconstruct_result1614 := _t1830 - if deconstruct_result1614 != nil { - unwrapped1615 := deconstruct_result1614 - p.pretty_what_if(unwrapped1615) + deconstruct_result1620 := _t1839 + if deconstruct_result1620 != nil { + unwrapped1621 := deconstruct_result1620 + p.pretty_what_if(unwrapped1621) } else { _dollar_dollar := msg - var _t1831 *pb.Abort + var _t1840 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1831 = _dollar_dollar.GetAbort() + _t1840 = _dollar_dollar.GetAbort() } - deconstruct_result1612 := _t1831 - if deconstruct_result1612 != nil { - unwrapped1613 := deconstruct_result1612 - p.pretty_abort(unwrapped1613) + deconstruct_result1618 := _t1840 + if deconstruct_result1618 != nil { + unwrapped1619 := deconstruct_result1618 + p.pretty_abort(unwrapped1619) } else { _dollar_dollar := msg - var _t1832 *pb.Export + var _t1841 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1832 = _dollar_dollar.GetExport() + _t1841 = _dollar_dollar.GetExport() } - deconstruct_result1610 := _t1832 - if deconstruct_result1610 != nil { - unwrapped1611 := deconstruct_result1610 - p.pretty_export(unwrapped1611) + deconstruct_result1616 := _t1841 + if deconstruct_result1616 != nil { + unwrapped1617 := deconstruct_result1616 + p.pretty_export(unwrapped1617) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -4844,19 +4877,19 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - flat1623 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1623 != nil { - p.write(*flat1623) + flat1629 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1629 != nil { + p.write(*flat1629) return nil } else { _dollar_dollar := msg - fields1621 := _dollar_dollar.GetRelationId() - unwrapped_fields1622 := fields1621 + fields1627 := _dollar_dollar.GetRelationId() + unwrapped_fields1628 := fields1627 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1622) + p.pretty_relation_id(unwrapped_fields1628) p.dedent() p.write(")") } @@ -4864,23 +4897,23 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - flat1628 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1628 != nil { - p.write(*flat1628) + flat1634 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1634 != nil { + p.write(*flat1634) return nil } else { _dollar_dollar := msg - fields1624 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} - unwrapped_fields1625 := fields1624 + fields1630 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} + unwrapped_fields1631 := fields1630 p.write("(") p.write("output") p.indentSexp() p.newline() - field1626 := unwrapped_fields1625[0].(string) - p.pretty_name(field1626) + field1632 := unwrapped_fields1631[0].(string) + p.pretty_name(field1632) p.newline() - field1627 := unwrapped_fields1625[1].(*pb.RelationId) - p.pretty_relation_id(field1627) + field1633 := unwrapped_fields1631[1].(*pb.RelationId) + p.pretty_relation_id(field1633) p.dedent() p.write(")") } @@ -4888,23 +4921,23 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - flat1633 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1633 != nil { - p.write(*flat1633) + flat1639 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1639 != nil { + p.write(*flat1639) return nil } else { _dollar_dollar := msg - fields1629 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} - unwrapped_fields1630 := fields1629 + fields1635 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} + unwrapped_fields1636 := fields1635 p.write("(") p.write("what_if") p.indentSexp() p.newline() - field1631 := unwrapped_fields1630[0].(string) - p.pretty_name(field1631) + field1637 := unwrapped_fields1636[0].(string) + p.pretty_name(field1637) p.newline() - field1632 := unwrapped_fields1630[1].(*pb.Epoch) - p.pretty_epoch(field1632) + field1638 := unwrapped_fields1636[1].(*pb.Epoch) + p.pretty_epoch(field1638) p.dedent() p.write(")") } @@ -4912,30 +4945,30 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - flat1639 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1639 != nil { - p.write(*flat1639) + flat1645 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1645 != nil { + p.write(*flat1645) return nil } else { _dollar_dollar := msg - var _t1833 *string + var _t1842 *string if _dollar_dollar.GetName() != "abort" { - _t1833 = ptr(_dollar_dollar.GetName()) + _t1842 = ptr(_dollar_dollar.GetName()) } - fields1634 := []interface{}{_t1833, _dollar_dollar.GetRelationId()} - unwrapped_fields1635 := fields1634 + fields1640 := []interface{}{_t1842, _dollar_dollar.GetRelationId()} + unwrapped_fields1641 := fields1640 p.write("(") p.write("abort") p.indentSexp() - field1636 := unwrapped_fields1635[0].(*string) - if field1636 != nil { + field1642 := unwrapped_fields1641[0].(*string) + if field1642 != nil { p.newline() - opt_val1637 := *field1636 - p.pretty_name(opt_val1637) + opt_val1643 := *field1642 + p.pretty_name(opt_val1643) } p.newline() - field1638 := unwrapped_fields1635[1].(*pb.RelationId) - p.pretty_relation_id(field1638) + field1644 := unwrapped_fields1641[1].(*pb.RelationId) + p.pretty_relation_id(field1644) p.dedent() p.write(")") } @@ -4943,40 +4976,40 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - flat1644 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1644 != nil { - p.write(*flat1644) + flat1650 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1650 != nil { + p.write(*flat1650) return nil } else { _dollar_dollar := msg - var _t1834 *pb.ExportCSVConfig + var _t1843 *pb.ExportCSVConfig if hasProtoField(_dollar_dollar, "csv_config") { - _t1834 = _dollar_dollar.GetCsvConfig() + _t1843 = _dollar_dollar.GetCsvConfig() } - deconstruct_result1642 := _t1834 - if deconstruct_result1642 != nil { - unwrapped1643 := deconstruct_result1642 + deconstruct_result1648 := _t1843 + if deconstruct_result1648 != nil { + unwrapped1649 := deconstruct_result1648 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped1643) + p.pretty_export_csv_config(unwrapped1649) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1835 *pb.ExportIcebergConfig + var _t1844 *pb.ExportIcebergConfig if hasProtoField(_dollar_dollar, "iceberg_config") { - _t1835 = _dollar_dollar.GetIcebergConfig() + _t1844 = _dollar_dollar.GetIcebergConfig() } - deconstruct_result1640 := _t1835 - if deconstruct_result1640 != nil { - unwrapped1641 := deconstruct_result1640 + deconstruct_result1646 := _t1844 + if deconstruct_result1646 != nil { + unwrapped1647 := deconstruct_result1646 p.write("(") p.write("export_iceberg") p.indentSexp() p.newline() - p.pretty_export_iceberg_config(unwrapped1641) + p.pretty_export_iceberg_config(unwrapped1647) p.dedent() p.write(")") } else { @@ -4988,56 +5021,56 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - flat1655 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1655 != nil { - p.write(*flat1655) + flat1661 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1661 != nil { + p.write(*flat1661) return nil } else { _dollar_dollar := msg - var _t1836 []interface{} + var _t1845 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) == 0 { - _t1837 := p.deconstruct_export_csv_output_location(_dollar_dollar) - _t1836 = []interface{}{_t1837, _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} + _t1846 := p.deconstruct_export_csv_output_location(_dollar_dollar) + _t1845 = []interface{}{_t1846, _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} } - deconstruct_result1650 := _t1836 - if deconstruct_result1650 != nil { - unwrapped1651 := deconstruct_result1650 + deconstruct_result1656 := _t1845 + if deconstruct_result1656 != nil { + unwrapped1657 := deconstruct_result1656 p.write("(") p.write("export_csv_config_v2") p.indentSexp() p.newline() - field1652 := unwrapped1651[0].([]interface{}) - p.pretty_export_csv_output_location(field1652) + field1658 := unwrapped1657[0].([]interface{}) + p.pretty_export_csv_output_location(field1658) p.newline() - field1653 := unwrapped1651[1].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1653) + field1659 := unwrapped1657[1].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1659) p.newline() - field1654 := unwrapped1651[2].(*pb.CSVConfig) - p.pretty_csv_config(field1654) + field1660 := unwrapped1657[2].(*pb.CSVConfig) + p.pretty_csv_config(field1660) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1838 []interface{} + var _t1847 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) != 0 { - _t1839 := p.deconstruct_export_csv_config(_dollar_dollar) - _t1838 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1839} + _t1848 := p.deconstruct_export_csv_config(_dollar_dollar) + _t1847 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1848} } - deconstruct_result1645 := _t1838 - if deconstruct_result1645 != nil { - unwrapped1646 := deconstruct_result1645 + deconstruct_result1651 := _t1847 + if deconstruct_result1651 != nil { + unwrapped1652 := deconstruct_result1651 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - field1647 := unwrapped1646[0].(string) - p.pretty_export_csv_path(field1647) + field1653 := unwrapped1652[0].(string) + p.pretty_export_csv_path(field1653) p.newline() - field1648 := unwrapped1646[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns_list(field1648) + field1654 := unwrapped1652[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns_list(field1654) p.newline() - field1649 := unwrapped1646[2].([][]interface{}) - p.pretty_config_dict(field1649) + field1655 := unwrapped1652[2].([][]interface{}) + p.pretty_config_dict(field1655) p.dedent() p.write(")") } else { @@ -5049,40 +5082,40 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf } func (p *PrettyPrinter) pretty_export_csv_output_location(msg []interface{}) interface{} { - flat1660 := p.tryFlat(msg, func() { p.pretty_export_csv_output_location(msg) }) - if flat1660 != nil { - p.write(*flat1660) + flat1666 := p.tryFlat(msg, func() { p.pretty_export_csv_output_location(msg) }) + if flat1666 != nil { + p.write(*flat1666) return nil } else { _dollar_dollar := msg - var _t1840 *string + var _t1849 *string if _dollar_dollar[0].(string) != "" { - _t1840 = ptr(_dollar_dollar[0].(string)) + _t1849 = ptr(_dollar_dollar[0].(string)) } - deconstruct_result1658 := _t1840 - if deconstruct_result1658 != nil { - unwrapped1659 := *deconstruct_result1658 + deconstruct_result1664 := _t1849 + if deconstruct_result1664 != nil { + unwrapped1665 := *deconstruct_result1664 p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(unwrapped1659)) + p.write(p.formatStringValue(unwrapped1665)) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1841 *string + var _t1850 *string if _dollar_dollar[1].(string) != "" { - _t1841 = ptr(_dollar_dollar[1].(string)) + _t1850 = ptr(_dollar_dollar[1].(string)) } - deconstruct_result1656 := _t1841 - if deconstruct_result1656 != nil { - unwrapped1657 := *deconstruct_result1656 + deconstruct_result1662 := _t1850 + if deconstruct_result1662 != nil { + unwrapped1663 := *deconstruct_result1662 p.write("(") p.write("transaction_output_name") p.indentSexp() p.newline() - p.pretty_name(unwrapped1657) + p.pretty_name(unwrapped1663) p.dedent() p.write(")") } else { @@ -5094,47 +5127,47 @@ func (p *PrettyPrinter) pretty_export_csv_output_location(msg []interface{}) int } func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interface{} { - flat1667 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) - if flat1667 != nil { - p.write(*flat1667) + flat1673 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) + if flat1673 != nil { + p.write(*flat1673) return nil } else { _dollar_dollar := msg - var _t1842 []*pb.ExportCSVColumn + var _t1851 []*pb.ExportCSVColumn if hasProtoField(_dollar_dollar, "gnf_columns") { - _t1842 = _dollar_dollar.GetGnfColumns().GetColumns() + _t1851 = _dollar_dollar.GetGnfColumns().GetColumns() } - deconstruct_result1663 := _t1842 - if deconstruct_result1663 != nil { - unwrapped1664 := deconstruct_result1663 + deconstruct_result1669 := _t1851 + if deconstruct_result1669 != nil { + unwrapped1670 := deconstruct_result1669 p.write("(") p.write("gnf_columns") p.indentSexp() - if !(len(unwrapped1664) == 0) { + if !(len(unwrapped1670) == 0) { p.newline() - for i1666, elem1665 := range unwrapped1664 { - if (i1666 > 0) { + for i1672, elem1671 := range unwrapped1670 { + if (i1672 > 0) { p.newline() } - p.pretty_export_csv_column(elem1665) + p.pretty_export_csv_column(elem1671) } } p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1843 *pb.RelationId + var _t1852 *pb.RelationId if hasProtoField(_dollar_dollar, "table_def") { - _t1843 = _dollar_dollar.GetTableDef() + _t1852 = _dollar_dollar.GetTableDef() } - deconstruct_result1661 := _t1843 - if deconstruct_result1661 != nil { - unwrapped1662 := deconstruct_result1661 + deconstruct_result1667 := _t1852 + if deconstruct_result1667 != nil { + unwrapped1668 := deconstruct_result1667 p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped1662) + p.pretty_relation_id(unwrapped1668) p.dedent() p.write(")") } else { @@ -5146,23 +5179,23 @@ func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interf } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1672 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1672 != nil { - p.write(*flat1672) + flat1678 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1678 != nil { + p.write(*flat1678) return nil } else { _dollar_dollar := msg - fields1668 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} - unwrapped_fields1669 := fields1668 + fields1674 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} + unwrapped_fields1675 := fields1674 p.write("(") p.write("column") p.indentSexp() p.newline() - field1670 := unwrapped_fields1669[0].(string) - p.write(p.formatStringValue(field1670)) + field1676 := unwrapped_fields1675[0].(string) + p.write(p.formatStringValue(field1676)) p.newline() - field1671 := unwrapped_fields1669[1].(*pb.RelationId) - p.pretty_relation_id(field1671) + field1677 := unwrapped_fields1675[1].(*pb.RelationId) + p.pretty_relation_id(field1677) p.dedent() p.write(")") } @@ -5170,17 +5203,17 @@ func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interf } func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1674 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1674 != nil { - p.write(*flat1674) + flat1680 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1680 != nil { + p.write(*flat1680) return nil } else { - fields1673 := msg + fields1679 := msg p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1673)) + p.write(p.formatStringValue(fields1679)) p.dedent() p.write(")") } @@ -5188,22 +5221,22 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { } func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn) interface{} { - flat1678 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) - if flat1678 != nil { - p.write(*flat1678) + flat1684 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) + if flat1684 != nil { + p.write(*flat1684) return nil } else { - fields1675 := msg + fields1681 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1675) == 0) { + if !(len(fields1681) == 0) { p.newline() - for i1677, elem1676 := range fields1675 { - if (i1677 > 0) { + for i1683, elem1682 := range fields1681 { + if (i1683 > 0) { p.newline() } - p.pretty_export_csv_column(elem1676) + p.pretty_export_csv_column(elem1682) } } p.dedent() @@ -5213,35 +5246,35 @@ func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn } func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig) interface{} { - flat1687 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) - if flat1687 != nil { - p.write(*flat1687) + flat1693 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) + if flat1693 != nil { + p.write(*flat1693) return nil } else { _dollar_dollar := msg - _t1844 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1679 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1844} - unwrapped_fields1680 := fields1679 + _t1853 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1685 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1853} + unwrapped_fields1686 := fields1685 p.write("(") p.write("export_iceberg_config") p.indentSexp() p.newline() - field1681 := unwrapped_fields1680[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1681) + field1687 := unwrapped_fields1686[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1687) p.newline() - field1682 := unwrapped_fields1680[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1682) + field1688 := unwrapped_fields1686[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1688) p.newline() - field1683 := unwrapped_fields1680[2].(*pb.RelationId) - p.pretty_export_iceberg_table_def(field1683) + field1689 := unwrapped_fields1686[2].(*pb.RelationId) + p.pretty_export_iceberg_table_def(field1689) p.newline() - field1684 := unwrapped_fields1680[3].([][]interface{}) - p.pretty_iceberg_table_properties(field1684) - field1685 := unwrapped_fields1680[4].([][]interface{}) - if field1685 != nil { + field1690 := unwrapped_fields1686[3].([][]interface{}) + p.pretty_iceberg_table_properties(field1690) + field1691 := unwrapped_fields1686[4].([][]interface{}) + if field1691 != nil { p.newline() - opt_val1686 := field1685 - p.pretty_config_dict(opt_val1686) + opt_val1692 := field1691 + p.pretty_config_dict(opt_val1692) } p.dedent() p.write(")") @@ -5250,17 +5283,17 @@ func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig } func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) interface{} { - flat1689 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) - if flat1689 != nil { - p.write(*flat1689) + flat1695 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) + if flat1695 != nil { + p.write(*flat1695) return nil } else { - fields1688 := msg + fields1694 := msg p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(fields1688) + p.pretty_relation_id(fields1694) p.dedent() p.write(")") } @@ -5268,22 +5301,22 @@ func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) inte } func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) interface{} { - flat1693 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) - if flat1693 != nil { - p.write(*flat1693) + flat1699 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) + if flat1699 != nil { + p.write(*flat1699) return nil } else { - fields1690 := msg + fields1696 := msg p.write("(") p.write("table_properties") p.indentSexp() - if !(len(fields1690) == 0) { + if !(len(fields1696) == 0) { p.newline() - for i1692, elem1691 := range fields1690 { - if (i1692 > 0) { + for i1698, elem1697 := range fields1696 { + if (i1698 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1691) + p.pretty_iceberg_property_entry(elem1697) } } p.dedent() @@ -5301,8 +5334,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1898 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1898) + _t1907 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1907) p.write(" ") p.write(p.formatStringValue(msg.GetOrigNames()[_idx])) p.write(")") @@ -5704,8 +5737,6 @@ func (p *PrettyPrinter) pprintDispatch(msg interface{}) { p.pretty_gnf_column(m) case *pb.TargetRelations: p.pretty_target_relations(m) - case []*pb.NamedColumn: - p.pretty_relation_keys(m) case *pb.NamedColumn: p.pretty_named_column(m) case []*pb.TargetRelation: diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl index 674f02e0..bae7fbb4 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/logic_pb.jl @@ -2163,17 +2163,19 @@ end struct TargetRelations keys::Vector{NamedColumn} body::Union{Nothing,OneOf{<:Union{PlainTargets,CDCTargets}}} + synthetic_key::Bool end -TargetRelations(;keys = Vector{NamedColumn}(), body = nothing) = TargetRelations(keys, body) +TargetRelations(;keys = Vector{NamedColumn}(), body = nothing, synthetic_key = false) = TargetRelations(keys, body, synthetic_key) PB.oneof_field_types(::Type{TargetRelations}) = (; body = (;plain=PlainTargets, cdc=CDCTargets), ) -PB.default_values(::Type{TargetRelations}) = (;keys = Vector{NamedColumn}(), plain = nothing, cdc = nothing) -PB.field_numbers(::Type{TargetRelations}) = (;keys = 1, plain = 2, cdc = 3) +PB.default_values(::Type{TargetRelations}) = (;keys = Vector{NamedColumn}(), plain = nothing, cdc = nothing, synthetic_key = false) +PB.field_numbers(::Type{TargetRelations}) = (;keys = 1, plain = 2, cdc = 3, synthetic_key = 4) function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:TargetRelations}, _endpos::Int=0, _group::Bool=false) keys = PB.BufferedVector{NamedColumn}() body = nothing + synthetic_key = false while !PB.message_done(d, _endpos, _group) field_number, wire_type = PB.decode_tag(d) if field_number == 1 @@ -2182,11 +2184,13 @@ function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:TargetRelations}, _endpo body = OneOf(:plain, PB.decode(d, Ref{PlainTargets})) elseif field_number == 3 body = OneOf(:cdc, PB.decode(d, Ref{CDCTargets})) + elseif field_number == 4 + synthetic_key = PB.decode(d, Bool) else Base.skip(d, wire_type) end end - return TargetRelations(keys[], body) + return TargetRelations(keys[], body, synthetic_key) end function PB.encode(e::PB.AbstractProtoEncoder, x::TargetRelations) @@ -2198,6 +2202,7 @@ function PB.encode(e::PB.AbstractProtoEncoder, x::TargetRelations) elseif x.body.name === :cdc PB.encode(e, 3, x.body[]::CDCTargets) end + x.synthetic_key != false && PB.encode(e, 4, x.synthetic_key) return position(e.io) - initpos end function PB._encoded_size(x::TargetRelations) @@ -2209,6 +2214,7 @@ function PB._encoded_size(x::TargetRelations) elseif x.body.name === :cdc encoded_size += PB._encoded_size(x.body[]::CDCTargets, 3) end + x.synthetic_key != false && (encoded_size += PB._encoded_size(x.synthetic_key, 4)) return encoded_size end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index e6f0cfa0..a7450ae6 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -372,12 +372,12 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V if isnothing(value) return Int32(default) else - _t2199 = nothing + _t2211 = nothing end if _has_proto_field(value, Symbol("int32_value")) return _get_oneof_field(value, :int32_value) else - _t2200 = nothing + _t2212 = nothing end throw(ParseError("expected an int32 value (e.g. `1i32`) for this config field")) end @@ -386,7 +386,7 @@ function _extract_value_int64(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2201 = nothing + _t2213 = nothing end return default end @@ -395,7 +395,7 @@ function _extract_value_string(parser::ParserState, value::Union{Nothing, Proto. if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return _get_oneof_field(value, :string_value) else - _t2202 = nothing + _t2214 = nothing end return default end @@ -404,7 +404,7 @@ function _extract_value_boolean(parser::ParserState, value::Union{Nothing, Proto if (!isnothing(value) && _has_proto_field(value, Symbol("boolean_value"))) return _get_oneof_field(value, :boolean_value) else - _t2203 = nothing + _t2215 = nothing end return default end @@ -413,7 +413,7 @@ function _extract_value_string_list(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return String[_get_oneof_field(value, :string_value)] else - _t2204 = nothing + _t2216 = nothing end return default end @@ -422,7 +422,7 @@ function _try_extract_value_int64(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2205 = nothing + _t2217 = nothing end return nothing end @@ -431,7 +431,7 @@ function _try_extract_value_float64(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("float_value"))) return _get_oneof_field(value, :float_value) else - _t2206 = nothing + _t2218 = nothing end return nothing end @@ -440,7 +440,7 @@ function _try_extract_value_bytes(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return Vector{UInt8}(_get_oneof_field(value, :string_value)) else - _t2207 = nothing + _t2219 = nothing end return nothing end @@ -449,118 +449,127 @@ function _try_extract_value_uint128(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("uint128_value"))) return _get_oneof_field(value, :uint128_value) else - _t2208 = nothing + _t2220 = nothing end return nothing end function construct_non_cdc_relations(parser::ParserState, targets::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2209 = Proto.PlainTargets(targets=targets) - _t2210 = Proto.TargetRelations(body=OneOf(:plain, _t2209), keys=Proto.NamedColumn[]) - return _t2210 + _t2221 = Proto.PlainTargets(targets=targets) + _t2222 = Proto.TargetRelations(body=OneOf(:plain, _t2221), keys=Proto.NamedColumn[]) + return _t2222 end function construct_cdc_relations(parser::ParserState, inserts::Vector{Proto.TargetRelation}, deletes::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2211 = Proto.CDCTargets(inserts=inserts, deletes=deletes) - _t2212 = Proto.TargetRelations(body=OneOf(:cdc, _t2211), keys=Proto.NamedColumn[]) - return _t2212 + _t2223 = Proto.CDCTargets(inserts=inserts, deletes=deletes) + _t2224 = Proto.TargetRelations(body=OneOf(:cdc, _t2223), keys=Proto.NamedColumn[]) + return _t2224 +end + +function construct_synthetic_keys(parser::ParserState, marker::String)::Tuple{Vector{Proto.NamedColumn}, Bool} + if marker != "synthetic_key" + throw(ParseError("expected the `:synthetic_key` marker in the relation keys clause")) + else + _t2225 = nothing + end + return (Proto.NamedColumn[], true,) end -function construct_relations(parser::ParserState, keys::Vector{Proto.NamedColumn}, body::Proto.TargetRelations)::Proto.TargetRelations +function construct_relations(parser::ParserState, keys::Tuple{Vector{Proto.NamedColumn}, Bool}, body::Proto.TargetRelations)::Proto.TargetRelations if _has_proto_field(body, Symbol("plain")) - _t2214 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys) - return _t2214 + _t2227 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys[1], synthetic_key=keys[2]) + return _t2227 else - _t2213 = nothing + _t2226 = nothing end - _t2215 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys) - return _t2215 + _t2228 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys[1], synthetic_key=keys[2]) + return _t2228 end function construct_csv_data(parser::ParserState, locator::Proto.CSVLocator, config::Proto.CSVConfig, columns_opt::Union{Nothing, Vector{Proto.GNFColumn}}, relations_opt::Union{Nothing, Proto.TargetRelations}, asof::String)::Proto.CSVData - _t2216 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) - return _t2216 + _t2229 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) + return _t2229 end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}}, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.CSVConfig config = Dict(config_dict) - _t2217 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t2217 - _t2218 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t2218 - _t2219 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t2219 - _t2220 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t2220 - _t2221 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t2221 - _t2222 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t2222 - _t2223 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t2223 - _t2224 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t2224 - _t2225 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t2225 - _t2226 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t2226 - _t2227 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") - compression = _t2227 - _t2228 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) - partition_size_mb = _t2228 - _t2229 = construct_csv_storage_integration(parser, storage_integration_opt) - storage_integration = _t2229 - _t2230 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2230 + _t2230 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t2230 + _t2231 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t2231 + _t2232 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t2232 + _t2233 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t2233 + _t2234 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t2234 + _t2235 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t2235 + _t2236 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t2236 + _t2237 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t2237 + _t2238 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t2238 + _t2239 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t2239 + _t2240 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") + compression = _t2240 + _t2241 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) + partition_size_mb = _t2241 + _t2242 = construct_csv_storage_integration(parser, storage_integration_opt) + storage_integration = _t2242 + _t2243 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) + return _t2243 end function construct_csv_storage_integration(parser::ParserState, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Union{Nothing, Proto.StorageIntegration} if isnothing(storage_integration_opt) return nothing else - _t2231 = nothing + _t2244 = nothing end config = Dict(storage_integration_opt) - _t2232 = _extract_value_string(parser, get(config, "provider", nothing), "") - _t2233 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") - _t2234 = _extract_value_string(parser, get(config, "s3_region", nothing), "") - _t2235 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") - _t2236 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") - _t2237 = Proto.StorageIntegration(provider=_t2232, azure_sas_token=_t2233, s3_region=_t2234, s3_access_key_id=_t2235, s3_secret_access_key=_t2236) - return _t2237 + _t2245 = _extract_value_string(parser, get(config, "provider", nothing), "") + _t2246 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") + _t2247 = _extract_value_string(parser, get(config, "s3_region", nothing), "") + _t2248 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") + _t2249 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") + _t2250 = Proto.StorageIntegration(provider=_t2245, azure_sas_token=_t2246, s3_region=_t2247, s3_access_key_id=_t2248, s3_secret_access_key=_t2249) + return _t2250 end function construct_betree_info(parser::ParserState, key_types::Vector{Proto.var"#Type"}, value_types::Vector{Proto.var"#Type"}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.BeTreeInfo config = Dict(config_dict) - _t2238 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t2238 - _t2239 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t2239 - _t2240 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t2240 - _t2241 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t2241 - _t2242 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2242 - _t2243 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t2243 - _t2244 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t2244 - _t2245 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t2245 - _t2246 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t2246 - _t2247 = Proto.BeTreeLocator(location=(!isnothing(root_pageid) ? OneOf(:root_pageid, root_pageid) : (!isnothing(inline_data) ? OneOf(:inline_data, inline_data) : nothing)), element_count=element_count, tree_height=tree_height) - relation_locator = _t2247 - _t2248 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2248 + _t2251 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t2251 + _t2252 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t2252 + _t2253 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t2253 + _t2254 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t2254 + _t2255 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2255 + _t2256 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t2256 + _t2257 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t2257 + _t2258 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t2258 + _t2259 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t2259 + _t2260 = Proto.BeTreeLocator(location=(!isnothing(root_pageid) ? OneOf(:root_pageid, root_pageid) : (!isnothing(inline_data) ? OneOf(:inline_data, inline_data) : nothing)), element_count=element_count, tree_height=tree_height) + relation_locator = _t2260 + _t2261 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2261 end function default_configure(parser::ParserState)::Proto.Configure - _t2249 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2249 - _t2250 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2250 + _t2262 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2262 + _t2263 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2263 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -582,3347 +591,3373 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t2251 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t2251 - _t2252 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t2252 - _t2253 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2253 + _t2264 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t2264 + _t2265 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t2265 + _t2266 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2266 end function construct_export_csv_config(parser::ParserState, path::String, columns::Vector{Proto.ExportCSVColumn}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.ExportCSVConfig config = Dict(config_dict) - _t2254 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t2254 - _t2255 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t2255 - _t2256 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t2256 - _t2257 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t2257 - _t2258 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t2258 - _t2259 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t2259 - _t2260 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t2260 - _t2261 = Proto.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) - return _t2261 + _t2267 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t2267 + _t2268 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t2268 + _t2269 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t2269 + _t2270 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t2270 + _t2271 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t2271 + _t2272 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t2272 + _t2273 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t2273 + _t2274 = Proto.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) + return _t2274 end function construct_export_csv_config_with_location(parser::ParserState, location::Tuple{String, String}, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig - _t2262 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) - return _t2262 + _t2275 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) + return _t2275 end function construct_iceberg_catalog_config(parser::ParserState, catalog_uri::String, scope_opt::Union{Nothing, String}, property_pairs::Vector{Tuple{String, String}}, auth_property_pairs::Vector{Tuple{String, String}})::Proto.IcebergCatalogConfig props = Dict(property_pairs) auth_props = Dict(auth_property_pairs) - _t2263 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) - return _t2263 + _t2276 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) + return _t2276 end function construct_iceberg_data(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, columns::Vector{Proto.GNFColumn}, from_snapshot_opt::Union{Nothing, String}, to_snapshot_opt::Union{Nothing, String}, returns_delta::Bool)::Proto.IcebergData - _t2264 = Proto.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(!isnothing(from_snapshot_opt) ? from_snapshot_opt : ""), to_snapshot=(!isnothing(to_snapshot_opt) ? to_snapshot_opt : ""), returns_delta=returns_delta) - return _t2264 + _t2277 = Proto.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(!isnothing(from_snapshot_opt) ? from_snapshot_opt : ""), to_snapshot=(!isnothing(to_snapshot_opt) ? to_snapshot_opt : ""), returns_delta=returns_delta) + return _t2277 end function construct_export_iceberg_config_full(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, table_def::Proto.RelationId, table_property_pairs::Vector{Tuple{String, String}}, config_dict::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.ExportIcebergConfig cfg = Dict((!isnothing(config_dict) ? config_dict : Tuple{String, Proto.Value}[])) - _t2265 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") - prefix = _t2265 - _t2266 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) - target_file_size_bytes = _t2266 - _t2267 = _extract_value_string(parser, get(cfg, "compression", nothing), "") - compression = _t2267 + _t2278 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") + prefix = _t2278 + _t2279 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) + target_file_size_bytes = _t2279 + _t2280 = _extract_value_string(parser, get(cfg, "compression", nothing), "") + compression = _t2280 table_props = Dict(table_property_pairs) - _t2268 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2268 + _t2281 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2281 end # --- Parse functions --- function parse_transaction(parser::ParserState)::Proto.Transaction - span_start713 = span_start(parser) + span_start715 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t1415 = parse_configure(parser) - _t1414 = _t1415 + _t1419 = parse_configure(parser) + _t1418 = _t1419 else - _t1414 = nothing + _t1418 = nothing end - configure707 = _t1414 + configure709 = _t1418 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t1417 = parse_sync(parser) - _t1416 = _t1417 + _t1421 = parse_sync(parser) + _t1420 = _t1421 else - _t1416 = nothing - end - sync708 = _t1416 - xs709 = Proto.Epoch[] - cond710 = match_lookahead_literal(parser, "(", 0) - while cond710 - _t1418 = parse_epoch(parser) - item711 = _t1418 - push!(xs709, item711) - cond710 = match_lookahead_literal(parser, "(", 0) - end - epochs712 = xs709 + _t1420 = nothing + end + sync710 = _t1420 + xs711 = Proto.Epoch[] + cond712 = match_lookahead_literal(parser, "(", 0) + while cond712 + _t1422 = parse_epoch(parser) + item713 = _t1422 + push!(xs711, item713) + cond712 = match_lookahead_literal(parser, "(", 0) + end + epochs714 = xs711 consume_literal!(parser, ")") - _t1419 = default_configure(parser) - _t1420 = Proto.Transaction(epochs=epochs712, configure=(!isnothing(configure707) ? configure707 : _t1419), sync=sync708) - result714 = _t1420 - record_span!(parser, span_start713, "Transaction") - return result714 + _t1423 = default_configure(parser) + _t1424 = Proto.Transaction(epochs=epochs714, configure=(!isnothing(configure709) ? configure709 : _t1423), sync=sync710) + result716 = _t1424 + record_span!(parser, span_start715, "Transaction") + return result716 end function parse_configure(parser::ParserState)::Proto.Configure - span_start716 = span_start(parser) + span_start718 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t1421 = parse_config_dict(parser) - config_dict715 = _t1421 + _t1425 = parse_config_dict(parser) + config_dict717 = _t1425 consume_literal!(parser, ")") - _t1422 = construct_configure(parser, config_dict715) - result717 = _t1422 - record_span!(parser, span_start716, "Configure") - return result717 + _t1426 = construct_configure(parser, config_dict717) + result719 = _t1426 + record_span!(parser, span_start718, "Configure") + return result719 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs718 = Tuple{String, Proto.Value}[] - cond719 = match_lookahead_literal(parser, ":", 0) - while cond719 - _t1423 = parse_config_key_value(parser) - item720 = _t1423 - push!(xs718, item720) - cond719 = match_lookahead_literal(parser, ":", 0) - end - config_key_values721 = xs718 + xs720 = Tuple{String, Proto.Value}[] + cond721 = match_lookahead_literal(parser, ":", 0) + while cond721 + _t1427 = parse_config_key_value(parser) + item722 = _t1427 + push!(xs720, item722) + cond721 = match_lookahead_literal(parser, ":", 0) + end + config_key_values723 = xs720 consume_literal!(parser, "}") - return config_key_values721 + return config_key_values723 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol722 = consume_terminal!(parser, "SYMBOL") - _t1424 = parse_raw_value(parser) - raw_value723 = _t1424 - return (symbol722, raw_value723,) + symbol724 = consume_terminal!(parser, "SYMBOL") + _t1428 = parse_raw_value(parser) + raw_value725 = _t1428 + return (symbol724, raw_value725,) end function parse_raw_value(parser::ParserState)::Proto.Value - span_start737 = span_start(parser) + span_start739 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1425 = 12 + _t1429 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1426 = 11 + _t1430 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1427 = 12 + _t1431 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1429 = 1 + _t1433 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1430 = 0 + _t1434 = 0 else - _t1430 = -1 + _t1434 = -1 end - _t1429 = _t1430 + _t1433 = _t1434 end - _t1428 = _t1429 + _t1432 = _t1433 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1431 = 7 + _t1435 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1432 = 8 + _t1436 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1433 = 2 + _t1437 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1434 = 3 + _t1438 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1435 = 9 + _t1439 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1436 = 4 + _t1440 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1437 = 5 + _t1441 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1438 = 6 + _t1442 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1439 = 10 + _t1443 = 10 else - _t1439 = -1 + _t1443 = -1 end - _t1438 = _t1439 + _t1442 = _t1443 end - _t1437 = _t1438 + _t1441 = _t1442 end - _t1436 = _t1437 + _t1440 = _t1441 end - _t1435 = _t1436 + _t1439 = _t1440 end - _t1434 = _t1435 + _t1438 = _t1439 end - _t1433 = _t1434 + _t1437 = _t1438 end - _t1432 = _t1433 + _t1436 = _t1437 end - _t1431 = _t1432 + _t1435 = _t1436 end - _t1428 = _t1431 + _t1432 = _t1435 end - _t1427 = _t1428 + _t1431 = _t1432 end - _t1426 = _t1427 + _t1430 = _t1431 end - _t1425 = _t1426 - end - prediction724 = _t1425 - if prediction724 == 12 - _t1441 = parse_boolean_value(parser) - boolean_value736 = _t1441 - _t1442 = Proto.Value(value=OneOf(:boolean_value, boolean_value736)) - _t1440 = _t1442 + _t1429 = _t1430 + end + prediction726 = _t1429 + if prediction726 == 12 + _t1445 = parse_boolean_value(parser) + boolean_value738 = _t1445 + _t1446 = Proto.Value(value=OneOf(:boolean_value, boolean_value738)) + _t1444 = _t1446 else - if prediction724 == 11 + if prediction726 == 11 consume_literal!(parser, "missing") - _t1444 = Proto.MissingValue() - _t1445 = Proto.Value(value=OneOf(:missing_value, _t1444)) - _t1443 = _t1445 + _t1448 = Proto.MissingValue() + _t1449 = Proto.Value(value=OneOf(:missing_value, _t1448)) + _t1447 = _t1449 else - if prediction724 == 10 - decimal735 = consume_terminal!(parser, "DECIMAL") - _t1447 = Proto.Value(value=OneOf(:decimal_value, decimal735)) - _t1446 = _t1447 + if prediction726 == 10 + decimal737 = consume_terminal!(parser, "DECIMAL") + _t1451 = Proto.Value(value=OneOf(:decimal_value, decimal737)) + _t1450 = _t1451 else - if prediction724 == 9 - int128734 = consume_terminal!(parser, "INT128") - _t1449 = Proto.Value(value=OneOf(:int128_value, int128734)) - _t1448 = _t1449 + if prediction726 == 9 + int128736 = consume_terminal!(parser, "INT128") + _t1453 = Proto.Value(value=OneOf(:int128_value, int128736)) + _t1452 = _t1453 else - if prediction724 == 8 - uint128733 = consume_terminal!(parser, "UINT128") - _t1451 = Proto.Value(value=OneOf(:uint128_value, uint128733)) - _t1450 = _t1451 + if prediction726 == 8 + uint128735 = consume_terminal!(parser, "UINT128") + _t1455 = Proto.Value(value=OneOf(:uint128_value, uint128735)) + _t1454 = _t1455 else - if prediction724 == 7 - uint32732 = consume_terminal!(parser, "UINT32") - _t1453 = Proto.Value(value=OneOf(:uint32_value, uint32732)) - _t1452 = _t1453 + if prediction726 == 7 + uint32734 = consume_terminal!(parser, "UINT32") + _t1457 = Proto.Value(value=OneOf(:uint32_value, uint32734)) + _t1456 = _t1457 else - if prediction724 == 6 - float731 = consume_terminal!(parser, "FLOAT") - _t1455 = Proto.Value(value=OneOf(:float_value, float731)) - _t1454 = _t1455 + if prediction726 == 6 + float733 = consume_terminal!(parser, "FLOAT") + _t1459 = Proto.Value(value=OneOf(:float_value, float733)) + _t1458 = _t1459 else - if prediction724 == 5 - float32730 = consume_terminal!(parser, "FLOAT32") - _t1457 = Proto.Value(value=OneOf(:float32_value, float32730)) - _t1456 = _t1457 + if prediction726 == 5 + float32732 = consume_terminal!(parser, "FLOAT32") + _t1461 = Proto.Value(value=OneOf(:float32_value, float32732)) + _t1460 = _t1461 else - if prediction724 == 4 - int729 = consume_terminal!(parser, "INT") - _t1459 = Proto.Value(value=OneOf(:int_value, int729)) - _t1458 = _t1459 + if prediction726 == 4 + int731 = consume_terminal!(parser, "INT") + _t1463 = Proto.Value(value=OneOf(:int_value, int731)) + _t1462 = _t1463 else - if prediction724 == 3 - int32728 = consume_terminal!(parser, "INT32") - _t1461 = Proto.Value(value=OneOf(:int32_value, int32728)) - _t1460 = _t1461 + if prediction726 == 3 + int32730 = consume_terminal!(parser, "INT32") + _t1465 = Proto.Value(value=OneOf(:int32_value, int32730)) + _t1464 = _t1465 else - if prediction724 == 2 - string727 = consume_terminal!(parser, "STRING") - _t1463 = Proto.Value(value=OneOf(:string_value, string727)) - _t1462 = _t1463 + if prediction726 == 2 + string729 = consume_terminal!(parser, "STRING") + _t1467 = Proto.Value(value=OneOf(:string_value, string729)) + _t1466 = _t1467 else - if prediction724 == 1 - _t1465 = parse_raw_datetime(parser) - raw_datetime726 = _t1465 - _t1466 = Proto.Value(value=OneOf(:datetime_value, raw_datetime726)) - _t1464 = _t1466 + if prediction726 == 1 + _t1469 = parse_raw_datetime(parser) + raw_datetime728 = _t1469 + _t1470 = Proto.Value(value=OneOf(:datetime_value, raw_datetime728)) + _t1468 = _t1470 else - if prediction724 == 0 - _t1468 = parse_raw_date(parser) - raw_date725 = _t1468 - _t1469 = Proto.Value(value=OneOf(:date_value, raw_date725)) - _t1467 = _t1469 + if prediction726 == 0 + _t1472 = parse_raw_date(parser) + raw_date727 = _t1472 + _t1473 = Proto.Value(value=OneOf(:date_value, raw_date727)) + _t1471 = _t1473 else throw(ParseError("Unexpected token in raw_value" * ": " * string(lookahead(parser, 0)))) end - _t1464 = _t1467 + _t1468 = _t1471 end - _t1462 = _t1464 + _t1466 = _t1468 end - _t1460 = _t1462 + _t1464 = _t1466 end - _t1458 = _t1460 + _t1462 = _t1464 end - _t1456 = _t1458 + _t1460 = _t1462 end - _t1454 = _t1456 + _t1458 = _t1460 end - _t1452 = _t1454 + _t1456 = _t1458 end - _t1450 = _t1452 + _t1454 = _t1456 end - _t1448 = _t1450 + _t1452 = _t1454 end - _t1446 = _t1448 + _t1450 = _t1452 end - _t1443 = _t1446 + _t1447 = _t1450 end - _t1440 = _t1443 + _t1444 = _t1447 end - result738 = _t1440 - record_span!(parser, span_start737, "Value") - return result738 + result740 = _t1444 + record_span!(parser, span_start739, "Value") + return result740 end function parse_raw_date(parser::ParserState)::Proto.DateValue - span_start742 = span_start(parser) + span_start744 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - int739 = consume_terminal!(parser, "INT") - int_3740 = consume_terminal!(parser, "INT") - int_4741 = consume_terminal!(parser, "INT") + int741 = consume_terminal!(parser, "INT") + int_3742 = consume_terminal!(parser, "INT") + int_4743 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1470 = Proto.DateValue(year=Int32(int739), month=Int32(int_3740), day=Int32(int_4741)) - result743 = _t1470 - record_span!(parser, span_start742, "DateValue") - return result743 + _t1474 = Proto.DateValue(year=Int32(int741), month=Int32(int_3742), day=Int32(int_4743)) + result745 = _t1474 + record_span!(parser, span_start744, "DateValue") + return result745 end function parse_raw_datetime(parser::ParserState)::Proto.DateTimeValue - span_start751 = span_start(parser) + span_start753 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int744 = consume_terminal!(parser, "INT") - int_3745 = consume_terminal!(parser, "INT") - int_4746 = consume_terminal!(parser, "INT") - int_5747 = consume_terminal!(parser, "INT") - int_6748 = consume_terminal!(parser, "INT") - int_7749 = consume_terminal!(parser, "INT") + int746 = consume_terminal!(parser, "INT") + int_3747 = consume_terminal!(parser, "INT") + int_4748 = consume_terminal!(parser, "INT") + int_5749 = consume_terminal!(parser, "INT") + int_6750 = consume_terminal!(parser, "INT") + int_7751 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1471 = consume_terminal!(parser, "INT") + _t1475 = consume_terminal!(parser, "INT") else - _t1471 = nothing + _t1475 = nothing end - int_8750 = _t1471 + int_8752 = _t1475 consume_literal!(parser, ")") - _t1472 = Proto.DateTimeValue(year=Int32(int744), month=Int32(int_3745), day=Int32(int_4746), hour=Int32(int_5747), minute=Int32(int_6748), second=Int32(int_7749), microsecond=Int32((!isnothing(int_8750) ? int_8750 : 0))) - result752 = _t1472 - record_span!(parser, span_start751, "DateTimeValue") - return result752 + _t1476 = Proto.DateTimeValue(year=Int32(int746), month=Int32(int_3747), day=Int32(int_4748), hour=Int32(int_5749), minute=Int32(int_6750), second=Int32(int_7751), microsecond=Int32((!isnothing(int_8752) ? int_8752 : 0))) + result754 = _t1476 + record_span!(parser, span_start753, "DateTimeValue") + return result754 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t1473 = 0 + _t1477 = 0 else if match_lookahead_literal(parser, "false", 0) - _t1474 = 1 + _t1478 = 1 else - _t1474 = -1 + _t1478 = -1 end - _t1473 = _t1474 + _t1477 = _t1478 end - prediction753 = _t1473 - if prediction753 == 1 + prediction755 = _t1477 + if prediction755 == 1 consume_literal!(parser, "false") - _t1475 = false + _t1479 = false else - if prediction753 == 0 + if prediction755 == 0 consume_literal!(parser, "true") - _t1476 = true + _t1480 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t1475 = _t1476 + _t1479 = _t1480 end - return _t1475 + return _t1479 end function parse_sync(parser::ParserState)::Proto.Sync - span_start758 = span_start(parser) + span_start760 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs754 = Proto.FragmentId[] - cond755 = match_lookahead_literal(parser, ":", 0) - while cond755 - _t1477 = parse_fragment_id(parser) - item756 = _t1477 - push!(xs754, item756) - cond755 = match_lookahead_literal(parser, ":", 0) - end - fragment_ids757 = xs754 + xs756 = Proto.FragmentId[] + cond757 = match_lookahead_literal(parser, ":", 0) + while cond757 + _t1481 = parse_fragment_id(parser) + item758 = _t1481 + push!(xs756, item758) + cond757 = match_lookahead_literal(parser, ":", 0) + end + fragment_ids759 = xs756 consume_literal!(parser, ")") - _t1478 = Proto.Sync(fragments=fragment_ids757) - result759 = _t1478 - record_span!(parser, span_start758, "Sync") - return result759 + _t1482 = Proto.Sync(fragments=fragment_ids759) + result761 = _t1482 + record_span!(parser, span_start760, "Sync") + return result761 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId - span_start761 = span_start(parser) + span_start763 = span_start(parser) consume_literal!(parser, ":") - symbol760 = consume_terminal!(parser, "SYMBOL") - result762 = Proto.FragmentId(Vector{UInt8}(symbol760)) - record_span!(parser, span_start761, "FragmentId") - return result762 + symbol762 = consume_terminal!(parser, "SYMBOL") + result764 = Proto.FragmentId(Vector{UInt8}(symbol762)) + record_span!(parser, span_start763, "FragmentId") + return result764 end function parse_epoch(parser::ParserState)::Proto.Epoch - span_start765 = span_start(parser) + span_start767 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t1480 = parse_epoch_writes(parser) - _t1479 = _t1480 + _t1484 = parse_epoch_writes(parser) + _t1483 = _t1484 else - _t1479 = nothing + _t1483 = nothing end - epoch_writes763 = _t1479 + epoch_writes765 = _t1483 if match_lookahead_literal(parser, "(", 0) - _t1482 = parse_epoch_reads(parser) - _t1481 = _t1482 + _t1486 = parse_epoch_reads(parser) + _t1485 = _t1486 else - _t1481 = nothing + _t1485 = nothing end - epoch_reads764 = _t1481 + epoch_reads766 = _t1485 consume_literal!(parser, ")") - _t1483 = Proto.Epoch(writes=(!isnothing(epoch_writes763) ? epoch_writes763 : Proto.Write[]), reads=(!isnothing(epoch_reads764) ? epoch_reads764 : Proto.Read[])) - result766 = _t1483 - record_span!(parser, span_start765, "Epoch") - return result766 + _t1487 = Proto.Epoch(writes=(!isnothing(epoch_writes765) ? epoch_writes765 : Proto.Write[]), reads=(!isnothing(epoch_reads766) ? epoch_reads766 : Proto.Read[])) + result768 = _t1487 + record_span!(parser, span_start767, "Epoch") + return result768 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs767 = Proto.Write[] - cond768 = match_lookahead_literal(parser, "(", 0) - while cond768 - _t1484 = parse_write(parser) - item769 = _t1484 - push!(xs767, item769) - cond768 = match_lookahead_literal(parser, "(", 0) - end - writes770 = xs767 + xs769 = Proto.Write[] + cond770 = match_lookahead_literal(parser, "(", 0) + while cond770 + _t1488 = parse_write(parser) + item771 = _t1488 + push!(xs769, item771) + cond770 = match_lookahead_literal(parser, "(", 0) + end + writes772 = xs769 consume_literal!(parser, ")") - return writes770 + return writes772 end function parse_write(parser::ParserState)::Proto.Write - span_start776 = span_start(parser) + span_start778 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t1486 = 1 + _t1490 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t1487 = 3 + _t1491 = 3 else if match_lookahead_literal(parser, "define", 1) - _t1488 = 0 + _t1492 = 0 else if match_lookahead_literal(parser, "context", 1) - _t1489 = 2 + _t1493 = 2 else - _t1489 = -1 + _t1493 = -1 end - _t1488 = _t1489 + _t1492 = _t1493 end - _t1487 = _t1488 + _t1491 = _t1492 end - _t1486 = _t1487 + _t1490 = _t1491 end - _t1485 = _t1486 + _t1489 = _t1490 else - _t1485 = -1 - end - prediction771 = _t1485 - if prediction771 == 3 - _t1491 = parse_snapshot(parser) - snapshot775 = _t1491 - _t1492 = Proto.Write(write_type=OneOf(:snapshot, snapshot775)) - _t1490 = _t1492 + _t1489 = -1 + end + prediction773 = _t1489 + if prediction773 == 3 + _t1495 = parse_snapshot(parser) + snapshot777 = _t1495 + _t1496 = Proto.Write(write_type=OneOf(:snapshot, snapshot777)) + _t1494 = _t1496 else - if prediction771 == 2 - _t1494 = parse_context(parser) - context774 = _t1494 - _t1495 = Proto.Write(write_type=OneOf(:context, context774)) - _t1493 = _t1495 + if prediction773 == 2 + _t1498 = parse_context(parser) + context776 = _t1498 + _t1499 = Proto.Write(write_type=OneOf(:context, context776)) + _t1497 = _t1499 else - if prediction771 == 1 - _t1497 = parse_undefine(parser) - undefine773 = _t1497 - _t1498 = Proto.Write(write_type=OneOf(:undefine, undefine773)) - _t1496 = _t1498 + if prediction773 == 1 + _t1501 = parse_undefine(parser) + undefine775 = _t1501 + _t1502 = Proto.Write(write_type=OneOf(:undefine, undefine775)) + _t1500 = _t1502 else - if prediction771 == 0 - _t1500 = parse_define(parser) - define772 = _t1500 - _t1501 = Proto.Write(write_type=OneOf(:define, define772)) - _t1499 = _t1501 + if prediction773 == 0 + _t1504 = parse_define(parser) + define774 = _t1504 + _t1505 = Proto.Write(write_type=OneOf(:define, define774)) + _t1503 = _t1505 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t1496 = _t1499 + _t1500 = _t1503 end - _t1493 = _t1496 + _t1497 = _t1500 end - _t1490 = _t1493 + _t1494 = _t1497 end - result777 = _t1490 - record_span!(parser, span_start776, "Write") - return result777 + result779 = _t1494 + record_span!(parser, span_start778, "Write") + return result779 end function parse_define(parser::ParserState)::Proto.Define - span_start779 = span_start(parser) + span_start781 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "define") - _t1502 = parse_fragment(parser) - fragment778 = _t1502 + _t1506 = parse_fragment(parser) + fragment780 = _t1506 consume_literal!(parser, ")") - _t1503 = Proto.Define(fragment=fragment778) - result780 = _t1503 - record_span!(parser, span_start779, "Define") - return result780 + _t1507 = Proto.Define(fragment=fragment780) + result782 = _t1507 + record_span!(parser, span_start781, "Define") + return result782 end function parse_fragment(parser::ParserState)::Proto.Fragment - span_start786 = span_start(parser) + span_start788 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t1504 = parse_new_fragment_id(parser) - new_fragment_id781 = _t1504 - xs782 = Proto.Declaration[] - cond783 = match_lookahead_literal(parser, "(", 0) - while cond783 - _t1505 = parse_declaration(parser) - item784 = _t1505 - push!(xs782, item784) - cond783 = match_lookahead_literal(parser, "(", 0) - end - declarations785 = xs782 + _t1508 = parse_new_fragment_id(parser) + new_fragment_id783 = _t1508 + xs784 = Proto.Declaration[] + cond785 = match_lookahead_literal(parser, "(", 0) + while cond785 + _t1509 = parse_declaration(parser) + item786 = _t1509 + push!(xs784, item786) + cond785 = match_lookahead_literal(parser, "(", 0) + end + declarations787 = xs784 consume_literal!(parser, ")") - result787 = construct_fragment(parser, new_fragment_id781, declarations785) - record_span!(parser, span_start786, "Fragment") - return result787 + result789 = construct_fragment(parser, new_fragment_id783, declarations787) + record_span!(parser, span_start788, "Fragment") + return result789 end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - span_start789 = span_start(parser) - _t1506 = parse_fragment_id(parser) - fragment_id788 = _t1506 - start_fragment!(parser, fragment_id788) - result790 = fragment_id788 - record_span!(parser, span_start789, "FragmentId") - return result790 + span_start791 = span_start(parser) + _t1510 = parse_fragment_id(parser) + fragment_id790 = _t1510 + start_fragment!(parser, fragment_id790) + result792 = fragment_id790 + record_span!(parser, span_start791, "FragmentId") + return result792 end function parse_declaration(parser::ParserState)::Proto.Declaration - span_start796 = span_start(parser) + span_start798 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1508 = 3 + _t1512 = 3 else if match_lookahead_literal(parser, "functional_dependency", 1) - _t1509 = 2 + _t1513 = 2 else if match_lookahead_literal(parser, "edb", 1) - _t1510 = 3 + _t1514 = 3 else if match_lookahead_literal(parser, "def", 1) - _t1511 = 0 + _t1515 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1512 = 3 + _t1516 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1513 = 3 + _t1517 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t1514 = 1 + _t1518 = 1 else - _t1514 = -1 + _t1518 = -1 end - _t1513 = _t1514 + _t1517 = _t1518 end - _t1512 = _t1513 + _t1516 = _t1517 end - _t1511 = _t1512 + _t1515 = _t1516 end - _t1510 = _t1511 + _t1514 = _t1515 end - _t1509 = _t1510 + _t1513 = _t1514 end - _t1508 = _t1509 + _t1512 = _t1513 end - _t1507 = _t1508 + _t1511 = _t1512 else - _t1507 = -1 - end - prediction791 = _t1507 - if prediction791 == 3 - _t1516 = parse_data(parser) - data795 = _t1516 - _t1517 = Proto.Declaration(declaration_type=OneOf(:data, data795)) - _t1515 = _t1517 + _t1511 = -1 + end + prediction793 = _t1511 + if prediction793 == 3 + _t1520 = parse_data(parser) + data797 = _t1520 + _t1521 = Proto.Declaration(declaration_type=OneOf(:data, data797)) + _t1519 = _t1521 else - if prediction791 == 2 - _t1519 = parse_constraint(parser) - constraint794 = _t1519 - _t1520 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint794)) - _t1518 = _t1520 + if prediction793 == 2 + _t1523 = parse_constraint(parser) + constraint796 = _t1523 + _t1524 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint796)) + _t1522 = _t1524 else - if prediction791 == 1 - _t1522 = parse_algorithm(parser) - algorithm793 = _t1522 - _t1523 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm793)) - _t1521 = _t1523 + if prediction793 == 1 + _t1526 = parse_algorithm(parser) + algorithm795 = _t1526 + _t1527 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm795)) + _t1525 = _t1527 else - if prediction791 == 0 - _t1525 = parse_def(parser) - def792 = _t1525 - _t1526 = Proto.Declaration(declaration_type=OneOf(:def, def792)) - _t1524 = _t1526 + if prediction793 == 0 + _t1529 = parse_def(parser) + def794 = _t1529 + _t1530 = Proto.Declaration(declaration_type=OneOf(:def, def794)) + _t1528 = _t1530 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t1521 = _t1524 + _t1525 = _t1528 end - _t1518 = _t1521 + _t1522 = _t1525 end - _t1515 = _t1518 + _t1519 = _t1522 end - result797 = _t1515 - record_span!(parser, span_start796, "Declaration") - return result797 + result799 = _t1519 + record_span!(parser, span_start798, "Declaration") + return result799 end function parse_def(parser::ParserState)::Proto.Def - span_start801 = span_start(parser) + span_start803 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "def") - _t1527 = parse_relation_id(parser) - relation_id798 = _t1527 - _t1528 = parse_abstraction(parser) - abstraction799 = _t1528 + _t1531 = parse_relation_id(parser) + relation_id800 = _t1531 + _t1532 = parse_abstraction(parser) + abstraction801 = _t1532 if match_lookahead_literal(parser, "(", 0) - _t1530 = parse_attrs(parser) - _t1529 = _t1530 + _t1534 = parse_attrs(parser) + _t1533 = _t1534 else - _t1529 = nothing + _t1533 = nothing end - attrs800 = _t1529 + attrs802 = _t1533 consume_literal!(parser, ")") - _t1531 = Proto.Def(name=relation_id798, body=abstraction799, attrs=(!isnothing(attrs800) ? attrs800 : Proto.Attribute[])) - result802 = _t1531 - record_span!(parser, span_start801, "Def") - return result802 + _t1535 = Proto.Def(name=relation_id800, body=abstraction801, attrs=(!isnothing(attrs802) ? attrs802 : Proto.Attribute[])) + result804 = _t1535 + record_span!(parser, span_start803, "Def") + return result804 end function parse_relation_id(parser::ParserState)::Proto.RelationId - span_start806 = span_start(parser) + span_start808 = span_start(parser) if match_lookahead_literal(parser, ":", 0) - _t1532 = 0 + _t1536 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1533 = 1 + _t1537 = 1 else - _t1533 = -1 + _t1537 = -1 end - _t1532 = _t1533 + _t1536 = _t1537 end - prediction803 = _t1532 - if prediction803 == 1 - uint128805 = consume_terminal!(parser, "UINT128") - _t1534 = Proto.RelationId(uint128805.low, uint128805.high) + prediction805 = _t1536 + if prediction805 == 1 + uint128807 = consume_terminal!(parser, "UINT128") + _t1538 = Proto.RelationId(uint128807.low, uint128807.high) else - if prediction803 == 0 + if prediction805 == 0 consume_literal!(parser, ":") - symbol804 = consume_terminal!(parser, "SYMBOL") - _t1535 = relation_id_from_string(parser, symbol804) + symbol806 = consume_terminal!(parser, "SYMBOL") + _t1539 = relation_id_from_string(parser, symbol806) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t1534 = _t1535 + _t1538 = _t1539 end - result807 = _t1534 - record_span!(parser, span_start806, "RelationId") - return result807 + result809 = _t1538 + record_span!(parser, span_start808, "RelationId") + return result809 end function parse_abstraction(parser::ParserState)::Proto.Abstraction - span_start810 = span_start(parser) + span_start812 = span_start(parser) consume_literal!(parser, "(") - _t1536 = parse_bindings(parser) - bindings808 = _t1536 - _t1537 = parse_formula(parser) - formula809 = _t1537 + _t1540 = parse_bindings(parser) + bindings810 = _t1540 + _t1541 = parse_formula(parser) + formula811 = _t1541 consume_literal!(parser, ")") - _t1538 = Proto.Abstraction(vars=vcat(bindings808[1], !isnothing(bindings808[2]) ? bindings808[2] : []), value=formula809) - result811 = _t1538 - record_span!(parser, span_start810, "Abstraction") - return result811 + _t1542 = Proto.Abstraction(vars=vcat(bindings810[1], !isnothing(bindings810[2]) ? bindings810[2] : []), value=formula811) + result813 = _t1542 + record_span!(parser, span_start812, "Abstraction") + return result813 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs812 = Proto.Binding[] - cond813 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond813 - _t1539 = parse_binding(parser) - item814 = _t1539 - push!(xs812, item814) - cond813 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - bindings815 = xs812 + xs814 = Proto.Binding[] + cond815 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond815 + _t1543 = parse_binding(parser) + item816 = _t1543 + push!(xs814, item816) + cond815 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + bindings817 = xs814 if match_lookahead_literal(parser, "|", 0) - _t1541 = parse_value_bindings(parser) - _t1540 = _t1541 + _t1545 = parse_value_bindings(parser) + _t1544 = _t1545 else - _t1540 = nothing + _t1544 = nothing end - value_bindings816 = _t1540 + value_bindings818 = _t1544 consume_literal!(parser, "]") - return (bindings815, (!isnothing(value_bindings816) ? value_bindings816 : Proto.Binding[]),) + return (bindings817, (!isnothing(value_bindings818) ? value_bindings818 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - span_start819 = span_start(parser) - symbol817 = consume_terminal!(parser, "SYMBOL") + span_start821 = span_start(parser) + symbol819 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t1542 = parse_type(parser) - type818 = _t1542 - _t1543 = Proto.Var(name=symbol817) - _t1544 = Proto.Binding(var=_t1543, var"#type"=type818) - result820 = _t1544 - record_span!(parser, span_start819, "Binding") - return result820 + _t1546 = parse_type(parser) + type820 = _t1546 + _t1547 = Proto.Var(name=symbol819) + _t1548 = Proto.Binding(var=_t1547, var"#type"=type820) + result822 = _t1548 + record_span!(parser, span_start821, "Binding") + return result822 end function parse_type(parser::ParserState)::Proto.var"#Type" - span_start836 = span_start(parser) + span_start838 = span_start(parser) if match_lookahead_literal(parser, "UNKNOWN", 0) - _t1545 = 0 + _t1549 = 0 else if match_lookahead_literal(parser, "UINT32", 0) - _t1546 = 13 + _t1550 = 13 else if match_lookahead_literal(parser, "UINT128", 0) - _t1547 = 4 + _t1551 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t1548 = 1 + _t1552 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t1549 = 8 + _t1553 = 8 else if match_lookahead_literal(parser, "INT32", 0) - _t1550 = 11 + _t1554 = 11 else if match_lookahead_literal(parser, "INT128", 0) - _t1551 = 5 + _t1555 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t1552 = 2 + _t1556 = 2 else if match_lookahead_literal(parser, "FLOAT32", 0) - _t1553 = 12 + _t1557 = 12 else if match_lookahead_literal(parser, "FLOAT", 0) - _t1554 = 3 + _t1558 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t1555 = 7 + _t1559 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t1556 = 6 + _t1560 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t1557 = 10 + _t1561 = 10 else if match_lookahead_literal(parser, "(", 0) - _t1558 = 9 + _t1562 = 9 else - _t1558 = -1 + _t1562 = -1 end - _t1557 = _t1558 + _t1561 = _t1562 end - _t1556 = _t1557 + _t1560 = _t1561 end - _t1555 = _t1556 + _t1559 = _t1560 end - _t1554 = _t1555 + _t1558 = _t1559 end - _t1553 = _t1554 + _t1557 = _t1558 end - _t1552 = _t1553 + _t1556 = _t1557 end - _t1551 = _t1552 + _t1555 = _t1556 end - _t1550 = _t1551 + _t1554 = _t1555 end - _t1549 = _t1550 + _t1553 = _t1554 end - _t1548 = _t1549 + _t1552 = _t1553 end - _t1547 = _t1548 + _t1551 = _t1552 end - _t1546 = _t1547 + _t1550 = _t1551 end - _t1545 = _t1546 - end - prediction821 = _t1545 - if prediction821 == 13 - _t1560 = parse_uint32_type(parser) - uint32_type835 = _t1560 - _t1561 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type835)) - _t1559 = _t1561 + _t1549 = _t1550 + end + prediction823 = _t1549 + if prediction823 == 13 + _t1564 = parse_uint32_type(parser) + uint32_type837 = _t1564 + _t1565 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type837)) + _t1563 = _t1565 else - if prediction821 == 12 - _t1563 = parse_float32_type(parser) - float32_type834 = _t1563 - _t1564 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type834)) - _t1562 = _t1564 + if prediction823 == 12 + _t1567 = parse_float32_type(parser) + float32_type836 = _t1567 + _t1568 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type836)) + _t1566 = _t1568 else - if prediction821 == 11 - _t1566 = parse_int32_type(parser) - int32_type833 = _t1566 - _t1567 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type833)) - _t1565 = _t1567 + if prediction823 == 11 + _t1570 = parse_int32_type(parser) + int32_type835 = _t1570 + _t1571 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type835)) + _t1569 = _t1571 else - if prediction821 == 10 - _t1569 = parse_boolean_type(parser) - boolean_type832 = _t1569 - _t1570 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type832)) - _t1568 = _t1570 + if prediction823 == 10 + _t1573 = parse_boolean_type(parser) + boolean_type834 = _t1573 + _t1574 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type834)) + _t1572 = _t1574 else - if prediction821 == 9 - _t1572 = parse_decimal_type(parser) - decimal_type831 = _t1572 - _t1573 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type831)) - _t1571 = _t1573 + if prediction823 == 9 + _t1576 = parse_decimal_type(parser) + decimal_type833 = _t1576 + _t1577 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type833)) + _t1575 = _t1577 else - if prediction821 == 8 - _t1575 = parse_missing_type(parser) - missing_type830 = _t1575 - _t1576 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type830)) - _t1574 = _t1576 + if prediction823 == 8 + _t1579 = parse_missing_type(parser) + missing_type832 = _t1579 + _t1580 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type832)) + _t1578 = _t1580 else - if prediction821 == 7 - _t1578 = parse_datetime_type(parser) - datetime_type829 = _t1578 - _t1579 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type829)) - _t1577 = _t1579 + if prediction823 == 7 + _t1582 = parse_datetime_type(parser) + datetime_type831 = _t1582 + _t1583 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type831)) + _t1581 = _t1583 else - if prediction821 == 6 - _t1581 = parse_date_type(parser) - date_type828 = _t1581 - _t1582 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type828)) - _t1580 = _t1582 + if prediction823 == 6 + _t1585 = parse_date_type(parser) + date_type830 = _t1585 + _t1586 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type830)) + _t1584 = _t1586 else - if prediction821 == 5 - _t1584 = parse_int128_type(parser) - int128_type827 = _t1584 - _t1585 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type827)) - _t1583 = _t1585 + if prediction823 == 5 + _t1588 = parse_int128_type(parser) + int128_type829 = _t1588 + _t1589 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type829)) + _t1587 = _t1589 else - if prediction821 == 4 - _t1587 = parse_uint128_type(parser) - uint128_type826 = _t1587 - _t1588 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type826)) - _t1586 = _t1588 + if prediction823 == 4 + _t1591 = parse_uint128_type(parser) + uint128_type828 = _t1591 + _t1592 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type828)) + _t1590 = _t1592 else - if prediction821 == 3 - _t1590 = parse_float_type(parser) - float_type825 = _t1590 - _t1591 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type825)) - _t1589 = _t1591 + if prediction823 == 3 + _t1594 = parse_float_type(parser) + float_type827 = _t1594 + _t1595 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type827)) + _t1593 = _t1595 else - if prediction821 == 2 - _t1593 = parse_int_type(parser) - int_type824 = _t1593 - _t1594 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type824)) - _t1592 = _t1594 + if prediction823 == 2 + _t1597 = parse_int_type(parser) + int_type826 = _t1597 + _t1598 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type826)) + _t1596 = _t1598 else - if prediction821 == 1 - _t1596 = parse_string_type(parser) - string_type823 = _t1596 - _t1597 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type823)) - _t1595 = _t1597 + if prediction823 == 1 + _t1600 = parse_string_type(parser) + string_type825 = _t1600 + _t1601 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type825)) + _t1599 = _t1601 else - if prediction821 == 0 - _t1599 = parse_unspecified_type(parser) - unspecified_type822 = _t1599 - _t1600 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type822)) - _t1598 = _t1600 + if prediction823 == 0 + _t1603 = parse_unspecified_type(parser) + unspecified_type824 = _t1603 + _t1604 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type824)) + _t1602 = _t1604 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) end - _t1595 = _t1598 + _t1599 = _t1602 end - _t1592 = _t1595 + _t1596 = _t1599 end - _t1589 = _t1592 + _t1593 = _t1596 end - _t1586 = _t1589 + _t1590 = _t1593 end - _t1583 = _t1586 + _t1587 = _t1590 end - _t1580 = _t1583 + _t1584 = _t1587 end - _t1577 = _t1580 + _t1581 = _t1584 end - _t1574 = _t1577 + _t1578 = _t1581 end - _t1571 = _t1574 + _t1575 = _t1578 end - _t1568 = _t1571 + _t1572 = _t1575 end - _t1565 = _t1568 + _t1569 = _t1572 end - _t1562 = _t1565 + _t1566 = _t1569 end - _t1559 = _t1562 + _t1563 = _t1566 end - result837 = _t1559 - record_span!(parser, span_start836, "Type") - return result837 + result839 = _t1563 + record_span!(parser, span_start838, "Type") + return result839 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType - span_start838 = span_start(parser) + span_start840 = span_start(parser) consume_literal!(parser, "UNKNOWN") - _t1601 = Proto.UnspecifiedType() - result839 = _t1601 - record_span!(parser, span_start838, "UnspecifiedType") - return result839 + _t1605 = Proto.UnspecifiedType() + result841 = _t1605 + record_span!(parser, span_start840, "UnspecifiedType") + return result841 end function parse_string_type(parser::ParserState)::Proto.StringType - span_start840 = span_start(parser) + span_start842 = span_start(parser) consume_literal!(parser, "STRING") - _t1602 = Proto.StringType() - result841 = _t1602 - record_span!(parser, span_start840, "StringType") - return result841 + _t1606 = Proto.StringType() + result843 = _t1606 + record_span!(parser, span_start842, "StringType") + return result843 end function parse_int_type(parser::ParserState)::Proto.IntType - span_start842 = span_start(parser) + span_start844 = span_start(parser) consume_literal!(parser, "INT") - _t1603 = Proto.IntType() - result843 = _t1603 - record_span!(parser, span_start842, "IntType") - return result843 + _t1607 = Proto.IntType() + result845 = _t1607 + record_span!(parser, span_start844, "IntType") + return result845 end function parse_float_type(parser::ParserState)::Proto.FloatType - span_start844 = span_start(parser) + span_start846 = span_start(parser) consume_literal!(parser, "FLOAT") - _t1604 = Proto.FloatType() - result845 = _t1604 - record_span!(parser, span_start844, "FloatType") - return result845 + _t1608 = Proto.FloatType() + result847 = _t1608 + record_span!(parser, span_start846, "FloatType") + return result847 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type - span_start846 = span_start(parser) + span_start848 = span_start(parser) consume_literal!(parser, "UINT128") - _t1605 = Proto.UInt128Type() - result847 = _t1605 - record_span!(parser, span_start846, "UInt128Type") - return result847 + _t1609 = Proto.UInt128Type() + result849 = _t1609 + record_span!(parser, span_start848, "UInt128Type") + return result849 end function parse_int128_type(parser::ParserState)::Proto.Int128Type - span_start848 = span_start(parser) + span_start850 = span_start(parser) consume_literal!(parser, "INT128") - _t1606 = Proto.Int128Type() - result849 = _t1606 - record_span!(parser, span_start848, "Int128Type") - return result849 + _t1610 = Proto.Int128Type() + result851 = _t1610 + record_span!(parser, span_start850, "Int128Type") + return result851 end function parse_date_type(parser::ParserState)::Proto.DateType - span_start850 = span_start(parser) + span_start852 = span_start(parser) consume_literal!(parser, "DATE") - _t1607 = Proto.DateType() - result851 = _t1607 - record_span!(parser, span_start850, "DateType") - return result851 + _t1611 = Proto.DateType() + result853 = _t1611 + record_span!(parser, span_start852, "DateType") + return result853 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType - span_start852 = span_start(parser) + span_start854 = span_start(parser) consume_literal!(parser, "DATETIME") - _t1608 = Proto.DateTimeType() - result853 = _t1608 - record_span!(parser, span_start852, "DateTimeType") - return result853 + _t1612 = Proto.DateTimeType() + result855 = _t1612 + record_span!(parser, span_start854, "DateTimeType") + return result855 end function parse_missing_type(parser::ParserState)::Proto.MissingType - span_start854 = span_start(parser) + span_start856 = span_start(parser) consume_literal!(parser, "MISSING") - _t1609 = Proto.MissingType() - result855 = _t1609 - record_span!(parser, span_start854, "MissingType") - return result855 + _t1613 = Proto.MissingType() + result857 = _t1613 + record_span!(parser, span_start856, "MissingType") + return result857 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType - span_start858 = span_start(parser) + span_start860 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int856 = consume_terminal!(parser, "INT") - int_3857 = consume_terminal!(parser, "INT") + int858 = consume_terminal!(parser, "INT") + int_3859 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1610 = Proto.DecimalType(precision=Int32(int856), scale=Int32(int_3857)) - result859 = _t1610 - record_span!(parser, span_start858, "DecimalType") - return result859 + _t1614 = Proto.DecimalType(precision=Int32(int858), scale=Int32(int_3859)) + result861 = _t1614 + record_span!(parser, span_start860, "DecimalType") + return result861 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType - span_start860 = span_start(parser) + span_start862 = span_start(parser) consume_literal!(parser, "BOOLEAN") - _t1611 = Proto.BooleanType() - result861 = _t1611 - record_span!(parser, span_start860, "BooleanType") - return result861 + _t1615 = Proto.BooleanType() + result863 = _t1615 + record_span!(parser, span_start862, "BooleanType") + return result863 end function parse_int32_type(parser::ParserState)::Proto.Int32Type - span_start862 = span_start(parser) + span_start864 = span_start(parser) consume_literal!(parser, "INT32") - _t1612 = Proto.Int32Type() - result863 = _t1612 - record_span!(parser, span_start862, "Int32Type") - return result863 + _t1616 = Proto.Int32Type() + result865 = _t1616 + record_span!(parser, span_start864, "Int32Type") + return result865 end function parse_float32_type(parser::ParserState)::Proto.Float32Type - span_start864 = span_start(parser) + span_start866 = span_start(parser) consume_literal!(parser, "FLOAT32") - _t1613 = Proto.Float32Type() - result865 = _t1613 - record_span!(parser, span_start864, "Float32Type") - return result865 + _t1617 = Proto.Float32Type() + result867 = _t1617 + record_span!(parser, span_start866, "Float32Type") + return result867 end function parse_uint32_type(parser::ParserState)::Proto.UInt32Type - span_start866 = span_start(parser) + span_start868 = span_start(parser) consume_literal!(parser, "UINT32") - _t1614 = Proto.UInt32Type() - result867 = _t1614 - record_span!(parser, span_start866, "UInt32Type") - return result867 + _t1618 = Proto.UInt32Type() + result869 = _t1618 + record_span!(parser, span_start868, "UInt32Type") + return result869 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs868 = Proto.Binding[] - cond869 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond869 - _t1615 = parse_binding(parser) - item870 = _t1615 - push!(xs868, item870) - cond869 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs870 = Proto.Binding[] + cond871 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond871 + _t1619 = parse_binding(parser) + item872 = _t1619 + push!(xs870, item872) + cond871 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings871 = xs868 - return bindings871 + bindings873 = xs870 + return bindings873 end function parse_formula(parser::ParserState)::Proto.Formula - span_start886 = span_start(parser) + span_start888 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t1617 = 0 + _t1621 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t1618 = 11 + _t1622 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t1619 = 3 + _t1623 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t1620 = 10 + _t1624 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t1621 = 9 + _t1625 = 9 else if match_lookahead_literal(parser, "or", 1) - _t1622 = 5 + _t1626 = 5 else if match_lookahead_literal(parser, "not", 1) - _t1623 = 6 + _t1627 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t1624 = 7 + _t1628 = 7 else if match_lookahead_literal(parser, "false", 1) - _t1625 = 1 + _t1629 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t1626 = 2 + _t1630 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t1627 = 12 + _t1631 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t1628 = 8 + _t1632 = 8 else if match_lookahead_literal(parser, "and", 1) - _t1629 = 4 + _t1633 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t1630 = 10 + _t1634 = 10 else if match_lookahead_literal(parser, ">", 1) - _t1631 = 10 + _t1635 = 10 else if match_lookahead_literal(parser, "=", 1) - _t1632 = 10 + _t1636 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t1633 = 10 + _t1637 = 10 else if match_lookahead_literal(parser, "<", 1) - _t1634 = 10 + _t1638 = 10 else if match_lookahead_literal(parser, "/", 1) - _t1635 = 10 + _t1639 = 10 else if match_lookahead_literal(parser, "-", 1) - _t1636 = 10 + _t1640 = 10 else if match_lookahead_literal(parser, "+", 1) - _t1637 = 10 + _t1641 = 10 else if match_lookahead_literal(parser, "*", 1) - _t1638 = 10 + _t1642 = 10 else - _t1638 = -1 + _t1642 = -1 end - _t1637 = _t1638 + _t1641 = _t1642 end - _t1636 = _t1637 + _t1640 = _t1641 end - _t1635 = _t1636 + _t1639 = _t1640 end - _t1634 = _t1635 + _t1638 = _t1639 end - _t1633 = _t1634 + _t1637 = _t1638 end - _t1632 = _t1633 + _t1636 = _t1637 end - _t1631 = _t1632 + _t1635 = _t1636 end - _t1630 = _t1631 + _t1634 = _t1635 end - _t1629 = _t1630 + _t1633 = _t1634 end - _t1628 = _t1629 + _t1632 = _t1633 end - _t1627 = _t1628 + _t1631 = _t1632 end - _t1626 = _t1627 + _t1630 = _t1631 end - _t1625 = _t1626 + _t1629 = _t1630 end - _t1624 = _t1625 + _t1628 = _t1629 end - _t1623 = _t1624 + _t1627 = _t1628 end - _t1622 = _t1623 + _t1626 = _t1627 end - _t1621 = _t1622 + _t1625 = _t1626 end - _t1620 = _t1621 + _t1624 = _t1625 end - _t1619 = _t1620 + _t1623 = _t1624 end - _t1618 = _t1619 + _t1622 = _t1623 end - _t1617 = _t1618 + _t1621 = _t1622 end - _t1616 = _t1617 + _t1620 = _t1621 else - _t1616 = -1 - end - prediction872 = _t1616 - if prediction872 == 12 - _t1640 = parse_cast(parser) - cast885 = _t1640 - _t1641 = Proto.Formula(formula_type=OneOf(:cast, cast885)) - _t1639 = _t1641 + _t1620 = -1 + end + prediction874 = _t1620 + if prediction874 == 12 + _t1644 = parse_cast(parser) + cast887 = _t1644 + _t1645 = Proto.Formula(formula_type=OneOf(:cast, cast887)) + _t1643 = _t1645 else - if prediction872 == 11 - _t1643 = parse_rel_atom(parser) - rel_atom884 = _t1643 - _t1644 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom884)) - _t1642 = _t1644 + if prediction874 == 11 + _t1647 = parse_rel_atom(parser) + rel_atom886 = _t1647 + _t1648 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom886)) + _t1646 = _t1648 else - if prediction872 == 10 - _t1646 = parse_primitive(parser) - primitive883 = _t1646 - _t1647 = Proto.Formula(formula_type=OneOf(:primitive, primitive883)) - _t1645 = _t1647 + if prediction874 == 10 + _t1650 = parse_primitive(parser) + primitive885 = _t1650 + _t1651 = Proto.Formula(formula_type=OneOf(:primitive, primitive885)) + _t1649 = _t1651 else - if prediction872 == 9 - _t1649 = parse_pragma(parser) - pragma882 = _t1649 - _t1650 = Proto.Formula(formula_type=OneOf(:pragma, pragma882)) - _t1648 = _t1650 + if prediction874 == 9 + _t1653 = parse_pragma(parser) + pragma884 = _t1653 + _t1654 = Proto.Formula(formula_type=OneOf(:pragma, pragma884)) + _t1652 = _t1654 else - if prediction872 == 8 - _t1652 = parse_atom(parser) - atom881 = _t1652 - _t1653 = Proto.Formula(formula_type=OneOf(:atom, atom881)) - _t1651 = _t1653 + if prediction874 == 8 + _t1656 = parse_atom(parser) + atom883 = _t1656 + _t1657 = Proto.Formula(formula_type=OneOf(:atom, atom883)) + _t1655 = _t1657 else - if prediction872 == 7 - _t1655 = parse_ffi(parser) - ffi880 = _t1655 - _t1656 = Proto.Formula(formula_type=OneOf(:ffi, ffi880)) - _t1654 = _t1656 + if prediction874 == 7 + _t1659 = parse_ffi(parser) + ffi882 = _t1659 + _t1660 = Proto.Formula(formula_type=OneOf(:ffi, ffi882)) + _t1658 = _t1660 else - if prediction872 == 6 - _t1658 = parse_not(parser) - not879 = _t1658 - _t1659 = Proto.Formula(formula_type=OneOf(:not, not879)) - _t1657 = _t1659 + if prediction874 == 6 + _t1662 = parse_not(parser) + not881 = _t1662 + _t1663 = Proto.Formula(formula_type=OneOf(:not, not881)) + _t1661 = _t1663 else - if prediction872 == 5 - _t1661 = parse_disjunction(parser) - disjunction878 = _t1661 - _t1662 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction878)) - _t1660 = _t1662 + if prediction874 == 5 + _t1665 = parse_disjunction(parser) + disjunction880 = _t1665 + _t1666 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction880)) + _t1664 = _t1666 else - if prediction872 == 4 - _t1664 = parse_conjunction(parser) - conjunction877 = _t1664 - _t1665 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction877)) - _t1663 = _t1665 + if prediction874 == 4 + _t1668 = parse_conjunction(parser) + conjunction879 = _t1668 + _t1669 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction879)) + _t1667 = _t1669 else - if prediction872 == 3 - _t1667 = parse_reduce(parser) - reduce876 = _t1667 - _t1668 = Proto.Formula(formula_type=OneOf(:reduce, reduce876)) - _t1666 = _t1668 + if prediction874 == 3 + _t1671 = parse_reduce(parser) + reduce878 = _t1671 + _t1672 = Proto.Formula(formula_type=OneOf(:reduce, reduce878)) + _t1670 = _t1672 else - if prediction872 == 2 - _t1670 = parse_exists(parser) - exists875 = _t1670 - _t1671 = Proto.Formula(formula_type=OneOf(:exists, exists875)) - _t1669 = _t1671 + if prediction874 == 2 + _t1674 = parse_exists(parser) + exists877 = _t1674 + _t1675 = Proto.Formula(formula_type=OneOf(:exists, exists877)) + _t1673 = _t1675 else - if prediction872 == 1 - _t1673 = parse_false(parser) - false874 = _t1673 - _t1674 = Proto.Formula(formula_type=OneOf(:disjunction, false874)) - _t1672 = _t1674 + if prediction874 == 1 + _t1677 = parse_false(parser) + false876 = _t1677 + _t1678 = Proto.Formula(formula_type=OneOf(:disjunction, false876)) + _t1676 = _t1678 else - if prediction872 == 0 - _t1676 = parse_true(parser) - true873 = _t1676 - _t1677 = Proto.Formula(formula_type=OneOf(:conjunction, true873)) - _t1675 = _t1677 + if prediction874 == 0 + _t1680 = parse_true(parser) + true875 = _t1680 + _t1681 = Proto.Formula(formula_type=OneOf(:conjunction, true875)) + _t1679 = _t1681 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t1672 = _t1675 + _t1676 = _t1679 end - _t1669 = _t1672 + _t1673 = _t1676 end - _t1666 = _t1669 + _t1670 = _t1673 end - _t1663 = _t1666 + _t1667 = _t1670 end - _t1660 = _t1663 + _t1664 = _t1667 end - _t1657 = _t1660 + _t1661 = _t1664 end - _t1654 = _t1657 + _t1658 = _t1661 end - _t1651 = _t1654 + _t1655 = _t1658 end - _t1648 = _t1651 + _t1652 = _t1655 end - _t1645 = _t1648 + _t1649 = _t1652 end - _t1642 = _t1645 + _t1646 = _t1649 end - _t1639 = _t1642 + _t1643 = _t1646 end - result887 = _t1639 - record_span!(parser, span_start886, "Formula") - return result887 + result889 = _t1643 + record_span!(parser, span_start888, "Formula") + return result889 end function parse_true(parser::ParserState)::Proto.Conjunction - span_start888 = span_start(parser) + span_start890 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t1678 = Proto.Conjunction(args=Proto.Formula[]) - result889 = _t1678 - record_span!(parser, span_start888, "Conjunction") - return result889 + _t1682 = Proto.Conjunction(args=Proto.Formula[]) + result891 = _t1682 + record_span!(parser, span_start890, "Conjunction") + return result891 end function parse_false(parser::ParserState)::Proto.Disjunction - span_start890 = span_start(parser) + span_start892 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t1679 = Proto.Disjunction(args=Proto.Formula[]) - result891 = _t1679 - record_span!(parser, span_start890, "Disjunction") - return result891 + _t1683 = Proto.Disjunction(args=Proto.Formula[]) + result893 = _t1683 + record_span!(parser, span_start892, "Disjunction") + return result893 end function parse_exists(parser::ParserState)::Proto.Exists - span_start894 = span_start(parser) + span_start896 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t1680 = parse_bindings(parser) - bindings892 = _t1680 - _t1681 = parse_formula(parser) - formula893 = _t1681 + _t1684 = parse_bindings(parser) + bindings894 = _t1684 + _t1685 = parse_formula(parser) + formula895 = _t1685 consume_literal!(parser, ")") - _t1682 = Proto.Abstraction(vars=vcat(bindings892[1], !isnothing(bindings892[2]) ? bindings892[2] : []), value=formula893) - _t1683 = Proto.Exists(body=_t1682) - result895 = _t1683 - record_span!(parser, span_start894, "Exists") - return result895 + _t1686 = Proto.Abstraction(vars=vcat(bindings894[1], !isnothing(bindings894[2]) ? bindings894[2] : []), value=formula895) + _t1687 = Proto.Exists(body=_t1686) + result897 = _t1687 + record_span!(parser, span_start896, "Exists") + return result897 end function parse_reduce(parser::ParserState)::Proto.Reduce - span_start899 = span_start(parser) + span_start901 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t1684 = parse_abstraction(parser) - abstraction896 = _t1684 - _t1685 = parse_abstraction(parser) - abstraction_3897 = _t1685 - _t1686 = parse_terms(parser) - terms898 = _t1686 + _t1688 = parse_abstraction(parser) + abstraction898 = _t1688 + _t1689 = parse_abstraction(parser) + abstraction_3899 = _t1689 + _t1690 = parse_terms(parser) + terms900 = _t1690 consume_literal!(parser, ")") - _t1687 = Proto.Reduce(op=abstraction896, body=abstraction_3897, terms=terms898) - result900 = _t1687 - record_span!(parser, span_start899, "Reduce") - return result900 + _t1691 = Proto.Reduce(op=abstraction898, body=abstraction_3899, terms=terms900) + result902 = _t1691 + record_span!(parser, span_start901, "Reduce") + return result902 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs901 = Proto.Term[] - cond902 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond902 - _t1688 = parse_term(parser) - item903 = _t1688 - push!(xs901, item903) - cond902 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - end - terms904 = xs901 + xs903 = Proto.Term[] + cond904 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond904 + _t1692 = parse_term(parser) + item905 = _t1692 + push!(xs903, item905) + cond904 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + terms906 = xs903 consume_literal!(parser, ")") - return terms904 + return terms906 end function parse_term(parser::ParserState)::Proto.Term - span_start908 = span_start(parser) + span_start910 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1689 = 1 + _t1693 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1690 = 1 + _t1694 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1691 = 1 + _t1695 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1692 = 1 + _t1696 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1693 = 0 + _t1697 = 0 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1694 = 1 + _t1698 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1695 = 1 + _t1699 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1696 = 1 + _t1700 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1697 = 1 + _t1701 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1698 = 1 + _t1702 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1699 = 1 + _t1703 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1700 = 1 + _t1704 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1701 = 1 + _t1705 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1702 = 1 + _t1706 = 1 else - _t1702 = -1 + _t1706 = -1 end - _t1701 = _t1702 + _t1705 = _t1706 end - _t1700 = _t1701 + _t1704 = _t1705 end - _t1699 = _t1700 + _t1703 = _t1704 end - _t1698 = _t1699 + _t1702 = _t1703 end - _t1697 = _t1698 + _t1701 = _t1702 end - _t1696 = _t1697 + _t1700 = _t1701 end - _t1695 = _t1696 + _t1699 = _t1700 end - _t1694 = _t1695 + _t1698 = _t1699 end - _t1693 = _t1694 + _t1697 = _t1698 end - _t1692 = _t1693 + _t1696 = _t1697 end - _t1691 = _t1692 + _t1695 = _t1696 end - _t1690 = _t1691 + _t1694 = _t1695 end - _t1689 = _t1690 - end - prediction905 = _t1689 - if prediction905 == 1 - _t1704 = parse_value(parser) - value907 = _t1704 - _t1705 = Proto.Term(term_type=OneOf(:constant, value907)) - _t1703 = _t1705 + _t1693 = _t1694 + end + prediction907 = _t1693 + if prediction907 == 1 + _t1708 = parse_value(parser) + value909 = _t1708 + _t1709 = Proto.Term(term_type=OneOf(:constant, value909)) + _t1707 = _t1709 else - if prediction905 == 0 - _t1707 = parse_var(parser) - var906 = _t1707 - _t1708 = Proto.Term(term_type=OneOf(:var, var906)) - _t1706 = _t1708 + if prediction907 == 0 + _t1711 = parse_var(parser) + var908 = _t1711 + _t1712 = Proto.Term(term_type=OneOf(:var, var908)) + _t1710 = _t1712 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t1703 = _t1706 + _t1707 = _t1710 end - result909 = _t1703 - record_span!(parser, span_start908, "Term") - return result909 + result911 = _t1707 + record_span!(parser, span_start910, "Term") + return result911 end function parse_var(parser::ParserState)::Proto.Var - span_start911 = span_start(parser) - symbol910 = consume_terminal!(parser, "SYMBOL") - _t1709 = Proto.Var(name=symbol910) - result912 = _t1709 - record_span!(parser, span_start911, "Var") - return result912 + span_start913 = span_start(parser) + symbol912 = consume_terminal!(parser, "SYMBOL") + _t1713 = Proto.Var(name=symbol912) + result914 = _t1713 + record_span!(parser, span_start913, "Var") + return result914 end function parse_value(parser::ParserState)::Proto.Value - span_start926 = span_start(parser) + span_start928 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1710 = 12 + _t1714 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1711 = 11 + _t1715 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1712 = 12 + _t1716 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1714 = 1 + _t1718 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1715 = 0 + _t1719 = 0 else - _t1715 = -1 + _t1719 = -1 end - _t1714 = _t1715 + _t1718 = _t1719 end - _t1713 = _t1714 + _t1717 = _t1718 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1716 = 7 + _t1720 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1717 = 8 + _t1721 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1718 = 2 + _t1722 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1719 = 3 + _t1723 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1720 = 9 + _t1724 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1721 = 4 + _t1725 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1722 = 5 + _t1726 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1723 = 6 + _t1727 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1724 = 10 + _t1728 = 10 else - _t1724 = -1 + _t1728 = -1 end - _t1723 = _t1724 + _t1727 = _t1728 end - _t1722 = _t1723 + _t1726 = _t1727 end - _t1721 = _t1722 + _t1725 = _t1726 end - _t1720 = _t1721 + _t1724 = _t1725 end - _t1719 = _t1720 + _t1723 = _t1724 end - _t1718 = _t1719 + _t1722 = _t1723 end - _t1717 = _t1718 + _t1721 = _t1722 end - _t1716 = _t1717 + _t1720 = _t1721 end - _t1713 = _t1716 + _t1717 = _t1720 end - _t1712 = _t1713 + _t1716 = _t1717 end - _t1711 = _t1712 + _t1715 = _t1716 end - _t1710 = _t1711 - end - prediction913 = _t1710 - if prediction913 == 12 - _t1726 = parse_boolean_value(parser) - boolean_value925 = _t1726 - _t1727 = Proto.Value(value=OneOf(:boolean_value, boolean_value925)) - _t1725 = _t1727 + _t1714 = _t1715 + end + prediction915 = _t1714 + if prediction915 == 12 + _t1730 = parse_boolean_value(parser) + boolean_value927 = _t1730 + _t1731 = Proto.Value(value=OneOf(:boolean_value, boolean_value927)) + _t1729 = _t1731 else - if prediction913 == 11 + if prediction915 == 11 consume_literal!(parser, "missing") - _t1729 = Proto.MissingValue() - _t1730 = Proto.Value(value=OneOf(:missing_value, _t1729)) - _t1728 = _t1730 + _t1733 = Proto.MissingValue() + _t1734 = Proto.Value(value=OneOf(:missing_value, _t1733)) + _t1732 = _t1734 else - if prediction913 == 10 - formatted_decimal924 = consume_terminal!(parser, "DECIMAL") - _t1732 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal924)) - _t1731 = _t1732 + if prediction915 == 10 + formatted_decimal926 = consume_terminal!(parser, "DECIMAL") + _t1736 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal926)) + _t1735 = _t1736 else - if prediction913 == 9 - formatted_int128923 = consume_terminal!(parser, "INT128") - _t1734 = Proto.Value(value=OneOf(:int128_value, formatted_int128923)) - _t1733 = _t1734 + if prediction915 == 9 + formatted_int128925 = consume_terminal!(parser, "INT128") + _t1738 = Proto.Value(value=OneOf(:int128_value, formatted_int128925)) + _t1737 = _t1738 else - if prediction913 == 8 - formatted_uint128922 = consume_terminal!(parser, "UINT128") - _t1736 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128922)) - _t1735 = _t1736 + if prediction915 == 8 + formatted_uint128924 = consume_terminal!(parser, "UINT128") + _t1740 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128924)) + _t1739 = _t1740 else - if prediction913 == 7 - formatted_uint32921 = consume_terminal!(parser, "UINT32") - _t1738 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32921)) - _t1737 = _t1738 + if prediction915 == 7 + formatted_uint32923 = consume_terminal!(parser, "UINT32") + _t1742 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32923)) + _t1741 = _t1742 else - if prediction913 == 6 - formatted_float920 = consume_terminal!(parser, "FLOAT") - _t1740 = Proto.Value(value=OneOf(:float_value, formatted_float920)) - _t1739 = _t1740 + if prediction915 == 6 + formatted_float922 = consume_terminal!(parser, "FLOAT") + _t1744 = Proto.Value(value=OneOf(:float_value, formatted_float922)) + _t1743 = _t1744 else - if prediction913 == 5 - formatted_float32919 = consume_terminal!(parser, "FLOAT32") - _t1742 = Proto.Value(value=OneOf(:float32_value, formatted_float32919)) - _t1741 = _t1742 + if prediction915 == 5 + formatted_float32921 = consume_terminal!(parser, "FLOAT32") + _t1746 = Proto.Value(value=OneOf(:float32_value, formatted_float32921)) + _t1745 = _t1746 else - if prediction913 == 4 - formatted_int918 = consume_terminal!(parser, "INT") - _t1744 = Proto.Value(value=OneOf(:int_value, formatted_int918)) - _t1743 = _t1744 + if prediction915 == 4 + formatted_int920 = consume_terminal!(parser, "INT") + _t1748 = Proto.Value(value=OneOf(:int_value, formatted_int920)) + _t1747 = _t1748 else - if prediction913 == 3 - formatted_int32917 = consume_terminal!(parser, "INT32") - _t1746 = Proto.Value(value=OneOf(:int32_value, formatted_int32917)) - _t1745 = _t1746 + if prediction915 == 3 + formatted_int32919 = consume_terminal!(parser, "INT32") + _t1750 = Proto.Value(value=OneOf(:int32_value, formatted_int32919)) + _t1749 = _t1750 else - if prediction913 == 2 - formatted_string916 = consume_terminal!(parser, "STRING") - _t1748 = Proto.Value(value=OneOf(:string_value, formatted_string916)) - _t1747 = _t1748 + if prediction915 == 2 + formatted_string918 = consume_terminal!(parser, "STRING") + _t1752 = Proto.Value(value=OneOf(:string_value, formatted_string918)) + _t1751 = _t1752 else - if prediction913 == 1 - _t1750 = parse_datetime(parser) - datetime915 = _t1750 - _t1751 = Proto.Value(value=OneOf(:datetime_value, datetime915)) - _t1749 = _t1751 + if prediction915 == 1 + _t1754 = parse_datetime(parser) + datetime917 = _t1754 + _t1755 = Proto.Value(value=OneOf(:datetime_value, datetime917)) + _t1753 = _t1755 else - if prediction913 == 0 - _t1753 = parse_date(parser) - date914 = _t1753 - _t1754 = Proto.Value(value=OneOf(:date_value, date914)) - _t1752 = _t1754 + if prediction915 == 0 + _t1757 = parse_date(parser) + date916 = _t1757 + _t1758 = Proto.Value(value=OneOf(:date_value, date916)) + _t1756 = _t1758 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t1749 = _t1752 + _t1753 = _t1756 end - _t1747 = _t1749 + _t1751 = _t1753 end - _t1745 = _t1747 + _t1749 = _t1751 end - _t1743 = _t1745 + _t1747 = _t1749 end - _t1741 = _t1743 + _t1745 = _t1747 end - _t1739 = _t1741 + _t1743 = _t1745 end - _t1737 = _t1739 + _t1741 = _t1743 end - _t1735 = _t1737 + _t1739 = _t1741 end - _t1733 = _t1735 + _t1737 = _t1739 end - _t1731 = _t1733 + _t1735 = _t1737 end - _t1728 = _t1731 + _t1732 = _t1735 end - _t1725 = _t1728 + _t1729 = _t1732 end - result927 = _t1725 - record_span!(parser, span_start926, "Value") - return result927 + result929 = _t1729 + record_span!(parser, span_start928, "Value") + return result929 end function parse_date(parser::ParserState)::Proto.DateValue - span_start931 = span_start(parser) + span_start933 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - formatted_int928 = consume_terminal!(parser, "INT") - formatted_int_3929 = consume_terminal!(parser, "INT") - formatted_int_4930 = consume_terminal!(parser, "INT") + formatted_int930 = consume_terminal!(parser, "INT") + formatted_int_3931 = consume_terminal!(parser, "INT") + formatted_int_4932 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1755 = Proto.DateValue(year=Int32(formatted_int928), month=Int32(formatted_int_3929), day=Int32(formatted_int_4930)) - result932 = _t1755 - record_span!(parser, span_start931, "DateValue") - return result932 + _t1759 = Proto.DateValue(year=Int32(formatted_int930), month=Int32(formatted_int_3931), day=Int32(formatted_int_4932)) + result934 = _t1759 + record_span!(parser, span_start933, "DateValue") + return result934 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue - span_start940 = span_start(parser) + span_start942 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - formatted_int933 = consume_terminal!(parser, "INT") - formatted_int_3934 = consume_terminal!(parser, "INT") - formatted_int_4935 = consume_terminal!(parser, "INT") - formatted_int_5936 = consume_terminal!(parser, "INT") - formatted_int_6937 = consume_terminal!(parser, "INT") - formatted_int_7938 = consume_terminal!(parser, "INT") + formatted_int935 = consume_terminal!(parser, "INT") + formatted_int_3936 = consume_terminal!(parser, "INT") + formatted_int_4937 = consume_terminal!(parser, "INT") + formatted_int_5938 = consume_terminal!(parser, "INT") + formatted_int_6939 = consume_terminal!(parser, "INT") + formatted_int_7940 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1756 = consume_terminal!(parser, "INT") + _t1760 = consume_terminal!(parser, "INT") else - _t1756 = nothing + _t1760 = nothing end - formatted_int_8939 = _t1756 + formatted_int_8941 = _t1760 consume_literal!(parser, ")") - _t1757 = Proto.DateTimeValue(year=Int32(formatted_int933), month=Int32(formatted_int_3934), day=Int32(formatted_int_4935), hour=Int32(formatted_int_5936), minute=Int32(formatted_int_6937), second=Int32(formatted_int_7938), microsecond=Int32((!isnothing(formatted_int_8939) ? formatted_int_8939 : 0))) - result941 = _t1757 - record_span!(parser, span_start940, "DateTimeValue") - return result941 + _t1761 = Proto.DateTimeValue(year=Int32(formatted_int935), month=Int32(formatted_int_3936), day=Int32(formatted_int_4937), hour=Int32(formatted_int_5938), minute=Int32(formatted_int_6939), second=Int32(formatted_int_7940), microsecond=Int32((!isnothing(formatted_int_8941) ? formatted_int_8941 : 0))) + result943 = _t1761 + record_span!(parser, span_start942, "DateTimeValue") + return result943 end function parse_conjunction(parser::ParserState)::Proto.Conjunction - span_start946 = span_start(parser) + span_start948 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "and") - xs942 = Proto.Formula[] - cond943 = match_lookahead_literal(parser, "(", 0) - while cond943 - _t1758 = parse_formula(parser) - item944 = _t1758 - push!(xs942, item944) - cond943 = match_lookahead_literal(parser, "(", 0) - end - formulas945 = xs942 + xs944 = Proto.Formula[] + cond945 = match_lookahead_literal(parser, "(", 0) + while cond945 + _t1762 = parse_formula(parser) + item946 = _t1762 + push!(xs944, item946) + cond945 = match_lookahead_literal(parser, "(", 0) + end + formulas947 = xs944 consume_literal!(parser, ")") - _t1759 = Proto.Conjunction(args=formulas945) - result947 = _t1759 - record_span!(parser, span_start946, "Conjunction") - return result947 + _t1763 = Proto.Conjunction(args=formulas947) + result949 = _t1763 + record_span!(parser, span_start948, "Conjunction") + return result949 end function parse_disjunction(parser::ParserState)::Proto.Disjunction - span_start952 = span_start(parser) + span_start954 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") - xs948 = Proto.Formula[] - cond949 = match_lookahead_literal(parser, "(", 0) - while cond949 - _t1760 = parse_formula(parser) - item950 = _t1760 - push!(xs948, item950) - cond949 = match_lookahead_literal(parser, "(", 0) - end - formulas951 = xs948 + xs950 = Proto.Formula[] + cond951 = match_lookahead_literal(parser, "(", 0) + while cond951 + _t1764 = parse_formula(parser) + item952 = _t1764 + push!(xs950, item952) + cond951 = match_lookahead_literal(parser, "(", 0) + end + formulas953 = xs950 consume_literal!(parser, ")") - _t1761 = Proto.Disjunction(args=formulas951) - result953 = _t1761 - record_span!(parser, span_start952, "Disjunction") - return result953 + _t1765 = Proto.Disjunction(args=formulas953) + result955 = _t1765 + record_span!(parser, span_start954, "Disjunction") + return result955 end function parse_not(parser::ParserState)::Proto.Not - span_start955 = span_start(parser) + span_start957 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "not") - _t1762 = parse_formula(parser) - formula954 = _t1762 + _t1766 = parse_formula(parser) + formula956 = _t1766 consume_literal!(parser, ")") - _t1763 = Proto.Not(arg=formula954) - result956 = _t1763 - record_span!(parser, span_start955, "Not") - return result956 + _t1767 = Proto.Not(arg=formula956) + result958 = _t1767 + record_span!(parser, span_start957, "Not") + return result958 end function parse_ffi(parser::ParserState)::Proto.FFI - span_start960 = span_start(parser) + span_start962 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t1764 = parse_name(parser) - name957 = _t1764 - _t1765 = parse_ffi_args(parser) - ffi_args958 = _t1765 - _t1766 = parse_terms(parser) - terms959 = _t1766 + _t1768 = parse_name(parser) + name959 = _t1768 + _t1769 = parse_ffi_args(parser) + ffi_args960 = _t1769 + _t1770 = parse_terms(parser) + terms961 = _t1770 consume_literal!(parser, ")") - _t1767 = Proto.FFI(name=name957, args=ffi_args958, terms=terms959) - result961 = _t1767 - record_span!(parser, span_start960, "FFI") - return result961 + _t1771 = Proto.FFI(name=name959, args=ffi_args960, terms=terms961) + result963 = _t1771 + record_span!(parser, span_start962, "FFI") + return result963 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol962 = consume_terminal!(parser, "SYMBOL") - return symbol962 + symbol964 = consume_terminal!(parser, "SYMBOL") + return symbol964 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs963 = Proto.Abstraction[] - cond964 = match_lookahead_literal(parser, "(", 0) - while cond964 - _t1768 = parse_abstraction(parser) - item965 = _t1768 - push!(xs963, item965) - cond964 = match_lookahead_literal(parser, "(", 0) - end - abstractions966 = xs963 + xs965 = Proto.Abstraction[] + cond966 = match_lookahead_literal(parser, "(", 0) + while cond966 + _t1772 = parse_abstraction(parser) + item967 = _t1772 + push!(xs965, item967) + cond966 = match_lookahead_literal(parser, "(", 0) + end + abstractions968 = xs965 consume_literal!(parser, ")") - return abstractions966 + return abstractions968 end function parse_atom(parser::ParserState)::Proto.Atom - span_start972 = span_start(parser) + span_start974 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1769 = parse_relation_id(parser) - relation_id967 = _t1769 - xs968 = Proto.Term[] - cond969 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond969 - _t1770 = parse_term(parser) - item970 = _t1770 - push!(xs968, item970) - cond969 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - end - terms971 = xs968 + _t1773 = parse_relation_id(parser) + relation_id969 = _t1773 + xs970 = Proto.Term[] + cond971 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond971 + _t1774 = parse_term(parser) + item972 = _t1774 + push!(xs970, item972) + cond971 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + terms973 = xs970 consume_literal!(parser, ")") - _t1771 = Proto.Atom(name=relation_id967, terms=terms971) - result973 = _t1771 - record_span!(parser, span_start972, "Atom") - return result973 + _t1775 = Proto.Atom(name=relation_id969, terms=terms973) + result975 = _t1775 + record_span!(parser, span_start974, "Atom") + return result975 end function parse_pragma(parser::ParserState)::Proto.Pragma - span_start979 = span_start(parser) + span_start981 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1772 = parse_name(parser) - name974 = _t1772 - xs975 = Proto.Term[] - cond976 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond976 - _t1773 = parse_term(parser) - item977 = _t1773 - push!(xs975, item977) - cond976 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - end - terms978 = xs975 + _t1776 = parse_name(parser) + name976 = _t1776 + xs977 = Proto.Term[] + cond978 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond978 + _t1777 = parse_term(parser) + item979 = _t1777 + push!(xs977, item979) + cond978 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + terms980 = xs977 consume_literal!(parser, ")") - _t1774 = Proto.Pragma(name=name974, terms=terms978) - result980 = _t1774 - record_span!(parser, span_start979, "Pragma") - return result980 + _t1778 = Proto.Pragma(name=name976, terms=terms980) + result982 = _t1778 + record_span!(parser, span_start981, "Pragma") + return result982 end function parse_primitive(parser::ParserState)::Proto.Primitive - span_start996 = span_start(parser) + span_start998 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1776 = 9 + _t1780 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1777 = 4 + _t1781 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1778 = 3 + _t1782 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1779 = 0 + _t1783 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1780 = 2 + _t1784 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1781 = 1 + _t1785 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1782 = 8 + _t1786 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1783 = 6 + _t1787 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1784 = 5 + _t1788 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1785 = 7 + _t1789 = 7 else - _t1785 = -1 + _t1789 = -1 end - _t1784 = _t1785 + _t1788 = _t1789 end - _t1783 = _t1784 + _t1787 = _t1788 end - _t1782 = _t1783 + _t1786 = _t1787 end - _t1781 = _t1782 + _t1785 = _t1786 end - _t1780 = _t1781 + _t1784 = _t1785 end - _t1779 = _t1780 + _t1783 = _t1784 end - _t1778 = _t1779 + _t1782 = _t1783 end - _t1777 = _t1778 + _t1781 = _t1782 end - _t1776 = _t1777 + _t1780 = _t1781 end - _t1775 = _t1776 + _t1779 = _t1780 else - _t1775 = -1 + _t1779 = -1 end - prediction981 = _t1775 - if prediction981 == 9 + prediction983 = _t1779 + if prediction983 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1787 = parse_name(parser) - name991 = _t1787 - xs992 = Proto.RelTerm[] - cond993 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond993 - _t1788 = parse_rel_term(parser) - item994 = _t1788 - push!(xs992, item994) - cond993 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + _t1791 = parse_name(parser) + name993 = _t1791 + xs994 = Proto.RelTerm[] + cond995 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond995 + _t1792 = parse_rel_term(parser) + item996 = _t1792 + push!(xs994, item996) + cond995 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) end - rel_terms995 = xs992 + rel_terms997 = xs994 consume_literal!(parser, ")") - _t1789 = Proto.Primitive(name=name991, terms=rel_terms995) - _t1786 = _t1789 + _t1793 = Proto.Primitive(name=name993, terms=rel_terms997) + _t1790 = _t1793 else - if prediction981 == 8 - _t1791 = parse_divide(parser) - divide990 = _t1791 - _t1790 = divide990 + if prediction983 == 8 + _t1795 = parse_divide(parser) + divide992 = _t1795 + _t1794 = divide992 else - if prediction981 == 7 - _t1793 = parse_multiply(parser) - multiply989 = _t1793 - _t1792 = multiply989 + if prediction983 == 7 + _t1797 = parse_multiply(parser) + multiply991 = _t1797 + _t1796 = multiply991 else - if prediction981 == 6 - _t1795 = parse_minus(parser) - minus988 = _t1795 - _t1794 = minus988 + if prediction983 == 6 + _t1799 = parse_minus(parser) + minus990 = _t1799 + _t1798 = minus990 else - if prediction981 == 5 - _t1797 = parse_add(parser) - add987 = _t1797 - _t1796 = add987 + if prediction983 == 5 + _t1801 = parse_add(parser) + add989 = _t1801 + _t1800 = add989 else - if prediction981 == 4 - _t1799 = parse_gt_eq(parser) - gt_eq986 = _t1799 - _t1798 = gt_eq986 + if prediction983 == 4 + _t1803 = parse_gt_eq(parser) + gt_eq988 = _t1803 + _t1802 = gt_eq988 else - if prediction981 == 3 - _t1801 = parse_gt(parser) - gt985 = _t1801 - _t1800 = gt985 + if prediction983 == 3 + _t1805 = parse_gt(parser) + gt987 = _t1805 + _t1804 = gt987 else - if prediction981 == 2 - _t1803 = parse_lt_eq(parser) - lt_eq984 = _t1803 - _t1802 = lt_eq984 + if prediction983 == 2 + _t1807 = parse_lt_eq(parser) + lt_eq986 = _t1807 + _t1806 = lt_eq986 else - if prediction981 == 1 - _t1805 = parse_lt(parser) - lt983 = _t1805 - _t1804 = lt983 + if prediction983 == 1 + _t1809 = parse_lt(parser) + lt985 = _t1809 + _t1808 = lt985 else - if prediction981 == 0 - _t1807 = parse_eq(parser) - eq982 = _t1807 - _t1806 = eq982 + if prediction983 == 0 + _t1811 = parse_eq(parser) + eq984 = _t1811 + _t1810 = eq984 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1804 = _t1806 + _t1808 = _t1810 end - _t1802 = _t1804 + _t1806 = _t1808 end - _t1800 = _t1802 + _t1804 = _t1806 end - _t1798 = _t1800 + _t1802 = _t1804 end - _t1796 = _t1798 + _t1800 = _t1802 end - _t1794 = _t1796 + _t1798 = _t1800 end - _t1792 = _t1794 + _t1796 = _t1798 end - _t1790 = _t1792 + _t1794 = _t1796 end - _t1786 = _t1790 + _t1790 = _t1794 end - result997 = _t1786 - record_span!(parser, span_start996, "Primitive") - return result997 + result999 = _t1790 + record_span!(parser, span_start998, "Primitive") + return result999 end function parse_eq(parser::ParserState)::Proto.Primitive - span_start1000 = span_start(parser) + span_start1002 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1808 = parse_term(parser) - term998 = _t1808 - _t1809 = parse_term(parser) - term_3999 = _t1809 + _t1812 = parse_term(parser) + term1000 = _t1812 + _t1813 = parse_term(parser) + term_31001 = _t1813 consume_literal!(parser, ")") - _t1810 = Proto.RelTerm(rel_term_type=OneOf(:term, term998)) - _t1811 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3999)) - _t1812 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1810, _t1811]) - result1001 = _t1812 - record_span!(parser, span_start1000, "Primitive") - return result1001 + _t1814 = Proto.RelTerm(rel_term_type=OneOf(:term, term1000)) + _t1815 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31001)) + _t1816 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1814, _t1815]) + result1003 = _t1816 + record_span!(parser, span_start1002, "Primitive") + return result1003 end function parse_lt(parser::ParserState)::Proto.Primitive - span_start1004 = span_start(parser) + span_start1006 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1813 = parse_term(parser) - term1002 = _t1813 - _t1814 = parse_term(parser) - term_31003 = _t1814 + _t1817 = parse_term(parser) + term1004 = _t1817 + _t1818 = parse_term(parser) + term_31005 = _t1818 consume_literal!(parser, ")") - _t1815 = Proto.RelTerm(rel_term_type=OneOf(:term, term1002)) - _t1816 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31003)) - _t1817 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1815, _t1816]) - result1005 = _t1817 - record_span!(parser, span_start1004, "Primitive") - return result1005 + _t1819 = Proto.RelTerm(rel_term_type=OneOf(:term, term1004)) + _t1820 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31005)) + _t1821 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1819, _t1820]) + result1007 = _t1821 + record_span!(parser, span_start1006, "Primitive") + return result1007 end function parse_lt_eq(parser::ParserState)::Proto.Primitive - span_start1008 = span_start(parser) + span_start1010 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1818 = parse_term(parser) - term1006 = _t1818 - _t1819 = parse_term(parser) - term_31007 = _t1819 + _t1822 = parse_term(parser) + term1008 = _t1822 + _t1823 = parse_term(parser) + term_31009 = _t1823 consume_literal!(parser, ")") - _t1820 = Proto.RelTerm(rel_term_type=OneOf(:term, term1006)) - _t1821 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31007)) - _t1822 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1820, _t1821]) - result1009 = _t1822 - record_span!(parser, span_start1008, "Primitive") - return result1009 + _t1824 = Proto.RelTerm(rel_term_type=OneOf(:term, term1008)) + _t1825 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31009)) + _t1826 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1824, _t1825]) + result1011 = _t1826 + record_span!(parser, span_start1010, "Primitive") + return result1011 end function parse_gt(parser::ParserState)::Proto.Primitive - span_start1012 = span_start(parser) + span_start1014 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1823 = parse_term(parser) - term1010 = _t1823 - _t1824 = parse_term(parser) - term_31011 = _t1824 + _t1827 = parse_term(parser) + term1012 = _t1827 + _t1828 = parse_term(parser) + term_31013 = _t1828 consume_literal!(parser, ")") - _t1825 = Proto.RelTerm(rel_term_type=OneOf(:term, term1010)) - _t1826 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31011)) - _t1827 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1825, _t1826]) - result1013 = _t1827 - record_span!(parser, span_start1012, "Primitive") - return result1013 + _t1829 = Proto.RelTerm(rel_term_type=OneOf(:term, term1012)) + _t1830 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31013)) + _t1831 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1829, _t1830]) + result1015 = _t1831 + record_span!(parser, span_start1014, "Primitive") + return result1015 end function parse_gt_eq(parser::ParserState)::Proto.Primitive - span_start1016 = span_start(parser) + span_start1018 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1828 = parse_term(parser) - term1014 = _t1828 - _t1829 = parse_term(parser) - term_31015 = _t1829 + _t1832 = parse_term(parser) + term1016 = _t1832 + _t1833 = parse_term(parser) + term_31017 = _t1833 consume_literal!(parser, ")") - _t1830 = Proto.RelTerm(rel_term_type=OneOf(:term, term1014)) - _t1831 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31015)) - _t1832 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1830, _t1831]) - result1017 = _t1832 - record_span!(parser, span_start1016, "Primitive") - return result1017 + _t1834 = Proto.RelTerm(rel_term_type=OneOf(:term, term1016)) + _t1835 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31017)) + _t1836 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1834, _t1835]) + result1019 = _t1836 + record_span!(parser, span_start1018, "Primitive") + return result1019 end function parse_add(parser::ParserState)::Proto.Primitive - span_start1021 = span_start(parser) + span_start1023 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1833 = parse_term(parser) - term1018 = _t1833 - _t1834 = parse_term(parser) - term_31019 = _t1834 - _t1835 = parse_term(parser) - term_41020 = _t1835 + _t1837 = parse_term(parser) + term1020 = _t1837 + _t1838 = parse_term(parser) + term_31021 = _t1838 + _t1839 = parse_term(parser) + term_41022 = _t1839 consume_literal!(parser, ")") - _t1836 = Proto.RelTerm(rel_term_type=OneOf(:term, term1018)) - _t1837 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31019)) - _t1838 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41020)) - _t1839 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1836, _t1837, _t1838]) - result1022 = _t1839 - record_span!(parser, span_start1021, "Primitive") - return result1022 + _t1840 = Proto.RelTerm(rel_term_type=OneOf(:term, term1020)) + _t1841 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31021)) + _t1842 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41022)) + _t1843 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1840, _t1841, _t1842]) + result1024 = _t1843 + record_span!(parser, span_start1023, "Primitive") + return result1024 end function parse_minus(parser::ParserState)::Proto.Primitive - span_start1026 = span_start(parser) + span_start1028 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1840 = parse_term(parser) - term1023 = _t1840 - _t1841 = parse_term(parser) - term_31024 = _t1841 - _t1842 = parse_term(parser) - term_41025 = _t1842 + _t1844 = parse_term(parser) + term1025 = _t1844 + _t1845 = parse_term(parser) + term_31026 = _t1845 + _t1846 = parse_term(parser) + term_41027 = _t1846 consume_literal!(parser, ")") - _t1843 = Proto.RelTerm(rel_term_type=OneOf(:term, term1023)) - _t1844 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31024)) - _t1845 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41025)) - _t1846 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1843, _t1844, _t1845]) - result1027 = _t1846 - record_span!(parser, span_start1026, "Primitive") - return result1027 + _t1847 = Proto.RelTerm(rel_term_type=OneOf(:term, term1025)) + _t1848 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31026)) + _t1849 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41027)) + _t1850 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1847, _t1848, _t1849]) + result1029 = _t1850 + record_span!(parser, span_start1028, "Primitive") + return result1029 end function parse_multiply(parser::ParserState)::Proto.Primitive - span_start1031 = span_start(parser) + span_start1033 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1847 = parse_term(parser) - term1028 = _t1847 - _t1848 = parse_term(parser) - term_31029 = _t1848 - _t1849 = parse_term(parser) - term_41030 = _t1849 + _t1851 = parse_term(parser) + term1030 = _t1851 + _t1852 = parse_term(parser) + term_31031 = _t1852 + _t1853 = parse_term(parser) + term_41032 = _t1853 consume_literal!(parser, ")") - _t1850 = Proto.RelTerm(rel_term_type=OneOf(:term, term1028)) - _t1851 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31029)) - _t1852 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41030)) - _t1853 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1850, _t1851, _t1852]) - result1032 = _t1853 - record_span!(parser, span_start1031, "Primitive") - return result1032 + _t1854 = Proto.RelTerm(rel_term_type=OneOf(:term, term1030)) + _t1855 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31031)) + _t1856 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41032)) + _t1857 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1854, _t1855, _t1856]) + result1034 = _t1857 + record_span!(parser, span_start1033, "Primitive") + return result1034 end function parse_divide(parser::ParserState)::Proto.Primitive - span_start1036 = span_start(parser) + span_start1038 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1854 = parse_term(parser) - term1033 = _t1854 - _t1855 = parse_term(parser) - term_31034 = _t1855 - _t1856 = parse_term(parser) - term_41035 = _t1856 + _t1858 = parse_term(parser) + term1035 = _t1858 + _t1859 = parse_term(parser) + term_31036 = _t1859 + _t1860 = parse_term(parser) + term_41037 = _t1860 consume_literal!(parser, ")") - _t1857 = Proto.RelTerm(rel_term_type=OneOf(:term, term1033)) - _t1858 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31034)) - _t1859 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41035)) - _t1860 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1857, _t1858, _t1859]) - result1037 = _t1860 - record_span!(parser, span_start1036, "Primitive") - return result1037 + _t1861 = Proto.RelTerm(rel_term_type=OneOf(:term, term1035)) + _t1862 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31036)) + _t1863 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41037)) + _t1864 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1861, _t1862, _t1863]) + result1039 = _t1864 + record_span!(parser, span_start1038, "Primitive") + return result1039 end function parse_rel_term(parser::ParserState)::Proto.RelTerm - span_start1041 = span_start(parser) + span_start1043 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1861 = 1 + _t1865 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1862 = 1 + _t1866 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1863 = 1 + _t1867 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1864 = 1 + _t1868 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1865 = 0 + _t1869 = 0 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1866 = 1 + _t1870 = 1 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1867 = 1 + _t1871 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1868 = 1 + _t1872 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1869 = 1 + _t1873 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1870 = 1 + _t1874 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1871 = 1 + _t1875 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1872 = 1 + _t1876 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1873 = 1 + _t1877 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1874 = 1 + _t1878 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1875 = 1 + _t1879 = 1 else - _t1875 = -1 + _t1879 = -1 end - _t1874 = _t1875 + _t1878 = _t1879 end - _t1873 = _t1874 + _t1877 = _t1878 end - _t1872 = _t1873 + _t1876 = _t1877 end - _t1871 = _t1872 + _t1875 = _t1876 end - _t1870 = _t1871 + _t1874 = _t1875 end - _t1869 = _t1870 + _t1873 = _t1874 end - _t1868 = _t1869 + _t1872 = _t1873 end - _t1867 = _t1868 + _t1871 = _t1872 end - _t1866 = _t1867 + _t1870 = _t1871 end - _t1865 = _t1866 + _t1869 = _t1870 end - _t1864 = _t1865 + _t1868 = _t1869 end - _t1863 = _t1864 + _t1867 = _t1868 end - _t1862 = _t1863 + _t1866 = _t1867 end - _t1861 = _t1862 - end - prediction1038 = _t1861 - if prediction1038 == 1 - _t1877 = parse_term(parser) - term1040 = _t1877 - _t1878 = Proto.RelTerm(rel_term_type=OneOf(:term, term1040)) - _t1876 = _t1878 + _t1865 = _t1866 + end + prediction1040 = _t1865 + if prediction1040 == 1 + _t1881 = parse_term(parser) + term1042 = _t1881 + _t1882 = Proto.RelTerm(rel_term_type=OneOf(:term, term1042)) + _t1880 = _t1882 else - if prediction1038 == 0 - _t1880 = parse_specialized_value(parser) - specialized_value1039 = _t1880 - _t1881 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1039)) - _t1879 = _t1881 + if prediction1040 == 0 + _t1884 = parse_specialized_value(parser) + specialized_value1041 = _t1884 + _t1885 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1041)) + _t1883 = _t1885 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1876 = _t1879 + _t1880 = _t1883 end - result1042 = _t1876 - record_span!(parser, span_start1041, "RelTerm") - return result1042 + result1044 = _t1880 + record_span!(parser, span_start1043, "RelTerm") + return result1044 end function parse_specialized_value(parser::ParserState)::Proto.Value - span_start1044 = span_start(parser) + span_start1046 = span_start(parser) consume_literal!(parser, "#") - _t1882 = parse_raw_value(parser) - raw_value1043 = _t1882 - result1045 = raw_value1043 - record_span!(parser, span_start1044, "Value") - return result1045 + _t1886 = parse_raw_value(parser) + raw_value1045 = _t1886 + result1047 = raw_value1045 + record_span!(parser, span_start1046, "Value") + return result1047 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom - span_start1051 = span_start(parser) + span_start1053 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1883 = parse_name(parser) - name1046 = _t1883 - xs1047 = Proto.RelTerm[] - cond1048 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond1048 - _t1884 = parse_rel_term(parser) - item1049 = _t1884 - push!(xs1047, item1049) - cond1048 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - end - rel_terms1050 = xs1047 + _t1887 = parse_name(parser) + name1048 = _t1887 + xs1049 = Proto.RelTerm[] + cond1050 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond1050 + _t1888 = parse_rel_term(parser) + item1051 = _t1888 + push!(xs1049, item1051) + cond1050 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + rel_terms1052 = xs1049 consume_literal!(parser, ")") - _t1885 = Proto.RelAtom(name=name1046, terms=rel_terms1050) - result1052 = _t1885 - record_span!(parser, span_start1051, "RelAtom") - return result1052 + _t1889 = Proto.RelAtom(name=name1048, terms=rel_terms1052) + result1054 = _t1889 + record_span!(parser, span_start1053, "RelAtom") + return result1054 end function parse_cast(parser::ParserState)::Proto.Cast - span_start1055 = span_start(parser) + span_start1057 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1886 = parse_term(parser) - term1053 = _t1886 - _t1887 = parse_term(parser) - term_31054 = _t1887 + _t1890 = parse_term(parser) + term1055 = _t1890 + _t1891 = parse_term(parser) + term_31056 = _t1891 consume_literal!(parser, ")") - _t1888 = Proto.Cast(input=term1053, result=term_31054) - result1056 = _t1888 - record_span!(parser, span_start1055, "Cast") - return result1056 + _t1892 = Proto.Cast(input=term1055, result=term_31056) + result1058 = _t1892 + record_span!(parser, span_start1057, "Cast") + return result1058 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs1057 = Proto.Attribute[] - cond1058 = match_lookahead_literal(parser, "(", 0) - while cond1058 - _t1889 = parse_attribute(parser) - item1059 = _t1889 - push!(xs1057, item1059) - cond1058 = match_lookahead_literal(parser, "(", 0) - end - attributes1060 = xs1057 + xs1059 = Proto.Attribute[] + cond1060 = match_lookahead_literal(parser, "(", 0) + while cond1060 + _t1893 = parse_attribute(parser) + item1061 = _t1893 + push!(xs1059, item1061) + cond1060 = match_lookahead_literal(parser, "(", 0) + end + attributes1062 = xs1059 consume_literal!(parser, ")") - return attributes1060 + return attributes1062 end function parse_attribute(parser::ParserState)::Proto.Attribute - span_start1066 = span_start(parser) + span_start1068 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1890 = parse_name(parser) - name1061 = _t1890 - xs1062 = Proto.Value[] - cond1063 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) - while cond1063 - _t1891 = parse_raw_value(parser) - item1064 = _t1891 - push!(xs1062, item1064) - cond1063 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) - end - raw_values1065 = xs1062 + _t1894 = parse_name(parser) + name1063 = _t1894 + xs1064 = Proto.Value[] + cond1065 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) + while cond1065 + _t1895 = parse_raw_value(parser) + item1066 = _t1895 + push!(xs1064, item1066) + cond1065 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) + end + raw_values1067 = xs1064 consume_literal!(parser, ")") - _t1892 = Proto.Attribute(name=name1061, args=raw_values1065) - result1067 = _t1892 - record_span!(parser, span_start1066, "Attribute") - return result1067 + _t1896 = Proto.Attribute(name=name1063, args=raw_values1067) + result1069 = _t1896 + record_span!(parser, span_start1068, "Attribute") + return result1069 end function parse_algorithm(parser::ParserState)::Proto.Algorithm - span_start1074 = span_start(parser) + span_start1076 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs1068 = Proto.RelationId[] - cond1069 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1069 - _t1893 = parse_relation_id(parser) - item1070 = _t1893 - push!(xs1068, item1070) - cond1069 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1071 = xs1068 - _t1894 = parse_script(parser) - script1072 = _t1894 + xs1070 = Proto.RelationId[] + cond1071 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1071 + _t1897 = parse_relation_id(parser) + item1072 = _t1897 + push!(xs1070, item1072) + cond1071 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1073 = xs1070 + _t1898 = parse_script(parser) + script1074 = _t1898 if match_lookahead_literal(parser, "(", 0) - _t1896 = parse_attrs(parser) - _t1895 = _t1896 + _t1900 = parse_attrs(parser) + _t1899 = _t1900 else - _t1895 = nothing + _t1899 = nothing end - attrs1073 = _t1895 + attrs1075 = _t1899 consume_literal!(parser, ")") - _t1897 = Proto.Algorithm(var"#global"=relation_ids1071, body=script1072, attrs=(!isnothing(attrs1073) ? attrs1073 : Proto.Attribute[])) - result1075 = _t1897 - record_span!(parser, span_start1074, "Algorithm") - return result1075 + _t1901 = Proto.Algorithm(var"#global"=relation_ids1073, body=script1074, attrs=(!isnothing(attrs1075) ? attrs1075 : Proto.Attribute[])) + result1077 = _t1901 + record_span!(parser, span_start1076, "Algorithm") + return result1077 end function parse_script(parser::ParserState)::Proto.Script - span_start1080 = span_start(parser) + span_start1082 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "script") - xs1076 = Proto.Construct[] - cond1077 = match_lookahead_literal(parser, "(", 0) - while cond1077 - _t1898 = parse_construct(parser) - item1078 = _t1898 - push!(xs1076, item1078) - cond1077 = match_lookahead_literal(parser, "(", 0) - end - constructs1079 = xs1076 + xs1078 = Proto.Construct[] + cond1079 = match_lookahead_literal(parser, "(", 0) + while cond1079 + _t1902 = parse_construct(parser) + item1080 = _t1902 + push!(xs1078, item1080) + cond1079 = match_lookahead_literal(parser, "(", 0) + end + constructs1081 = xs1078 consume_literal!(parser, ")") - _t1899 = Proto.Script(constructs=constructs1079) - result1081 = _t1899 - record_span!(parser, span_start1080, "Script") - return result1081 + _t1903 = Proto.Script(constructs=constructs1081) + result1083 = _t1903 + record_span!(parser, span_start1082, "Script") + return result1083 end function parse_construct(parser::ParserState)::Proto.Construct - span_start1085 = span_start(parser) + span_start1087 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1901 = 1 + _t1905 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1902 = 1 + _t1906 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1903 = 1 + _t1907 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1904 = 0 + _t1908 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1905 = 1 + _t1909 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1906 = 1 + _t1910 = 1 else - _t1906 = -1 + _t1910 = -1 end - _t1905 = _t1906 + _t1909 = _t1910 end - _t1904 = _t1905 + _t1908 = _t1909 end - _t1903 = _t1904 + _t1907 = _t1908 end - _t1902 = _t1903 + _t1906 = _t1907 end - _t1901 = _t1902 + _t1905 = _t1906 end - _t1900 = _t1901 + _t1904 = _t1905 else - _t1900 = -1 - end - prediction1082 = _t1900 - if prediction1082 == 1 - _t1908 = parse_instruction(parser) - instruction1084 = _t1908 - _t1909 = Proto.Construct(construct_type=OneOf(:instruction, instruction1084)) - _t1907 = _t1909 + _t1904 = -1 + end + prediction1084 = _t1904 + if prediction1084 == 1 + _t1912 = parse_instruction(parser) + instruction1086 = _t1912 + _t1913 = Proto.Construct(construct_type=OneOf(:instruction, instruction1086)) + _t1911 = _t1913 else - if prediction1082 == 0 - _t1911 = parse_loop(parser) - loop1083 = _t1911 - _t1912 = Proto.Construct(construct_type=OneOf(:loop, loop1083)) - _t1910 = _t1912 + if prediction1084 == 0 + _t1915 = parse_loop(parser) + loop1085 = _t1915 + _t1916 = Proto.Construct(construct_type=OneOf(:loop, loop1085)) + _t1914 = _t1916 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1907 = _t1910 + _t1911 = _t1914 end - result1086 = _t1907 - record_span!(parser, span_start1085, "Construct") - return result1086 + result1088 = _t1911 + record_span!(parser, span_start1087, "Construct") + return result1088 end function parse_loop(parser::ParserState)::Proto.Loop - span_start1090 = span_start(parser) + span_start1092 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1913 = parse_init(parser) - init1087 = _t1913 - _t1914 = parse_script(parser) - script1088 = _t1914 + _t1917 = parse_init(parser) + init1089 = _t1917 + _t1918 = parse_script(parser) + script1090 = _t1918 if match_lookahead_literal(parser, "(", 0) - _t1916 = parse_attrs(parser) - _t1915 = _t1916 + _t1920 = parse_attrs(parser) + _t1919 = _t1920 else - _t1915 = nothing + _t1919 = nothing end - attrs1089 = _t1915 + attrs1091 = _t1919 consume_literal!(parser, ")") - _t1917 = Proto.Loop(init=init1087, body=script1088, attrs=(!isnothing(attrs1089) ? attrs1089 : Proto.Attribute[])) - result1091 = _t1917 - record_span!(parser, span_start1090, "Loop") - return result1091 + _t1921 = Proto.Loop(init=init1089, body=script1090, attrs=(!isnothing(attrs1091) ? attrs1091 : Proto.Attribute[])) + result1093 = _t1921 + record_span!(parser, span_start1092, "Loop") + return result1093 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs1092 = Proto.Instruction[] - cond1093 = match_lookahead_literal(parser, "(", 0) - while cond1093 - _t1918 = parse_instruction(parser) - item1094 = _t1918 - push!(xs1092, item1094) - cond1093 = match_lookahead_literal(parser, "(", 0) - end - instructions1095 = xs1092 + xs1094 = Proto.Instruction[] + cond1095 = match_lookahead_literal(parser, "(", 0) + while cond1095 + _t1922 = parse_instruction(parser) + item1096 = _t1922 + push!(xs1094, item1096) + cond1095 = match_lookahead_literal(parser, "(", 0) + end + instructions1097 = xs1094 consume_literal!(parser, ")") - return instructions1095 + return instructions1097 end function parse_instruction(parser::ParserState)::Proto.Instruction - span_start1102 = span_start(parser) + span_start1104 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1920 = 1 + _t1924 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1921 = 4 + _t1925 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1922 = 3 + _t1926 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1923 = 2 + _t1927 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1924 = 0 + _t1928 = 0 else - _t1924 = -1 + _t1928 = -1 end - _t1923 = _t1924 + _t1927 = _t1928 end - _t1922 = _t1923 + _t1926 = _t1927 end - _t1921 = _t1922 + _t1925 = _t1926 end - _t1920 = _t1921 + _t1924 = _t1925 end - _t1919 = _t1920 + _t1923 = _t1924 else - _t1919 = -1 - end - prediction1096 = _t1919 - if prediction1096 == 4 - _t1926 = parse_monus_def(parser) - monus_def1101 = _t1926 - _t1927 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1101)) - _t1925 = _t1927 + _t1923 = -1 + end + prediction1098 = _t1923 + if prediction1098 == 4 + _t1930 = parse_monus_def(parser) + monus_def1103 = _t1930 + _t1931 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1103)) + _t1929 = _t1931 else - if prediction1096 == 3 - _t1929 = parse_monoid_def(parser) - monoid_def1100 = _t1929 - _t1930 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1100)) - _t1928 = _t1930 + if prediction1098 == 3 + _t1933 = parse_monoid_def(parser) + monoid_def1102 = _t1933 + _t1934 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1102)) + _t1932 = _t1934 else - if prediction1096 == 2 - _t1932 = parse_break(parser) - break1099 = _t1932 - _t1933 = Proto.Instruction(instr_type=OneOf(:var"#break", break1099)) - _t1931 = _t1933 + if prediction1098 == 2 + _t1936 = parse_break(parser) + break1101 = _t1936 + _t1937 = Proto.Instruction(instr_type=OneOf(:var"#break", break1101)) + _t1935 = _t1937 else - if prediction1096 == 1 - _t1935 = parse_upsert(parser) - upsert1098 = _t1935 - _t1936 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1098)) - _t1934 = _t1936 + if prediction1098 == 1 + _t1939 = parse_upsert(parser) + upsert1100 = _t1939 + _t1940 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1100)) + _t1938 = _t1940 else - if prediction1096 == 0 - _t1938 = parse_assign(parser) - assign1097 = _t1938 - _t1939 = Proto.Instruction(instr_type=OneOf(:assign, assign1097)) - _t1937 = _t1939 + if prediction1098 == 0 + _t1942 = parse_assign(parser) + assign1099 = _t1942 + _t1943 = Proto.Instruction(instr_type=OneOf(:assign, assign1099)) + _t1941 = _t1943 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1934 = _t1937 + _t1938 = _t1941 end - _t1931 = _t1934 + _t1935 = _t1938 end - _t1928 = _t1931 + _t1932 = _t1935 end - _t1925 = _t1928 + _t1929 = _t1932 end - result1103 = _t1925 - record_span!(parser, span_start1102, "Instruction") - return result1103 + result1105 = _t1929 + record_span!(parser, span_start1104, "Instruction") + return result1105 end function parse_assign(parser::ParserState)::Proto.Assign - span_start1107 = span_start(parser) + span_start1109 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1940 = parse_relation_id(parser) - relation_id1104 = _t1940 - _t1941 = parse_abstraction(parser) - abstraction1105 = _t1941 + _t1944 = parse_relation_id(parser) + relation_id1106 = _t1944 + _t1945 = parse_abstraction(parser) + abstraction1107 = _t1945 if match_lookahead_literal(parser, "(", 0) - _t1943 = parse_attrs(parser) - _t1942 = _t1943 + _t1947 = parse_attrs(parser) + _t1946 = _t1947 else - _t1942 = nothing + _t1946 = nothing end - attrs1106 = _t1942 + attrs1108 = _t1946 consume_literal!(parser, ")") - _t1944 = Proto.Assign(name=relation_id1104, body=abstraction1105, attrs=(!isnothing(attrs1106) ? attrs1106 : Proto.Attribute[])) - result1108 = _t1944 - record_span!(parser, span_start1107, "Assign") - return result1108 + _t1948 = Proto.Assign(name=relation_id1106, body=abstraction1107, attrs=(!isnothing(attrs1108) ? attrs1108 : Proto.Attribute[])) + result1110 = _t1948 + record_span!(parser, span_start1109, "Assign") + return result1110 end function parse_upsert(parser::ParserState)::Proto.Upsert - span_start1112 = span_start(parser) + span_start1114 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1945 = parse_relation_id(parser) - relation_id1109 = _t1945 - _t1946 = parse_abstraction_with_arity(parser) - abstraction_with_arity1110 = _t1946 + _t1949 = parse_relation_id(parser) + relation_id1111 = _t1949 + _t1950 = parse_abstraction_with_arity(parser) + abstraction_with_arity1112 = _t1950 if match_lookahead_literal(parser, "(", 0) - _t1948 = parse_attrs(parser) - _t1947 = _t1948 + _t1952 = parse_attrs(parser) + _t1951 = _t1952 else - _t1947 = nothing + _t1951 = nothing end - attrs1111 = _t1947 + attrs1113 = _t1951 consume_literal!(parser, ")") - _t1949 = Proto.Upsert(name=relation_id1109, body=abstraction_with_arity1110[1], attrs=(!isnothing(attrs1111) ? attrs1111 : Proto.Attribute[]), value_arity=abstraction_with_arity1110[2]) - result1113 = _t1949 - record_span!(parser, span_start1112, "Upsert") - return result1113 + _t1953 = Proto.Upsert(name=relation_id1111, body=abstraction_with_arity1112[1], attrs=(!isnothing(attrs1113) ? attrs1113 : Proto.Attribute[]), value_arity=abstraction_with_arity1112[2]) + result1115 = _t1953 + record_span!(parser, span_start1114, "Upsert") + return result1115 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1950 = parse_bindings(parser) - bindings1114 = _t1950 - _t1951 = parse_formula(parser) - formula1115 = _t1951 + _t1954 = parse_bindings(parser) + bindings1116 = _t1954 + _t1955 = parse_formula(parser) + formula1117 = _t1955 consume_literal!(parser, ")") - _t1952 = Proto.Abstraction(vars=vcat(bindings1114[1], !isnothing(bindings1114[2]) ? bindings1114[2] : []), value=formula1115) - return (_t1952, length(bindings1114[2]),) + _t1956 = Proto.Abstraction(vars=vcat(bindings1116[1], !isnothing(bindings1116[2]) ? bindings1116[2] : []), value=formula1117) + return (_t1956, length(bindings1116[2]),) end function parse_break(parser::ParserState)::Proto.Break - span_start1119 = span_start(parser) + span_start1121 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1953 = parse_relation_id(parser) - relation_id1116 = _t1953 - _t1954 = parse_abstraction(parser) - abstraction1117 = _t1954 + _t1957 = parse_relation_id(parser) + relation_id1118 = _t1957 + _t1958 = parse_abstraction(parser) + abstraction1119 = _t1958 if match_lookahead_literal(parser, "(", 0) - _t1956 = parse_attrs(parser) - _t1955 = _t1956 + _t1960 = parse_attrs(parser) + _t1959 = _t1960 else - _t1955 = nothing + _t1959 = nothing end - attrs1118 = _t1955 + attrs1120 = _t1959 consume_literal!(parser, ")") - _t1957 = Proto.Break(name=relation_id1116, body=abstraction1117, attrs=(!isnothing(attrs1118) ? attrs1118 : Proto.Attribute[])) - result1120 = _t1957 - record_span!(parser, span_start1119, "Break") - return result1120 + _t1961 = Proto.Break(name=relation_id1118, body=abstraction1119, attrs=(!isnothing(attrs1120) ? attrs1120 : Proto.Attribute[])) + result1122 = _t1961 + record_span!(parser, span_start1121, "Break") + return result1122 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef - span_start1125 = span_start(parser) + span_start1127 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1958 = parse_monoid(parser) - monoid1121 = _t1958 - _t1959 = parse_relation_id(parser) - relation_id1122 = _t1959 - _t1960 = parse_abstraction_with_arity(parser) - abstraction_with_arity1123 = _t1960 + _t1962 = parse_monoid(parser) + monoid1123 = _t1962 + _t1963 = parse_relation_id(parser) + relation_id1124 = _t1963 + _t1964 = parse_abstraction_with_arity(parser) + abstraction_with_arity1125 = _t1964 if match_lookahead_literal(parser, "(", 0) - _t1962 = parse_attrs(parser) - _t1961 = _t1962 + _t1966 = parse_attrs(parser) + _t1965 = _t1966 else - _t1961 = nothing + _t1965 = nothing end - attrs1124 = _t1961 + attrs1126 = _t1965 consume_literal!(parser, ")") - _t1963 = Proto.MonoidDef(monoid=monoid1121, name=relation_id1122, body=abstraction_with_arity1123[1], attrs=(!isnothing(attrs1124) ? attrs1124 : Proto.Attribute[]), value_arity=abstraction_with_arity1123[2]) - result1126 = _t1963 - record_span!(parser, span_start1125, "MonoidDef") - return result1126 + _t1967 = Proto.MonoidDef(monoid=monoid1123, name=relation_id1124, body=abstraction_with_arity1125[1], attrs=(!isnothing(attrs1126) ? attrs1126 : Proto.Attribute[]), value_arity=abstraction_with_arity1125[2]) + result1128 = _t1967 + record_span!(parser, span_start1127, "MonoidDef") + return result1128 end function parse_monoid(parser::ParserState)::Proto.Monoid - span_start1132 = span_start(parser) + span_start1134 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1965 = 3 + _t1969 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1966 = 0 + _t1970 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1967 = 1 + _t1971 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1968 = 2 + _t1972 = 2 else - _t1968 = -1 + _t1972 = -1 end - _t1967 = _t1968 + _t1971 = _t1972 end - _t1966 = _t1967 + _t1970 = _t1971 end - _t1965 = _t1966 + _t1969 = _t1970 end - _t1964 = _t1965 + _t1968 = _t1969 else - _t1964 = -1 - end - prediction1127 = _t1964 - if prediction1127 == 3 - _t1970 = parse_sum_monoid(parser) - sum_monoid1131 = _t1970 - _t1971 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1131)) - _t1969 = _t1971 + _t1968 = -1 + end + prediction1129 = _t1968 + if prediction1129 == 3 + _t1974 = parse_sum_monoid(parser) + sum_monoid1133 = _t1974 + _t1975 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1133)) + _t1973 = _t1975 else - if prediction1127 == 2 - _t1973 = parse_max_monoid(parser) - max_monoid1130 = _t1973 - _t1974 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1130)) - _t1972 = _t1974 + if prediction1129 == 2 + _t1977 = parse_max_monoid(parser) + max_monoid1132 = _t1977 + _t1978 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1132)) + _t1976 = _t1978 else - if prediction1127 == 1 - _t1976 = parse_min_monoid(parser) - min_monoid1129 = _t1976 - _t1977 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1129)) - _t1975 = _t1977 + if prediction1129 == 1 + _t1980 = parse_min_monoid(parser) + min_monoid1131 = _t1980 + _t1981 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1131)) + _t1979 = _t1981 else - if prediction1127 == 0 - _t1979 = parse_or_monoid(parser) - or_monoid1128 = _t1979 - _t1980 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1128)) - _t1978 = _t1980 + if prediction1129 == 0 + _t1983 = parse_or_monoid(parser) + or_monoid1130 = _t1983 + _t1984 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1130)) + _t1982 = _t1984 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1975 = _t1978 + _t1979 = _t1982 end - _t1972 = _t1975 + _t1976 = _t1979 end - _t1969 = _t1972 + _t1973 = _t1976 end - result1133 = _t1969 - record_span!(parser, span_start1132, "Monoid") - return result1133 + result1135 = _t1973 + record_span!(parser, span_start1134, "Monoid") + return result1135 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid - span_start1134 = span_start(parser) + span_start1136 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1981 = Proto.OrMonoid() - result1135 = _t1981 - record_span!(parser, span_start1134, "OrMonoid") - return result1135 + _t1985 = Proto.OrMonoid() + result1137 = _t1985 + record_span!(parser, span_start1136, "OrMonoid") + return result1137 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid - span_start1137 = span_start(parser) + span_start1139 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1982 = parse_type(parser) - type1136 = _t1982 + _t1986 = parse_type(parser) + type1138 = _t1986 consume_literal!(parser, ")") - _t1983 = Proto.MinMonoid(var"#type"=type1136) - result1138 = _t1983 - record_span!(parser, span_start1137, "MinMonoid") - return result1138 + _t1987 = Proto.MinMonoid(var"#type"=type1138) + result1140 = _t1987 + record_span!(parser, span_start1139, "MinMonoid") + return result1140 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid - span_start1140 = span_start(parser) + span_start1142 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1984 = parse_type(parser) - type1139 = _t1984 + _t1988 = parse_type(parser) + type1141 = _t1988 consume_literal!(parser, ")") - _t1985 = Proto.MaxMonoid(var"#type"=type1139) - result1141 = _t1985 - record_span!(parser, span_start1140, "MaxMonoid") - return result1141 + _t1989 = Proto.MaxMonoid(var"#type"=type1141) + result1143 = _t1989 + record_span!(parser, span_start1142, "MaxMonoid") + return result1143 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid - span_start1143 = span_start(parser) + span_start1145 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1986 = parse_type(parser) - type1142 = _t1986 + _t1990 = parse_type(parser) + type1144 = _t1990 consume_literal!(parser, ")") - _t1987 = Proto.SumMonoid(var"#type"=type1142) - result1144 = _t1987 - record_span!(parser, span_start1143, "SumMonoid") - return result1144 + _t1991 = Proto.SumMonoid(var"#type"=type1144) + result1146 = _t1991 + record_span!(parser, span_start1145, "SumMonoid") + return result1146 end function parse_monus_def(parser::ParserState)::Proto.MonusDef - span_start1149 = span_start(parser) + span_start1151 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1988 = parse_monoid(parser) - monoid1145 = _t1988 - _t1989 = parse_relation_id(parser) - relation_id1146 = _t1989 - _t1990 = parse_abstraction_with_arity(parser) - abstraction_with_arity1147 = _t1990 + _t1992 = parse_monoid(parser) + monoid1147 = _t1992 + _t1993 = parse_relation_id(parser) + relation_id1148 = _t1993 + _t1994 = parse_abstraction_with_arity(parser) + abstraction_with_arity1149 = _t1994 if match_lookahead_literal(parser, "(", 0) - _t1992 = parse_attrs(parser) - _t1991 = _t1992 + _t1996 = parse_attrs(parser) + _t1995 = _t1996 else - _t1991 = nothing + _t1995 = nothing end - attrs1148 = _t1991 + attrs1150 = _t1995 consume_literal!(parser, ")") - _t1993 = Proto.MonusDef(monoid=monoid1145, name=relation_id1146, body=abstraction_with_arity1147[1], attrs=(!isnothing(attrs1148) ? attrs1148 : Proto.Attribute[]), value_arity=abstraction_with_arity1147[2]) - result1150 = _t1993 - record_span!(parser, span_start1149, "MonusDef") - return result1150 + _t1997 = Proto.MonusDef(monoid=monoid1147, name=relation_id1148, body=abstraction_with_arity1149[1], attrs=(!isnothing(attrs1150) ? attrs1150 : Proto.Attribute[]), value_arity=abstraction_with_arity1149[2]) + result1152 = _t1997 + record_span!(parser, span_start1151, "MonusDef") + return result1152 end function parse_constraint(parser::ParserState)::Proto.Constraint - span_start1155 = span_start(parser) + span_start1157 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1994 = parse_relation_id(parser) - relation_id1151 = _t1994 - _t1995 = parse_abstraction(parser) - abstraction1152 = _t1995 - _t1996 = parse_functional_dependency_keys(parser) - functional_dependency_keys1153 = _t1996 - _t1997 = parse_functional_dependency_values(parser) - functional_dependency_values1154 = _t1997 + _t1998 = parse_relation_id(parser) + relation_id1153 = _t1998 + _t1999 = parse_abstraction(parser) + abstraction1154 = _t1999 + _t2000 = parse_functional_dependency_keys(parser) + functional_dependency_keys1155 = _t2000 + _t2001 = parse_functional_dependency_values(parser) + functional_dependency_values1156 = _t2001 consume_literal!(parser, ")") - _t1998 = Proto.FunctionalDependency(guard=abstraction1152, keys=functional_dependency_keys1153, values=functional_dependency_values1154) - _t1999 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1998), name=relation_id1151) - result1156 = _t1999 - record_span!(parser, span_start1155, "Constraint") - return result1156 + _t2002 = Proto.FunctionalDependency(guard=abstraction1154, keys=functional_dependency_keys1155, values=functional_dependency_values1156) + _t2003 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t2002), name=relation_id1153) + result1158 = _t2003 + record_span!(parser, span_start1157, "Constraint") + return result1158 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1157 = Proto.Var[] - cond1158 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1158 - _t2000 = parse_var(parser) - item1159 = _t2000 - push!(xs1157, item1159) - cond1158 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1160 = xs1157 + xs1159 = Proto.Var[] + cond1160 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1160 + _t2004 = parse_var(parser) + item1161 = _t2004 + push!(xs1159, item1161) + cond1160 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1162 = xs1159 consume_literal!(parser, ")") - return vars1160 + return vars1162 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs1161 = Proto.Var[] - cond1162 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1162 - _t2001 = parse_var(parser) - item1163 = _t2001 - push!(xs1161, item1163) - cond1162 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1164 = xs1161 + xs1163 = Proto.Var[] + cond1164 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1164 + _t2005 = parse_var(parser) + item1165 = _t2005 + push!(xs1163, item1165) + cond1164 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1166 = xs1163 consume_literal!(parser, ")") - return vars1164 + return vars1166 end function parse_data(parser::ParserState)::Proto.Data - span_start1170 = span_start(parser) + span_start1172 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t2003 = 3 + _t2007 = 3 else if match_lookahead_literal(parser, "edb", 1) - _t2004 = 0 + _t2008 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t2005 = 2 + _t2009 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t2006 = 1 + _t2010 = 1 else - _t2006 = -1 + _t2010 = -1 end - _t2005 = _t2006 + _t2009 = _t2010 end - _t2004 = _t2005 + _t2008 = _t2009 end - _t2003 = _t2004 + _t2007 = _t2008 end - _t2002 = _t2003 + _t2006 = _t2007 else - _t2002 = -1 - end - prediction1165 = _t2002 - if prediction1165 == 3 - _t2008 = parse_iceberg_data(parser) - iceberg_data1169 = _t2008 - _t2009 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1169)) - _t2007 = _t2009 + _t2006 = -1 + end + prediction1167 = _t2006 + if prediction1167 == 3 + _t2012 = parse_iceberg_data(parser) + iceberg_data1171 = _t2012 + _t2013 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1171)) + _t2011 = _t2013 else - if prediction1165 == 2 - _t2011 = parse_csv_data(parser) - csv_data1168 = _t2011 - _t2012 = Proto.Data(data_type=OneOf(:csv_data, csv_data1168)) - _t2010 = _t2012 + if prediction1167 == 2 + _t2015 = parse_csv_data(parser) + csv_data1170 = _t2015 + _t2016 = Proto.Data(data_type=OneOf(:csv_data, csv_data1170)) + _t2014 = _t2016 else - if prediction1165 == 1 - _t2014 = parse_betree_relation(parser) - betree_relation1167 = _t2014 - _t2015 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1167)) - _t2013 = _t2015 + if prediction1167 == 1 + _t2018 = parse_betree_relation(parser) + betree_relation1169 = _t2018 + _t2019 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1169)) + _t2017 = _t2019 else - if prediction1165 == 0 - _t2017 = parse_edb(parser) - edb1166 = _t2017 - _t2018 = Proto.Data(data_type=OneOf(:edb, edb1166)) - _t2016 = _t2018 + if prediction1167 == 0 + _t2021 = parse_edb(parser) + edb1168 = _t2021 + _t2022 = Proto.Data(data_type=OneOf(:edb, edb1168)) + _t2020 = _t2022 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t2013 = _t2016 + _t2017 = _t2020 end - _t2010 = _t2013 + _t2014 = _t2017 end - _t2007 = _t2010 + _t2011 = _t2014 end - result1171 = _t2007 - record_span!(parser, span_start1170, "Data") - return result1171 + result1173 = _t2011 + record_span!(parser, span_start1172, "Data") + return result1173 end function parse_edb(parser::ParserState)::Proto.EDB - span_start1175 = span_start(parser) + span_start1177 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "edb") - _t2019 = parse_relation_id(parser) - relation_id1172 = _t2019 - _t2020 = parse_edb_path(parser) - edb_path1173 = _t2020 - _t2021 = parse_edb_types(parser) - edb_types1174 = _t2021 + _t2023 = parse_relation_id(parser) + relation_id1174 = _t2023 + _t2024 = parse_edb_path(parser) + edb_path1175 = _t2024 + _t2025 = parse_edb_types(parser) + edb_types1176 = _t2025 consume_literal!(parser, ")") - _t2022 = Proto.EDB(target_id=relation_id1172, path=edb_path1173, types=edb_types1174) - result1176 = _t2022 - record_span!(parser, span_start1175, "EDB") - return result1176 + _t2026 = Proto.EDB(target_id=relation_id1174, path=edb_path1175, types=edb_types1176) + result1178 = _t2026 + record_span!(parser, span_start1177, "EDB") + return result1178 end function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs1177 = String[] - cond1178 = match_lookahead_terminal(parser, "STRING", 0) - while cond1178 - item1179 = consume_terminal!(parser, "STRING") - push!(xs1177, item1179) - cond1178 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1180 = xs1177 + xs1179 = String[] + cond1180 = match_lookahead_terminal(parser, "STRING", 0) + while cond1180 + item1181 = consume_terminal!(parser, "STRING") + push!(xs1179, item1181) + cond1180 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1182 = xs1179 consume_literal!(parser, "]") - return strings1180 + return strings1182 end function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs1181 = Proto.var"#Type"[] - cond1182 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1182 - _t2023 = parse_type(parser) - item1183 = _t2023 - push!(xs1181, item1183) - cond1182 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1184 = xs1181 + xs1183 = Proto.var"#Type"[] + cond1184 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1184 + _t2027 = parse_type(parser) + item1185 = _t2027 + push!(xs1183, item1185) + cond1184 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1186 = xs1183 consume_literal!(parser, "]") - return types1184 + return types1186 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation - span_start1187 = span_start(parser) + span_start1189 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t2024 = parse_relation_id(parser) - relation_id1185 = _t2024 - _t2025 = parse_betree_info(parser) - betree_info1186 = _t2025 + _t2028 = parse_relation_id(parser) + relation_id1187 = _t2028 + _t2029 = parse_betree_info(parser) + betree_info1188 = _t2029 consume_literal!(parser, ")") - _t2026 = Proto.BeTreeRelation(name=relation_id1185, relation_info=betree_info1186) - result1188 = _t2026 - record_span!(parser, span_start1187, "BeTreeRelation") - return result1188 + _t2030 = Proto.BeTreeRelation(name=relation_id1187, relation_info=betree_info1188) + result1190 = _t2030 + record_span!(parser, span_start1189, "BeTreeRelation") + return result1190 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo - span_start1192 = span_start(parser) + span_start1194 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t2027 = parse_betree_info_key_types(parser) - betree_info_key_types1189 = _t2027 - _t2028 = parse_betree_info_value_types(parser) - betree_info_value_types1190 = _t2028 - _t2029 = parse_config_dict(parser) - config_dict1191 = _t2029 + _t2031 = parse_betree_info_key_types(parser) + betree_info_key_types1191 = _t2031 + _t2032 = parse_betree_info_value_types(parser) + betree_info_value_types1192 = _t2032 + _t2033 = parse_config_dict(parser) + config_dict1193 = _t2033 consume_literal!(parser, ")") - _t2030 = construct_betree_info(parser, betree_info_key_types1189, betree_info_value_types1190, config_dict1191) - result1193 = _t2030 - record_span!(parser, span_start1192, "BeTreeInfo") - return result1193 + _t2034 = construct_betree_info(parser, betree_info_key_types1191, betree_info_value_types1192, config_dict1193) + result1195 = _t2034 + record_span!(parser, span_start1194, "BeTreeInfo") + return result1195 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs1194 = Proto.var"#Type"[] - cond1195 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1195 - _t2031 = parse_type(parser) - item1196 = _t2031 - push!(xs1194, item1196) - cond1195 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1197 = xs1194 + xs1196 = Proto.var"#Type"[] + cond1197 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1197 + _t2035 = parse_type(parser) + item1198 = _t2035 + push!(xs1196, item1198) + cond1197 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1199 = xs1196 consume_literal!(parser, ")") - return types1197 + return types1199 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs1198 = Proto.var"#Type"[] - cond1199 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1199 - _t2032 = parse_type(parser) - item1200 = _t2032 - push!(xs1198, item1200) - cond1199 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1201 = xs1198 + xs1200 = Proto.var"#Type"[] + cond1201 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1201 + _t2036 = parse_type(parser) + item1202 = _t2036 + push!(xs1200, item1202) + cond1201 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1203 = xs1200 consume_literal!(parser, ")") - return types1201 + return types1203 end function parse_csv_data(parser::ParserState)::Proto.CSVData - span_start1207 = span_start(parser) + span_start1209 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t2033 = parse_csvlocator(parser) - csvlocator1202 = _t2033 - _t2034 = parse_csv_config(parser) - csv_config1203 = _t2034 + _t2037 = parse_csvlocator(parser) + csvlocator1204 = _t2037 + _t2038 = parse_csv_config(parser) + csv_config1205 = _t2038 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "columns", 1)) - _t2036 = parse_gnf_columns(parser) - _t2035 = _t2036 + _t2040 = parse_gnf_columns(parser) + _t2039 = _t2040 else - _t2035 = nothing + _t2039 = nothing end - gnf_columns1204 = _t2035 + gnf_columns1206 = _t2039 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "relations", 1)) - _t2038 = parse_target_relations(parser) - _t2037 = _t2038 + _t2042 = parse_target_relations(parser) + _t2041 = _t2042 else - _t2037 = nothing + _t2041 = nothing end - target_relations1205 = _t2037 - _t2039 = parse_csv_asof(parser) - csv_asof1206 = _t2039 + target_relations1207 = _t2041 + _t2043 = parse_csv_asof(parser) + csv_asof1208 = _t2043 consume_literal!(parser, ")") - _t2040 = construct_csv_data(parser, csvlocator1202, csv_config1203, gnf_columns1204, target_relations1205, csv_asof1206) - result1208 = _t2040 - record_span!(parser, span_start1207, "CSVData") - return result1208 + _t2044 = construct_csv_data(parser, csvlocator1204, csv_config1205, gnf_columns1206, target_relations1207, csv_asof1208) + result1210 = _t2044 + record_span!(parser, span_start1209, "CSVData") + return result1210 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator - span_start1211 = span_start(parser) + span_start1213 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t2042 = parse_csv_locator_paths(parser) - _t2041 = _t2042 + _t2046 = parse_csv_locator_paths(parser) + _t2045 = _t2046 else - _t2041 = nothing + _t2045 = nothing end - csv_locator_paths1209 = _t2041 + csv_locator_paths1211 = _t2045 if match_lookahead_literal(parser, "(", 0) - _t2044 = parse_csv_locator_inline_data(parser) - _t2043 = _t2044 + _t2048 = parse_csv_locator_inline_data(parser) + _t2047 = _t2048 else - _t2043 = nothing + _t2047 = nothing end - csv_locator_inline_data1210 = _t2043 + csv_locator_inline_data1212 = _t2047 consume_literal!(parser, ")") - _t2045 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1209) ? csv_locator_paths1209 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1210) ? csv_locator_inline_data1210 : ""))) - result1212 = _t2045 - record_span!(parser, span_start1211, "CSVLocator") - return result1212 + _t2049 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1211) ? csv_locator_paths1211 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1212) ? csv_locator_inline_data1212 : ""))) + result1214 = _t2049 + record_span!(parser, span_start1213, "CSVLocator") + return result1214 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs1213 = String[] - cond1214 = match_lookahead_terminal(parser, "STRING", 0) - while cond1214 - item1215 = consume_terminal!(parser, "STRING") - push!(xs1213, item1215) - cond1214 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1216 = xs1213 + xs1215 = String[] + cond1216 = match_lookahead_terminal(parser, "STRING", 0) + while cond1216 + item1217 = consume_terminal!(parser, "STRING") + push!(xs1215, item1217) + cond1216 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1218 = xs1215 consume_literal!(parser, ")") - return strings1216 + return strings1218 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - formatted_string1217 = consume_terminal!(parser, "STRING") + formatted_string1219 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return formatted_string1217 + return formatted_string1219 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig - span_start1220 = span_start(parser) + span_start1222 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t2046 = parse_config_dict(parser) - config_dict1218 = _t2046 + _t2050 = parse_config_dict(parser) + config_dict1220 = _t2050 if match_lookahead_literal(parser, "(", 0) - _t2048 = parse__storage_integration(parser) - _t2047 = _t2048 + _t2052 = parse__storage_integration(parser) + _t2051 = _t2052 else - _t2047 = nothing + _t2051 = nothing end - _storage_integration1219 = _t2047 + _storage_integration1221 = _t2051 consume_literal!(parser, ")") - _t2049 = construct_csv_config(parser, config_dict1218, _storage_integration1219) - result1221 = _t2049 - record_span!(parser, span_start1220, "CSVConfig") - return result1221 + _t2053 = construct_csv_config(parser, config_dict1220, _storage_integration1221) + result1223 = _t2053 + record_span!(parser, span_start1222, "CSVConfig") + return result1223 end function parse__storage_integration(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "(") consume_literal!(parser, "storage_integration") - _t2050 = parse_config_dict(parser) - config_dict1222 = _t2050 + _t2054 = parse_config_dict(parser) + config_dict1224 = _t2054 consume_literal!(parser, ")") - return config_dict1222 + return config_dict1224 end function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1223 = Proto.GNFColumn[] - cond1224 = match_lookahead_literal(parser, "(", 0) - while cond1224 - _t2051 = parse_gnf_column(parser) - item1225 = _t2051 - push!(xs1223, item1225) - cond1224 = match_lookahead_literal(parser, "(", 0) - end - gnf_columns1226 = xs1223 + xs1225 = Proto.GNFColumn[] + cond1226 = match_lookahead_literal(parser, "(", 0) + while cond1226 + _t2055 = parse_gnf_column(parser) + item1227 = _t2055 + push!(xs1225, item1227) + cond1226 = match_lookahead_literal(parser, "(", 0) + end + gnf_columns1228 = xs1225 consume_literal!(parser, ")") - return gnf_columns1226 + return gnf_columns1228 end function parse_gnf_column(parser::ParserState)::Proto.GNFColumn - span_start1233 = span_start(parser) + span_start1235 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - _t2052 = parse_gnf_column_path(parser) - gnf_column_path1227 = _t2052 + _t2056 = parse_gnf_column_path(parser) + gnf_column_path1229 = _t2056 if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - _t2054 = parse_relation_id(parser) - _t2053 = _t2054 + _t2058 = parse_relation_id(parser) + _t2057 = _t2058 else - _t2053 = nothing + _t2057 = nothing end - relation_id1228 = _t2053 + relation_id1230 = _t2057 consume_literal!(parser, "[") - xs1229 = Proto.var"#Type"[] - cond1230 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1230 - _t2055 = parse_type(parser) - item1231 = _t2055 - push!(xs1229, item1231) - cond1230 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1232 = xs1229 + xs1231 = Proto.var"#Type"[] + cond1232 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1232 + _t2059 = parse_type(parser) + item1233 = _t2059 + push!(xs1231, item1233) + cond1232 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1234 = xs1231 consume_literal!(parser, "]") consume_literal!(parser, ")") - _t2056 = Proto.GNFColumn(column_path=gnf_column_path1227, target_id=relation_id1228, types=types1232) - result1234 = _t2056 - record_span!(parser, span_start1233, "GNFColumn") - return result1234 + _t2060 = Proto.GNFColumn(column_path=gnf_column_path1229, target_id=relation_id1230, types=types1234) + result1236 = _t2060 + record_span!(parser, span_start1235, "GNFColumn") + return result1236 end function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t2057 = 1 + _t2061 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t2058 = 0 + _t2062 = 0 else - _t2058 = -1 + _t2062 = -1 end - _t2057 = _t2058 + _t2061 = _t2062 end - prediction1235 = _t2057 - if prediction1235 == 1 + prediction1237 = _t2061 + if prediction1237 == 1 consume_literal!(parser, "[") - xs1237 = String[] - cond1238 = match_lookahead_terminal(parser, "STRING", 0) - while cond1238 - item1239 = consume_terminal!(parser, "STRING") - push!(xs1237, item1239) - cond1238 = match_lookahead_terminal(parser, "STRING", 0) + xs1239 = String[] + cond1240 = match_lookahead_terminal(parser, "STRING", 0) + while cond1240 + item1241 = consume_terminal!(parser, "STRING") + push!(xs1239, item1241) + cond1240 = match_lookahead_terminal(parser, "STRING", 0) end - strings1240 = xs1237 + strings1242 = xs1239 consume_literal!(parser, "]") - _t2059 = strings1240 + _t2063 = strings1242 else - if prediction1235 == 0 - string1236 = consume_terminal!(parser, "STRING") - _t2060 = String[string1236] + if prediction1237 == 0 + string1238 = consume_terminal!(parser, "STRING") + _t2064 = String[string1238] else throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t2059 = _t2060 + _t2063 = _t2064 end - return _t2059 + return _t2063 end function parse_target_relations(parser::ParserState)::Proto.TargetRelations - span_start1243 = span_start(parser) + span_start1245 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relations") - _t2061 = parse_relation_keys(parser) - relation_keys1241 = _t2061 - _t2062 = parse_relation_body(parser) - relation_body1242 = _t2062 + _t2065 = parse_relation_keys(parser) + relation_keys1243 = _t2065 + _t2066 = parse_relation_body(parser) + relation_body1244 = _t2066 consume_literal!(parser, ")") - _t2063 = construct_relations(parser, relation_keys1241, relation_body1242) - result1244 = _t2063 - record_span!(parser, span_start1243, "TargetRelations") - return result1244 + _t2067 = construct_relations(parser, relation_keys1243, relation_body1244) + result1246 = _t2067 + record_span!(parser, span_start1245, "TargetRelations") + return result1246 end -function parse_relation_keys(parser::ParserState)::Vector{Proto.NamedColumn} - consume_literal!(parser, "(") - consume_literal!(parser, "keys") - xs1245 = Proto.NamedColumn[] - cond1246 = match_lookahead_literal(parser, "(", 0) - while cond1246 - _t2064 = parse_named_column(parser) - item1247 = _t2064 - push!(xs1245, item1247) - cond1246 = match_lookahead_literal(parser, "(", 0) - end - named_columns1248 = xs1245 - consume_literal!(parser, ")") - return named_columns1248 +function parse_relation_keys(parser::ParserState)::Tuple{Vector{Proto.NamedColumn}, Bool} + if match_lookahead_literal(parser, "(", 0) + if match_lookahead_literal(parser, "keys", 1) + if match_lookahead_literal(parser, ":", 2) + _t2070 = 1 + else + if match_lookahead_literal(parser, ")", 2) + _t2071 = 0 + else + if match_lookahead_literal(parser, "(", 2) + _t2072 = 0 + else + _t2072 = -1 + end + _t2071 = _t2072 + end + _t2070 = _t2071 + end + _t2069 = _t2070 + else + _t2069 = -1 + end + _t2068 = _t2069 + else + _t2068 = -1 + end + prediction1247 = _t2068 + if prediction1247 == 1 + consume_literal!(parser, "(") + consume_literal!(parser, "keys") + consume_literal!(parser, ":") + symbol1252 = consume_terminal!(parser, "SYMBOL") + consume_literal!(parser, ")") + _t2074 = construct_synthetic_keys(parser, symbol1252) + _t2073 = _t2074 + else + if prediction1247 == 0 + consume_literal!(parser, "(") + consume_literal!(parser, "keys") + xs1248 = Proto.NamedColumn[] + cond1249 = match_lookahead_literal(parser, "(", 0) + while cond1249 + _t2076 = parse_named_column(parser) + item1250 = _t2076 + push!(xs1248, item1250) + cond1249 = match_lookahead_literal(parser, "(", 0) + end + named_columns1251 = xs1248 + consume_literal!(parser, ")") + _t2075 = (named_columns1251, false,) + else + throw(ParseError("Unexpected token in relation_keys" * ": " * string(lookahead(parser, 0)))) + end + _t2073 = _t2075 + end + return _t2073 end function parse_named_column(parser::ParserState)::Proto.NamedColumn - span_start1251 = span_start(parser) + span_start1255 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1249 = consume_terminal!(parser, "STRING") - _t2065 = parse_type(parser) - type1250 = _t2065 + string1253 = consume_terminal!(parser, "STRING") + _t2077 = parse_type(parser) + type1254 = _t2077 consume_literal!(parser, ")") - _t2066 = Proto.NamedColumn(name=string1249, var"#type"=type1250) - result1252 = _t2066 - record_span!(parser, span_start1251, "NamedColumn") - return result1252 + _t2078 = Proto.NamedColumn(name=string1253, var"#type"=type1254) + result1256 = _t2078 + record_span!(parser, span_start1255, "NamedColumn") + return result1256 end function parse_relation_body(parser::ParserState)::Proto.TargetRelations - span_start1257 = span_start(parser) + span_start1261 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "relation", 1) - _t2068 = 0 + _t2080 = 0 else if match_lookahead_literal(parser, "inserts", 1) - _t2069 = 1 + _t2081 = 1 else - _t2069 = 0 + _t2081 = 0 end - _t2068 = _t2069 + _t2080 = _t2081 end - _t2067 = _t2068 + _t2079 = _t2080 else - _t2067 = 0 - end - prediction1253 = _t2067 - if prediction1253 == 1 - _t2071 = parse_cdc_inserts(parser) - cdc_inserts1255 = _t2071 - _t2072 = parse_cdc_deletes(parser) - cdc_deletes1256 = _t2072 - _t2073 = construct_cdc_relations(parser, cdc_inserts1255, cdc_deletes1256) - _t2070 = _t2073 + _t2079 = 0 + end + prediction1257 = _t2079 + if prediction1257 == 1 + _t2083 = parse_cdc_inserts(parser) + cdc_inserts1259 = _t2083 + _t2084 = parse_cdc_deletes(parser) + cdc_deletes1260 = _t2084 + _t2085 = construct_cdc_relations(parser, cdc_inserts1259, cdc_deletes1260) + _t2082 = _t2085 else - if prediction1253 == 0 - _t2075 = parse_non_cdc_relations(parser) - non_cdc_relations1254 = _t2075 - _t2076 = construct_non_cdc_relations(parser, non_cdc_relations1254) - _t2074 = _t2076 + if prediction1257 == 0 + _t2087 = parse_non_cdc_relations(parser) + non_cdc_relations1258 = _t2087 + _t2088 = construct_non_cdc_relations(parser, non_cdc_relations1258) + _t2086 = _t2088 else throw(ParseError("Unexpected token in relation_body" * ": " * string(lookahead(parser, 0)))) end - _t2070 = _t2074 + _t2082 = _t2086 end - result1258 = _t2070 - record_span!(parser, span_start1257, "TargetRelations") - return result1258 + result1262 = _t2082 + record_span!(parser, span_start1261, "TargetRelations") + return result1262 end function parse_non_cdc_relations(parser::ParserState)::Vector{Proto.TargetRelation} - xs1259 = Proto.TargetRelation[] - cond1260 = match_lookahead_literal(parser, "(", 0) - while cond1260 - _t2077 = parse_target_relation(parser) - item1261 = _t2077 - push!(xs1259, item1261) - cond1260 = match_lookahead_literal(parser, "(", 0) - end - return xs1259 -end - -function parse_target_relation(parser::ParserState)::Proto.TargetRelation - span_start1267 = span_start(parser) - consume_literal!(parser, "(") - consume_literal!(parser, "relation") - _t2078 = parse_relation_id(parser) - relation_id1262 = _t2078 - xs1263 = Proto.NamedColumn[] + xs1263 = Proto.TargetRelation[] cond1264 = match_lookahead_literal(parser, "(", 0) while cond1264 - _t2079 = parse_named_column(parser) - item1265 = _t2079 + _t2089 = parse_target_relation(parser) + item1265 = _t2089 push!(xs1263, item1265) cond1264 = match_lookahead_literal(parser, "(", 0) end - named_columns1266 = xs1263 - consume_literal!(parser, ")") - _t2080 = Proto.TargetRelation(target_id=relation_id1262, values=named_columns1266) - result1268 = _t2080 - record_span!(parser, span_start1267, "TargetRelation") - return result1268 + return xs1263 end -function parse_cdc_inserts(parser::ParserState)::Vector{Proto.TargetRelation} +function parse_target_relation(parser::ParserState)::Proto.TargetRelation + span_start1271 = span_start(parser) consume_literal!(parser, "(") - consume_literal!(parser, "inserts") - xs1269 = Proto.TargetRelation[] - cond1270 = match_lookahead_literal(parser, "(", 0) - while cond1270 - _t2081 = parse_target_relation(parser) - item1271 = _t2081 - push!(xs1269, item1271) - cond1270 = match_lookahead_literal(parser, "(", 0) - end - target_relations1272 = xs1269 + consume_literal!(parser, "relation") + _t2090 = parse_relation_id(parser) + relation_id1266 = _t2090 + xs1267 = Proto.NamedColumn[] + cond1268 = match_lookahead_literal(parser, "(", 0) + while cond1268 + _t2091 = parse_named_column(parser) + item1269 = _t2091 + push!(xs1267, item1269) + cond1268 = match_lookahead_literal(parser, "(", 0) + end + named_columns1270 = xs1267 consume_literal!(parser, ")") - return target_relations1272 + _t2092 = Proto.TargetRelation(target_id=relation_id1266, values=named_columns1270) + result1272 = _t2092 + record_span!(parser, span_start1271, "TargetRelation") + return result1272 end -function parse_cdc_deletes(parser::ParserState)::Vector{Proto.TargetRelation} +function parse_cdc_inserts(parser::ParserState)::Vector{Proto.TargetRelation} consume_literal!(parser, "(") - consume_literal!(parser, "deletes") + consume_literal!(parser, "inserts") xs1273 = Proto.TargetRelation[] cond1274 = match_lookahead_literal(parser, "(", 0) while cond1274 - _t2082 = parse_target_relation(parser) - item1275 = _t2082 + _t2093 = parse_target_relation(parser) + item1275 = _t2093 push!(xs1273, item1275) cond1274 = match_lookahead_literal(parser, "(", 0) end @@ -3931,710 +3966,726 @@ function parse_cdc_deletes(parser::ParserState)::Vector{Proto.TargetRelation} return target_relations1276 end +function parse_cdc_deletes(parser::ParserState)::Vector{Proto.TargetRelation} + consume_literal!(parser, "(") + consume_literal!(parser, "deletes") + xs1277 = Proto.TargetRelation[] + cond1278 = match_lookahead_literal(parser, "(", 0) + while cond1278 + _t2094 = parse_target_relation(parser) + item1279 = _t2094 + push!(xs1277, item1279) + cond1278 = match_lookahead_literal(parser, "(", 0) + end + target_relations1280 = xs1277 + consume_literal!(parser, ")") + return target_relations1280 +end + function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string1277 = consume_terminal!(parser, "STRING") + string1281 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1277 + return string1281 end function parse_iceberg_data(parser::ParserState)::Proto.IcebergData - span_start1284 = span_start(parser) + span_start1288 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_data") - _t2083 = parse_iceberg_locator(parser) - iceberg_locator1278 = _t2083 - _t2084 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1279 = _t2084 - _t2085 = parse_gnf_columns(parser) - gnf_columns1280 = _t2085 + _t2095 = parse_iceberg_locator(parser) + iceberg_locator1282 = _t2095 + _t2096 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1283 = _t2096 + _t2097 = parse_gnf_columns(parser) + gnf_columns1284 = _t2097 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "from_snapshot", 1)) - _t2087 = parse_iceberg_from_snapshot(parser) - _t2086 = _t2087 + _t2099 = parse_iceberg_from_snapshot(parser) + _t2098 = _t2099 else - _t2086 = nothing + _t2098 = nothing end - iceberg_from_snapshot1281 = _t2086 + iceberg_from_snapshot1285 = _t2098 if match_lookahead_literal(parser, "(", 0) - _t2089 = parse_iceberg_to_snapshot(parser) - _t2088 = _t2089 + _t2101 = parse_iceberg_to_snapshot(parser) + _t2100 = _t2101 else - _t2088 = nothing + _t2100 = nothing end - iceberg_to_snapshot1282 = _t2088 - _t2090 = parse_boolean_value(parser) - boolean_value1283 = _t2090 + iceberg_to_snapshot1286 = _t2100 + _t2102 = parse_boolean_value(parser) + boolean_value1287 = _t2102 consume_literal!(parser, ")") - _t2091 = construct_iceberg_data(parser, iceberg_locator1278, iceberg_catalog_config1279, gnf_columns1280, iceberg_from_snapshot1281, iceberg_to_snapshot1282, boolean_value1283) - result1285 = _t2091 - record_span!(parser, span_start1284, "IcebergData") - return result1285 + _t2103 = construct_iceberg_data(parser, iceberg_locator1282, iceberg_catalog_config1283, gnf_columns1284, iceberg_from_snapshot1285, iceberg_to_snapshot1286, boolean_value1287) + result1289 = _t2103 + record_span!(parser, span_start1288, "IcebergData") + return result1289 end function parse_iceberg_locator(parser::ParserState)::Proto.IcebergLocator - span_start1289 = span_start(parser) + span_start1293 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_locator") - _t2092 = parse_iceberg_locator_table_name(parser) - iceberg_locator_table_name1286 = _t2092 - _t2093 = parse_iceberg_locator_namespace(parser) - iceberg_locator_namespace1287 = _t2093 - _t2094 = parse_iceberg_locator_warehouse(parser) - iceberg_locator_warehouse1288 = _t2094 + _t2104 = parse_iceberg_locator_table_name(parser) + iceberg_locator_table_name1290 = _t2104 + _t2105 = parse_iceberg_locator_namespace(parser) + iceberg_locator_namespace1291 = _t2105 + _t2106 = parse_iceberg_locator_warehouse(parser) + iceberg_locator_warehouse1292 = _t2106 consume_literal!(parser, ")") - _t2095 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1286, namespace=iceberg_locator_namespace1287, warehouse=iceberg_locator_warehouse1288) - result1290 = _t2095 - record_span!(parser, span_start1289, "IcebergLocator") - return result1290 + _t2107 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1290, namespace=iceberg_locator_namespace1291, warehouse=iceberg_locator_warehouse1292) + result1294 = _t2107 + record_span!(parser, span_start1293, "IcebergLocator") + return result1294 end function parse_iceberg_locator_table_name(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "table_name") - string1291 = consume_terminal!(parser, "STRING") + string1295 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1291 + return string1295 end function parse_iceberg_locator_namespace(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "namespace") - xs1292 = String[] - cond1293 = match_lookahead_terminal(parser, "STRING", 0) - while cond1293 - item1294 = consume_terminal!(parser, "STRING") - push!(xs1292, item1294) - cond1293 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1295 = xs1292 + xs1296 = String[] + cond1297 = match_lookahead_terminal(parser, "STRING", 0) + while cond1297 + item1298 = consume_terminal!(parser, "STRING") + push!(xs1296, item1298) + cond1297 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1299 = xs1296 consume_literal!(parser, ")") - return strings1295 + return strings1299 end function parse_iceberg_locator_warehouse(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "warehouse") - string1296 = consume_terminal!(parser, "STRING") + string1300 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1296 + return string1300 end function parse_iceberg_catalog_config(parser::ParserState)::Proto.IcebergCatalogConfig - span_start1301 = span_start(parser) + span_start1305 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_catalog_config") - _t2096 = parse_iceberg_catalog_uri(parser) - iceberg_catalog_uri1297 = _t2096 + _t2108 = parse_iceberg_catalog_uri(parser) + iceberg_catalog_uri1301 = _t2108 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "scope", 1)) - _t2098 = parse_iceberg_catalog_config_scope(parser) - _t2097 = _t2098 + _t2110 = parse_iceberg_catalog_config_scope(parser) + _t2109 = _t2110 else - _t2097 = nothing + _t2109 = nothing end - iceberg_catalog_config_scope1298 = _t2097 - _t2099 = parse_iceberg_properties(parser) - iceberg_properties1299 = _t2099 - _t2100 = parse_iceberg_auth_properties(parser) - iceberg_auth_properties1300 = _t2100 + iceberg_catalog_config_scope1302 = _t2109 + _t2111 = parse_iceberg_properties(parser) + iceberg_properties1303 = _t2111 + _t2112 = parse_iceberg_auth_properties(parser) + iceberg_auth_properties1304 = _t2112 consume_literal!(parser, ")") - _t2101 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1297, iceberg_catalog_config_scope1298, iceberg_properties1299, iceberg_auth_properties1300) - result1302 = _t2101 - record_span!(parser, span_start1301, "IcebergCatalogConfig") - return result1302 + _t2113 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1301, iceberg_catalog_config_scope1302, iceberg_properties1303, iceberg_auth_properties1304) + result1306 = _t2113 + record_span!(parser, span_start1305, "IcebergCatalogConfig") + return result1306 end function parse_iceberg_catalog_uri(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "catalog_uri") - string1303 = consume_terminal!(parser, "STRING") + string1307 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1303 + return string1307 end function parse_iceberg_catalog_config_scope(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "scope") - string1304 = consume_terminal!(parser, "STRING") + string1308 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1304 + return string1308 end function parse_iceberg_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "properties") - xs1305 = Tuple{String, String}[] - cond1306 = match_lookahead_literal(parser, "(", 0) - while cond1306 - _t2102 = parse_iceberg_property_entry(parser) - item1307 = _t2102 - push!(xs1305, item1307) - cond1306 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1308 = xs1305 + xs1309 = Tuple{String, String}[] + cond1310 = match_lookahead_literal(parser, "(", 0) + while cond1310 + _t2114 = parse_iceberg_property_entry(parser) + item1311 = _t2114 + push!(xs1309, item1311) + cond1310 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1312 = xs1309 consume_literal!(parser, ")") - return iceberg_property_entrys1308 + return iceberg_property_entrys1312 end function parse_iceberg_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1309 = consume_terminal!(parser, "STRING") - string_31310 = consume_terminal!(parser, "STRING") + string1313 = consume_terminal!(parser, "STRING") + string_31314 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1309, string_31310,) + return (string1313, string_31314,) end function parse_iceberg_auth_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "auth_properties") - xs1311 = Tuple{String, String}[] - cond1312 = match_lookahead_literal(parser, "(", 0) - while cond1312 - _t2103 = parse_iceberg_masked_property_entry(parser) - item1313 = _t2103 - push!(xs1311, item1313) - cond1312 = match_lookahead_literal(parser, "(", 0) - end - iceberg_masked_property_entrys1314 = xs1311 + xs1315 = Tuple{String, String}[] + cond1316 = match_lookahead_literal(parser, "(", 0) + while cond1316 + _t2115 = parse_iceberg_masked_property_entry(parser) + item1317 = _t2115 + push!(xs1315, item1317) + cond1316 = match_lookahead_literal(parser, "(", 0) + end + iceberg_masked_property_entrys1318 = xs1315 consume_literal!(parser, ")") - return iceberg_masked_property_entrys1314 + return iceberg_masked_property_entrys1318 end function parse_iceberg_masked_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1315 = consume_terminal!(parser, "STRING") - string_31316 = consume_terminal!(parser, "STRING") + string1319 = consume_terminal!(parser, "STRING") + string_31320 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1315, string_31316,) + return (string1319, string_31320,) end function parse_iceberg_from_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "from_snapshot") - string1317 = consume_terminal!(parser, "STRING") + string1321 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1317 + return string1321 end function parse_iceberg_to_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "to_snapshot") - string1318 = consume_terminal!(parser, "STRING") + string1322 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1318 + return string1322 end function parse_undefine(parser::ParserState)::Proto.Undefine - span_start1320 = span_start(parser) + span_start1324 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t2104 = parse_fragment_id(parser) - fragment_id1319 = _t2104 + _t2116 = parse_fragment_id(parser) + fragment_id1323 = _t2116 consume_literal!(parser, ")") - _t2105 = Proto.Undefine(fragment_id=fragment_id1319) - result1321 = _t2105 - record_span!(parser, span_start1320, "Undefine") - return result1321 + _t2117 = Proto.Undefine(fragment_id=fragment_id1323) + result1325 = _t2117 + record_span!(parser, span_start1324, "Undefine") + return result1325 end function parse_context(parser::ParserState)::Proto.Context - span_start1326 = span_start(parser) + span_start1330 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "context") - xs1322 = Proto.RelationId[] - cond1323 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1323 - _t2106 = parse_relation_id(parser) - item1324 = _t2106 - push!(xs1322, item1324) - cond1323 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1325 = xs1322 + xs1326 = Proto.RelationId[] + cond1327 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1327 + _t2118 = parse_relation_id(parser) + item1328 = _t2118 + push!(xs1326, item1328) + cond1327 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1329 = xs1326 consume_literal!(parser, ")") - _t2107 = Proto.Context(relations=relation_ids1325) - result1327 = _t2107 - record_span!(parser, span_start1326, "Context") - return result1327 + _t2119 = Proto.Context(relations=relation_ids1329) + result1331 = _t2119 + record_span!(parser, span_start1330, "Context") + return result1331 end function parse_snapshot(parser::ParserState)::Proto.Snapshot - span_start1333 = span_start(parser) + span_start1337 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t2108 = parse_edb_path(parser) - edb_path1328 = _t2108 - xs1329 = Proto.SnapshotMapping[] - cond1330 = match_lookahead_literal(parser, "[", 0) - while cond1330 - _t2109 = parse_snapshot_mapping(parser) - item1331 = _t2109 - push!(xs1329, item1331) - cond1330 = match_lookahead_literal(parser, "[", 0) - end - snapshot_mappings1332 = xs1329 + _t2120 = parse_edb_path(parser) + edb_path1332 = _t2120 + xs1333 = Proto.SnapshotMapping[] + cond1334 = match_lookahead_literal(parser, "[", 0) + while cond1334 + _t2121 = parse_snapshot_mapping(parser) + item1335 = _t2121 + push!(xs1333, item1335) + cond1334 = match_lookahead_literal(parser, "[", 0) + end + snapshot_mappings1336 = xs1333 consume_literal!(parser, ")") - _t2110 = Proto.Snapshot(mappings=snapshot_mappings1332, prefix=edb_path1328) - result1334 = _t2110 - record_span!(parser, span_start1333, "Snapshot") - return result1334 + _t2122 = Proto.Snapshot(mappings=snapshot_mappings1336, prefix=edb_path1332) + result1338 = _t2122 + record_span!(parser, span_start1337, "Snapshot") + return result1338 end function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping - span_start1337 = span_start(parser) - _t2111 = parse_edb_path(parser) - edb_path1335 = _t2111 - _t2112 = parse_relation_id(parser) - relation_id1336 = _t2112 - _t2113 = Proto.SnapshotMapping(destination_path=edb_path1335, source_relation=relation_id1336) - result1338 = _t2113 - record_span!(parser, span_start1337, "SnapshotMapping") - return result1338 + span_start1341 = span_start(parser) + _t2123 = parse_edb_path(parser) + edb_path1339 = _t2123 + _t2124 = parse_relation_id(parser) + relation_id1340 = _t2124 + _t2125 = Proto.SnapshotMapping(destination_path=edb_path1339, source_relation=relation_id1340) + result1342 = _t2125 + record_span!(parser, span_start1341, "SnapshotMapping") + return result1342 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs1339 = Proto.Read[] - cond1340 = match_lookahead_literal(parser, "(", 0) - while cond1340 - _t2114 = parse_read(parser) - item1341 = _t2114 - push!(xs1339, item1341) - cond1340 = match_lookahead_literal(parser, "(", 0) - end - reads1342 = xs1339 + xs1343 = Proto.Read[] + cond1344 = match_lookahead_literal(parser, "(", 0) + while cond1344 + _t2126 = parse_read(parser) + item1345 = _t2126 + push!(xs1343, item1345) + cond1344 = match_lookahead_literal(parser, "(", 0) + end + reads1346 = xs1343 consume_literal!(parser, ")") - return reads1342 + return reads1346 end function parse_read(parser::ParserState)::Proto.Read - span_start1349 = span_start(parser) + span_start1353 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t2116 = 2 + _t2128 = 2 else if match_lookahead_literal(parser, "output", 1) - _t2117 = 1 + _t2129 = 1 else if match_lookahead_literal(parser, "export_iceberg", 1) - _t2118 = 4 + _t2130 = 4 else if match_lookahead_literal(parser, "export", 1) - _t2119 = 4 + _t2131 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t2120 = 0 + _t2132 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t2121 = 3 + _t2133 = 3 else - _t2121 = -1 + _t2133 = -1 end - _t2120 = _t2121 + _t2132 = _t2133 end - _t2119 = _t2120 + _t2131 = _t2132 end - _t2118 = _t2119 + _t2130 = _t2131 end - _t2117 = _t2118 + _t2129 = _t2130 end - _t2116 = _t2117 + _t2128 = _t2129 end - _t2115 = _t2116 + _t2127 = _t2128 else - _t2115 = -1 - end - prediction1343 = _t2115 - if prediction1343 == 4 - _t2123 = parse_export(parser) - export1348 = _t2123 - _t2124 = Proto.Read(read_type=OneOf(:var"#export", export1348)) - _t2122 = _t2124 + _t2127 = -1 + end + prediction1347 = _t2127 + if prediction1347 == 4 + _t2135 = parse_export(parser) + export1352 = _t2135 + _t2136 = Proto.Read(read_type=OneOf(:var"#export", export1352)) + _t2134 = _t2136 else - if prediction1343 == 3 - _t2126 = parse_abort(parser) - abort1347 = _t2126 - _t2127 = Proto.Read(read_type=OneOf(:abort, abort1347)) - _t2125 = _t2127 + if prediction1347 == 3 + _t2138 = parse_abort(parser) + abort1351 = _t2138 + _t2139 = Proto.Read(read_type=OneOf(:abort, abort1351)) + _t2137 = _t2139 else - if prediction1343 == 2 - _t2129 = parse_what_if(parser) - what_if1346 = _t2129 - _t2130 = Proto.Read(read_type=OneOf(:what_if, what_if1346)) - _t2128 = _t2130 + if prediction1347 == 2 + _t2141 = parse_what_if(parser) + what_if1350 = _t2141 + _t2142 = Proto.Read(read_type=OneOf(:what_if, what_if1350)) + _t2140 = _t2142 else - if prediction1343 == 1 - _t2132 = parse_output(parser) - output1345 = _t2132 - _t2133 = Proto.Read(read_type=OneOf(:output, output1345)) - _t2131 = _t2133 + if prediction1347 == 1 + _t2144 = parse_output(parser) + output1349 = _t2144 + _t2145 = Proto.Read(read_type=OneOf(:output, output1349)) + _t2143 = _t2145 else - if prediction1343 == 0 - _t2135 = parse_demand(parser) - demand1344 = _t2135 - _t2136 = Proto.Read(read_type=OneOf(:demand, demand1344)) - _t2134 = _t2136 + if prediction1347 == 0 + _t2147 = parse_demand(parser) + demand1348 = _t2147 + _t2148 = Proto.Read(read_type=OneOf(:demand, demand1348)) + _t2146 = _t2148 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t2131 = _t2134 + _t2143 = _t2146 end - _t2128 = _t2131 + _t2140 = _t2143 end - _t2125 = _t2128 + _t2137 = _t2140 end - _t2122 = _t2125 + _t2134 = _t2137 end - result1350 = _t2122 - record_span!(parser, span_start1349, "Read") - return result1350 + result1354 = _t2134 + record_span!(parser, span_start1353, "Read") + return result1354 end function parse_demand(parser::ParserState)::Proto.Demand - span_start1352 = span_start(parser) + span_start1356 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t2137 = parse_relation_id(parser) - relation_id1351 = _t2137 + _t2149 = parse_relation_id(parser) + relation_id1355 = _t2149 consume_literal!(parser, ")") - _t2138 = Proto.Demand(relation_id=relation_id1351) - result1353 = _t2138 - record_span!(parser, span_start1352, "Demand") - return result1353 + _t2150 = Proto.Demand(relation_id=relation_id1355) + result1357 = _t2150 + record_span!(parser, span_start1356, "Demand") + return result1357 end function parse_output(parser::ParserState)::Proto.Output - span_start1356 = span_start(parser) + span_start1360 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "output") - _t2139 = parse_name(parser) - name1354 = _t2139 - _t2140 = parse_relation_id(parser) - relation_id1355 = _t2140 + _t2151 = parse_name(parser) + name1358 = _t2151 + _t2152 = parse_relation_id(parser) + relation_id1359 = _t2152 consume_literal!(parser, ")") - _t2141 = Proto.Output(name=name1354, relation_id=relation_id1355) - result1357 = _t2141 - record_span!(parser, span_start1356, "Output") - return result1357 + _t2153 = Proto.Output(name=name1358, relation_id=relation_id1359) + result1361 = _t2153 + record_span!(parser, span_start1360, "Output") + return result1361 end function parse_what_if(parser::ParserState)::Proto.WhatIf - span_start1360 = span_start(parser) + span_start1364 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t2142 = parse_name(parser) - name1358 = _t2142 - _t2143 = parse_epoch(parser) - epoch1359 = _t2143 + _t2154 = parse_name(parser) + name1362 = _t2154 + _t2155 = parse_epoch(parser) + epoch1363 = _t2155 consume_literal!(parser, ")") - _t2144 = Proto.WhatIf(branch=name1358, epoch=epoch1359) - result1361 = _t2144 - record_span!(parser, span_start1360, "WhatIf") - return result1361 + _t2156 = Proto.WhatIf(branch=name1362, epoch=epoch1363) + result1365 = _t2156 + record_span!(parser, span_start1364, "WhatIf") + return result1365 end function parse_abort(parser::ParserState)::Proto.Abort - span_start1364 = span_start(parser) + span_start1368 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t2146 = parse_name(parser) - _t2145 = _t2146 + _t2158 = parse_name(parser) + _t2157 = _t2158 else - _t2145 = nothing + _t2157 = nothing end - name1362 = _t2145 - _t2147 = parse_relation_id(parser) - relation_id1363 = _t2147 + name1366 = _t2157 + _t2159 = parse_relation_id(parser) + relation_id1367 = _t2159 consume_literal!(parser, ")") - _t2148 = Proto.Abort(name=(!isnothing(name1362) ? name1362 : "abort"), relation_id=relation_id1363) - result1365 = _t2148 - record_span!(parser, span_start1364, "Abort") - return result1365 + _t2160 = Proto.Abort(name=(!isnothing(name1366) ? name1366 : "abort"), relation_id=relation_id1367) + result1369 = _t2160 + record_span!(parser, span_start1368, "Abort") + return result1369 end function parse_export(parser::ParserState)::Proto.Export - span_start1369 = span_start(parser) + span_start1373 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_iceberg", 1) - _t2150 = 1 + _t2162 = 1 else if match_lookahead_literal(parser, "export", 1) - _t2151 = 0 + _t2163 = 0 else - _t2151 = -1 + _t2163 = -1 end - _t2150 = _t2151 + _t2162 = _t2163 end - _t2149 = _t2150 + _t2161 = _t2162 else - _t2149 = -1 + _t2161 = -1 end - prediction1366 = _t2149 - if prediction1366 == 1 + prediction1370 = _t2161 + if prediction1370 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg") - _t2153 = parse_export_iceberg_config(parser) - export_iceberg_config1368 = _t2153 + _t2165 = parse_export_iceberg_config(parser) + export_iceberg_config1372 = _t2165 consume_literal!(parser, ")") - _t2154 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1368)) - _t2152 = _t2154 + _t2166 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1372)) + _t2164 = _t2166 else - if prediction1366 == 0 + if prediction1370 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export") - _t2156 = parse_export_csv_config(parser) - export_csv_config1367 = _t2156 + _t2168 = parse_export_csv_config(parser) + export_csv_config1371 = _t2168 consume_literal!(parser, ")") - _t2157 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1367)) - _t2155 = _t2157 + _t2169 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1371)) + _t2167 = _t2169 else throw(ParseError("Unexpected token in export" * ": " * string(lookahead(parser, 0)))) end - _t2152 = _t2155 + _t2164 = _t2167 end - result1370 = _t2152 - record_span!(parser, span_start1369, "Export") - return result1370 + result1374 = _t2164 + record_span!(parser, span_start1373, "Export") + return result1374 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig - span_start1378 = span_start(parser) + span_start1382 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_csv_config_v2", 1) - _t2159 = 0 + _t2171 = 0 else if match_lookahead_literal(parser, "export_csv_config", 1) - _t2160 = 1 + _t2172 = 1 else - _t2160 = -1 + _t2172 = -1 end - _t2159 = _t2160 + _t2171 = _t2172 end - _t2158 = _t2159 + _t2170 = _t2171 else - _t2158 = -1 + _t2170 = -1 end - prediction1371 = _t2158 - if prediction1371 == 1 + prediction1375 = _t2170 + if prediction1375 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t2162 = parse_export_csv_path(parser) - export_csv_path1375 = _t2162 - _t2163 = parse_export_csv_columns_list(parser) - export_csv_columns_list1376 = _t2163 - _t2164 = parse_config_dict(parser) - config_dict1377 = _t2164 + _t2174 = parse_export_csv_path(parser) + export_csv_path1379 = _t2174 + _t2175 = parse_export_csv_columns_list(parser) + export_csv_columns_list1380 = _t2175 + _t2176 = parse_config_dict(parser) + config_dict1381 = _t2176 consume_literal!(parser, ")") - _t2165 = construct_export_csv_config(parser, export_csv_path1375, export_csv_columns_list1376, config_dict1377) - _t2161 = _t2165 + _t2177 = construct_export_csv_config(parser, export_csv_path1379, export_csv_columns_list1380, config_dict1381) + _t2173 = _t2177 else - if prediction1371 == 0 + if prediction1375 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config_v2") - _t2167 = parse_export_csv_output_location(parser) - export_csv_output_location1372 = _t2167 - _t2168 = parse_export_csv_source(parser) - export_csv_source1373 = _t2168 - _t2169 = parse_csv_config(parser) - csv_config1374 = _t2169 + _t2179 = parse_export_csv_output_location(parser) + export_csv_output_location1376 = _t2179 + _t2180 = parse_export_csv_source(parser) + export_csv_source1377 = _t2180 + _t2181 = parse_csv_config(parser) + csv_config1378 = _t2181 consume_literal!(parser, ")") - _t2170 = construct_export_csv_config_with_location(parser, export_csv_output_location1372, export_csv_source1373, csv_config1374) - _t2166 = _t2170 + _t2182 = construct_export_csv_config_with_location(parser, export_csv_output_location1376, export_csv_source1377, csv_config1378) + _t2178 = _t2182 else throw(ParseError("Unexpected token in export_csv_config" * ": " * string(lookahead(parser, 0)))) end - _t2161 = _t2166 + _t2173 = _t2178 end - result1379 = _t2161 - record_span!(parser, span_start1378, "ExportCSVConfig") - return result1379 + result1383 = _t2173 + record_span!(parser, span_start1382, "ExportCSVConfig") + return result1383 end function parse_export_csv_output_location(parser::ParserState)::Tuple{String, String} if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "transaction_output_name", 1) - _t2172 = 1 + _t2184 = 1 else if match_lookahead_literal(parser, "path", 1) - _t2173 = 0 + _t2185 = 0 else - _t2173 = -1 + _t2185 = -1 end - _t2172 = _t2173 + _t2184 = _t2185 end - _t2171 = _t2172 + _t2183 = _t2184 else - _t2171 = -1 + _t2183 = -1 end - prediction1380 = _t2171 - if prediction1380 == 1 + prediction1384 = _t2183 + if prediction1384 == 1 consume_literal!(parser, "(") consume_literal!(parser, "transaction_output_name") - _t2175 = parse_name(parser) - name1382 = _t2175 + _t2187 = parse_name(parser) + name1386 = _t2187 consume_literal!(parser, ")") - _t2174 = ("", name1382,) + _t2186 = ("", name1386,) else - if prediction1380 == 0 + if prediction1384 == 0 consume_literal!(parser, "(") consume_literal!(parser, "path") - string1381 = consume_terminal!(parser, "STRING") + string1385 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - _t2176 = (string1381, "",) + _t2188 = (string1385, "",) else throw(ParseError("Unexpected token in export_csv_output_location" * ": " * string(lookahead(parser, 0)))) end - _t2174 = _t2176 + _t2186 = _t2188 end - return _t2174 + return _t2186 end function parse_export_csv_source(parser::ParserState)::Proto.ExportCSVSource - span_start1389 = span_start(parser) + span_start1393 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "table_def", 1) - _t2178 = 1 + _t2190 = 1 else if match_lookahead_literal(parser, "gnf_columns", 1) - _t2179 = 0 + _t2191 = 0 else - _t2179 = -1 + _t2191 = -1 end - _t2178 = _t2179 + _t2190 = _t2191 end - _t2177 = _t2178 + _t2189 = _t2190 else - _t2177 = -1 + _t2189 = -1 end - prediction1383 = _t2177 - if prediction1383 == 1 + prediction1387 = _t2189 + if prediction1387 == 1 consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2181 = parse_relation_id(parser) - relation_id1388 = _t2181 + _t2193 = parse_relation_id(parser) + relation_id1392 = _t2193 consume_literal!(parser, ")") - _t2182 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1388)) - _t2180 = _t2182 + _t2194 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1392)) + _t2192 = _t2194 else - if prediction1383 == 0 + if prediction1387 == 0 consume_literal!(parser, "(") consume_literal!(parser, "gnf_columns") - xs1384 = Proto.ExportCSVColumn[] - cond1385 = match_lookahead_literal(parser, "(", 0) - while cond1385 - _t2184 = parse_export_csv_column(parser) - item1386 = _t2184 - push!(xs1384, item1386) - cond1385 = match_lookahead_literal(parser, "(", 0) + xs1388 = Proto.ExportCSVColumn[] + cond1389 = match_lookahead_literal(parser, "(", 0) + while cond1389 + _t2196 = parse_export_csv_column(parser) + item1390 = _t2196 + push!(xs1388, item1390) + cond1389 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1387 = xs1384 + export_csv_columns1391 = xs1388 consume_literal!(parser, ")") - _t2185 = Proto.ExportCSVColumns(columns=export_csv_columns1387) - _t2186 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2185)) - _t2183 = _t2186 + _t2197 = Proto.ExportCSVColumns(columns=export_csv_columns1391) + _t2198 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2197)) + _t2195 = _t2198 else throw(ParseError("Unexpected token in export_csv_source" * ": " * string(lookahead(parser, 0)))) end - _t2180 = _t2183 + _t2192 = _t2195 end - result1390 = _t2180 - record_span!(parser, span_start1389, "ExportCSVSource") - return result1390 + result1394 = _t2192 + record_span!(parser, span_start1393, "ExportCSVSource") + return result1394 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn - span_start1393 = span_start(parser) + span_start1397 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1391 = consume_terminal!(parser, "STRING") - _t2187 = parse_relation_id(parser) - relation_id1392 = _t2187 + string1395 = consume_terminal!(parser, "STRING") + _t2199 = parse_relation_id(parser) + relation_id1396 = _t2199 consume_literal!(parser, ")") - _t2188 = Proto.ExportCSVColumn(column_name=string1391, column_data=relation_id1392) - result1394 = _t2188 - record_span!(parser, span_start1393, "ExportCSVColumn") - return result1394 + _t2200 = Proto.ExportCSVColumn(column_name=string1395, column_data=relation_id1396) + result1398 = _t2200 + record_span!(parser, span_start1397, "ExportCSVColumn") + return result1398 end function parse_export_csv_path(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "path") - string1395 = consume_terminal!(parser, "STRING") + string1399 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1395 + return string1399 end function parse_export_csv_columns_list(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1396 = Proto.ExportCSVColumn[] - cond1397 = match_lookahead_literal(parser, "(", 0) - while cond1397 - _t2189 = parse_export_csv_column(parser) - item1398 = _t2189 - push!(xs1396, item1398) - cond1397 = match_lookahead_literal(parser, "(", 0) - end - export_csv_columns1399 = xs1396 + xs1400 = Proto.ExportCSVColumn[] + cond1401 = match_lookahead_literal(parser, "(", 0) + while cond1401 + _t2201 = parse_export_csv_column(parser) + item1402 = _t2201 + push!(xs1400, item1402) + cond1401 = match_lookahead_literal(parser, "(", 0) + end + export_csv_columns1403 = xs1400 consume_literal!(parser, ")") - return export_csv_columns1399 + return export_csv_columns1403 end function parse_export_iceberg_config(parser::ParserState)::Proto.ExportIcebergConfig - span_start1405 = span_start(parser) + span_start1409 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg_config") - _t2190 = parse_iceberg_locator(parser) - iceberg_locator1400 = _t2190 - _t2191 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1401 = _t2191 - _t2192 = parse_export_iceberg_table_def(parser) - export_iceberg_table_def1402 = _t2192 - _t2193 = parse_iceberg_table_properties(parser) - iceberg_table_properties1403 = _t2193 + _t2202 = parse_iceberg_locator(parser) + iceberg_locator1404 = _t2202 + _t2203 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1405 = _t2203 + _t2204 = parse_export_iceberg_table_def(parser) + export_iceberg_table_def1406 = _t2204 + _t2205 = parse_iceberg_table_properties(parser) + iceberg_table_properties1407 = _t2205 if match_lookahead_literal(parser, "{", 0) - _t2195 = parse_config_dict(parser) - _t2194 = _t2195 + _t2207 = parse_config_dict(parser) + _t2206 = _t2207 else - _t2194 = nothing + _t2206 = nothing end - config_dict1404 = _t2194 + config_dict1408 = _t2206 consume_literal!(parser, ")") - _t2196 = construct_export_iceberg_config_full(parser, iceberg_locator1400, iceberg_catalog_config1401, export_iceberg_table_def1402, iceberg_table_properties1403, config_dict1404) - result1406 = _t2196 - record_span!(parser, span_start1405, "ExportIcebergConfig") - return result1406 + _t2208 = construct_export_iceberg_config_full(parser, iceberg_locator1404, iceberg_catalog_config1405, export_iceberg_table_def1406, iceberg_table_properties1407, config_dict1408) + result1410 = _t2208 + record_span!(parser, span_start1409, "ExportIcebergConfig") + return result1410 end function parse_export_iceberg_table_def(parser::ParserState)::Proto.RelationId - span_start1408 = span_start(parser) + span_start1412 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2197 = parse_relation_id(parser) - relation_id1407 = _t2197 + _t2209 = parse_relation_id(parser) + relation_id1411 = _t2209 consume_literal!(parser, ")") - result1409 = relation_id1407 - record_span!(parser, span_start1408, "RelationId") - return result1409 + result1413 = relation_id1411 + record_span!(parser, span_start1412, "RelationId") + return result1413 end function parse_iceberg_table_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "table_properties") - xs1410 = Tuple{String, String}[] - cond1411 = match_lookahead_literal(parser, "(", 0) - while cond1411 - _t2198 = parse_iceberg_property_entry(parser) - item1412 = _t2198 - push!(xs1410, item1412) - cond1411 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1413 = xs1410 + xs1414 = Tuple{String, String}[] + cond1415 = match_lookahead_literal(parser, "(", 0) + while cond1415 + _t2210 = parse_iceberg_property_entry(parser) + item1416 = _t2210 + push!(xs1414, item1416) + cond1415 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1417 = xs1414 consume_literal!(parser, ")") - return iceberg_property_entrys1413 + return iceberg_property_entrys1417 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index 3ae409df..5cf08b5a 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -376,11 +376,15 @@ end # --- Helper functions --- +function deconstruct_relation_keys(pp::PrettyPrinter, msg::Proto.TargetRelations)::Tuple{Vector{Proto.NamedColumn}, Bool} + return (msg.keys, msg.synthetic_key,) +end + function deconstruct_csv_data_columns_optional(pp::PrettyPrinter, msg::Proto.CSVData)::Union{Nothing, Vector{Proto.GNFColumn}} if _has_proto_field(msg, Symbol("relations")) return nothing else - _t1889 = nothing + _t1898 = nothing end return msg.columns end @@ -389,7 +393,7 @@ function deconstruct_csv_data_relations_optional(pp::PrettyPrinter, msg::Proto.C if _has_proto_field(msg, Symbol("relations")) return msg.relations else - _t1890 = nothing + _t1899 = nothing end return nothing end @@ -399,89 +403,89 @@ function deconstruct_export_csv_output_location(pp::PrettyPrinter, msg::Proto.Ex end function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value - _t1891 = Proto.Value(value=OneOf(:int32_value, v)) - return _t1891 + _t1900 = Proto.Value(value=OneOf(:int32_value, v)) + return _t1900 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1892 = Proto.Value(value=OneOf(:int_value, v)) - return _t1892 + _t1901 = Proto.Value(value=OneOf(:int_value, v)) + return _t1901 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1893 = Proto.Value(value=OneOf(:float_value, v)) - return _t1893 + _t1902 = Proto.Value(value=OneOf(:float_value, v)) + return _t1902 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1894 = Proto.Value(value=OneOf(:string_value, v)) - return _t1894 + _t1903 = Proto.Value(value=OneOf(:string_value, v)) + return _t1903 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1895 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1895 + _t1904 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1904 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1896 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1896 + _t1905 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1905 end function deconstruct_configure(pp::PrettyPrinter, msg::Proto.Configure)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_AUTO - _t1897 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1897,)) + _t1906 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1906,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1898 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1898,)) + _t1907 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1907,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1899 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1899,)) + _t1908 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1908,)) end end end - _t1900 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1900,)) + _t1909 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1909,)) return sort(result) end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1901 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1901,)) - _t1902 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1902,)) + _t1910 = _make_value_int32(pp, msg.header_row) + push!(result, ("csv_header_row", _t1910,)) + _t1911 = _make_value_int64(pp, msg.skip) + push!(result, ("csv_skip", _t1911,)) if msg.new_line != "" - _t1903 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1903,)) - end - _t1904 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1904,)) - _t1905 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1905,)) - _t1906 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1906,)) + _t1912 = _make_value_string(pp, msg.new_line) + push!(result, ("csv_new_line", _t1912,)) + end + _t1913 = _make_value_string(pp, msg.delimiter) + push!(result, ("csv_delimiter", _t1913,)) + _t1914 = _make_value_string(pp, msg.quotechar) + push!(result, ("csv_quotechar", _t1914,)) + _t1915 = _make_value_string(pp, msg.escapechar) + push!(result, ("csv_escapechar", _t1915,)) if msg.comment != "" - _t1907 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1907,)) + _t1916 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1916,)) end for missing_string in msg.missing_strings - _t1908 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1908,)) - end - _t1909 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1909,)) - _t1910 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1910,)) - _t1911 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1911,)) + _t1917 = _make_value_string(pp, missing_string) + push!(result, ("csv_missing_strings", _t1917,)) + end + _t1918 = _make_value_string(pp, msg.decimal_separator) + push!(result, ("csv_decimal_separator", _t1918,)) + _t1919 = _make_value_string(pp, msg.encoding) + push!(result, ("csv_encoding", _t1919,)) + _t1920 = _make_value_string(pp, msg.compression) + push!(result, ("csv_compression", _t1920,)) if msg.partition_size_mb != 0 - _t1912 = _make_value_int64(pp, msg.partition_size_mb) - push!(result, ("csv_partition_size_mb", _t1912,)) + _t1921 = _make_value_int64(pp, msg.partition_size_mb) + push!(result, ("csv_partition_size_mb", _t1921,)) end return sort(result) end @@ -490,91 +494,91 @@ function deconstruct_csv_storage_integration_optional(pp::PrettyPrinter, msg::Pr if !_has_proto_field(msg, Symbol("storage_integration")) return nothing else - _t1913 = nothing + _t1922 = nothing end si = msg.storage_integration result = Tuple{String, Proto.Value}[] if si.provider != "" - _t1914 = _make_value_string(pp, si.provider) - push!(result, ("provider", _t1914,)) + _t1923 = _make_value_string(pp, si.provider) + push!(result, ("provider", _t1923,)) end if si.azure_sas_token != "" - _t1915 = _make_value_string(pp, "***") - push!(result, ("azure_sas_token", _t1915,)) + _t1924 = _make_value_string(pp, "***") + push!(result, ("azure_sas_token", _t1924,)) end if si.s3_region != "" - _t1916 = _make_value_string(pp, si.s3_region) - push!(result, ("s3_region", _t1916,)) + _t1925 = _make_value_string(pp, si.s3_region) + push!(result, ("s3_region", _t1925,)) end if si.s3_access_key_id != "" - _t1917 = _make_value_string(pp, "***") - push!(result, ("s3_access_key_id", _t1917,)) + _t1926 = _make_value_string(pp, "***") + push!(result, ("s3_access_key_id", _t1926,)) end if si.s3_secret_access_key != "" - _t1918 = _make_value_string(pp, "***") - push!(result, ("s3_secret_access_key", _t1918,)) + _t1927 = _make_value_string(pp, "***") + push!(result, ("s3_secret_access_key", _t1927,)) end return sort(result) end function deconstruct_betree_info_config(pp::PrettyPrinter, msg::Proto.BeTreeInfo)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1919 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1919,)) - _t1920 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1920,)) - _t1921 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1921,)) - _t1922 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1922,)) + _t1928 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1928,)) + _t1929 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1929,)) + _t1930 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1930,)) + _t1931 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1931,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1923 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1923,)) + _t1932 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1932,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1924 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1924,)) + _t1933 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1933,)) end end - _t1925 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1925,)) - _t1926 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1926,)) + _t1934 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1934,)) + _t1935 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1935,)) return sort(result) end function deconstruct_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] if !isnothing(msg.partition_size) - _t1927 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1927,)) + _t1936 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1936,)) end if !isnothing(msg.compression) - _t1928 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1928,)) + _t1937 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1937,)) end if !isnothing(msg.syntax_header_row) - _t1929 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1929,)) + _t1938 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1938,)) end if !isnothing(msg.syntax_missing_string) - _t1930 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1930,)) + _t1939 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1939,)) end if !isnothing(msg.syntax_delim) - _t1931 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1931,)) + _t1940 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1940,)) end if !isnothing(msg.syntax_quotechar) - _t1932 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1932,)) + _t1941 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1941,)) end if !isnothing(msg.syntax_escapechar) - _t1933 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1933,)) + _t1942 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1942,)) end return sort(result) end @@ -587,7 +591,7 @@ function deconstruct_iceberg_catalog_config_scope_optional(pp::PrettyPrinter, ms if msg.scope != "" return msg.scope else - _t1934 = nothing + _t1943 = nothing end return nothing end @@ -596,7 +600,7 @@ function deconstruct_iceberg_data_from_snapshot_optional(pp::PrettyPrinter, msg: if msg.from_snapshot != "" return msg.from_snapshot else - _t1935 = nothing + _t1944 = nothing end return nothing end @@ -605,7 +609,7 @@ function deconstruct_iceberg_data_to_snapshot_optional(pp::PrettyPrinter, msg::P if msg.to_snapshot != "" return msg.to_snapshot else - _t1936 = nothing + _t1945 = nothing end return nothing end @@ -613,21 +617,21 @@ end function deconstruct_export_iceberg_config_optional(pp::PrettyPrinter, msg::Proto.ExportIcebergConfig)::Union{Nothing, Vector{Tuple{String, Proto.Value}}} result = Tuple{String, Proto.Value}[] if msg.prefix != "" - _t1937 = _make_value_string(pp, msg.prefix) - push!(result, ("prefix", _t1937,)) + _t1946 = _make_value_string(pp, msg.prefix) + push!(result, ("prefix", _t1946,)) end if msg.target_file_size_bytes != 0 - _t1938 = _make_value_int64(pp, msg.target_file_size_bytes) - push!(result, ("target_file_size_bytes", _t1938,)) + _t1947 = _make_value_int64(pp, msg.target_file_size_bytes) + push!(result, ("target_file_size_bytes", _t1947,)) end if msg.compression != "" - _t1939 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1939,)) + _t1948 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1948,)) end if length(result) == 0 return nothing else - _t1940 = nothing + _t1949 = nothing end return sort(result) end @@ -642,7 +646,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1941 = nothing + _t1950 = nothing end return nothing end @@ -661,47 +665,47 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat856 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat856) - write(pp, flat856) + flat859 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat859) + write(pp, flat859) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1694 = _dollar_dollar.configure + _t1700 = _dollar_dollar.configure else - _t1694 = nothing + _t1700 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1695 = _dollar_dollar.sync + _t1701 = _dollar_dollar.sync else - _t1695 = nothing + _t1701 = nothing end - fields847 = (_t1694, _t1695, _dollar_dollar.epochs,) - unwrapped_fields848 = fields847 + fields850 = (_t1700, _t1701, _dollar_dollar.epochs,) + unwrapped_fields851 = fields850 write(pp, "(transaction") indent_sexp!(pp) - field849 = unwrapped_fields848[1] - if !isnothing(field849) + field852 = unwrapped_fields851[1] + if !isnothing(field852) newline(pp) - opt_val850 = field849 - pretty_configure(pp, opt_val850) + opt_val853 = field852 + pretty_configure(pp, opt_val853) end - field851 = unwrapped_fields848[2] - if !isnothing(field851) + field854 = unwrapped_fields851[2] + if !isnothing(field854) newline(pp) - opt_val852 = field851 - pretty_sync(pp, opt_val852) + opt_val855 = field854 + pretty_sync(pp, opt_val855) end - field853 = unwrapped_fields848[3] - if !isempty(field853) + field856 = unwrapped_fields851[3] + if !isempty(field856) newline(pp) - for (i1696, elem854) in enumerate(field853) - i855 = i1696 - 1 - if (i855 > 0) + for (i1702, elem857) in enumerate(field856) + i858 = i1702 - 1 + if (i858 > 0) newline(pp) end - pretty_epoch(pp, elem854) + pretty_epoch(pp, elem857) end end dedent!(pp) @@ -711,19 +715,19 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat859 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat859) - write(pp, flat859) + flat862 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat862) + write(pp, flat862) return nothing else _dollar_dollar = msg - _t1697 = deconstruct_configure(pp, _dollar_dollar) - fields857 = _t1697 - unwrapped_fields858 = fields857 + _t1703 = deconstruct_configure(pp, _dollar_dollar) + fields860 = _t1703 + unwrapped_fields861 = fields860 write(pp, "(configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields858) + pretty_config_dict(pp, unwrapped_fields861) dedent!(pp) write(pp, ")") end @@ -731,22 +735,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat863 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat863) - write(pp, flat863) + flat866 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat866) + write(pp, flat866) return nothing else - fields860 = msg + fields863 = msg write(pp, "{") indent!(pp) - if !isempty(fields860) + if !isempty(fields863) newline(pp) - for (i1698, elem861) in enumerate(fields860) - i862 = i1698 - 1 - if (i862 > 0) + for (i1704, elem864) in enumerate(fields863) + i865 = i1704 - 1 + if (i865 > 0) newline(pp) end - pretty_config_key_value(pp, elem861) + pretty_config_key_value(pp, elem864) end end dedent!(pp) @@ -756,163 +760,163 @@ function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.V end function pretty_config_key_value(pp::PrettyPrinter, msg::Tuple{String, Proto.Value}) - flat868 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat868) - write(pp, flat868) + flat871 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat871) + write(pp, flat871) return nothing else _dollar_dollar = msg - fields864 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields865 = fields864 + fields867 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields868 = fields867 write(pp, ":") - field866 = unwrapped_fields865[1] - write(pp, field866) + field869 = unwrapped_fields868[1] + write(pp, field869) write(pp, " ") - field867 = unwrapped_fields865[2] - pretty_raw_value(pp, field867) + field870 = unwrapped_fields868[2] + pretty_raw_value(pp, field870) end return nothing end function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) - flat894 = try_flat(pp, msg, pretty_raw_value) - if !isnothing(flat894) - write(pp, flat894) + flat897 = try_flat(pp, msg, pretty_raw_value) + if !isnothing(flat897) + write(pp, flat897) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1699 = _get_oneof_field(_dollar_dollar, :date_value) + _t1705 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1699 = nothing + _t1705 = nothing end - deconstruct_result892 = _t1699 - if !isnothing(deconstruct_result892) - unwrapped893 = deconstruct_result892 - pretty_raw_date(pp, unwrapped893) + deconstruct_result895 = _t1705 + if !isnothing(deconstruct_result895) + unwrapped896 = deconstruct_result895 + pretty_raw_date(pp, unwrapped896) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1700 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1706 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1700 = nothing + _t1706 = nothing end - deconstruct_result890 = _t1700 - if !isnothing(deconstruct_result890) - unwrapped891 = deconstruct_result890 - pretty_raw_datetime(pp, unwrapped891) + deconstruct_result893 = _t1706 + if !isnothing(deconstruct_result893) + unwrapped894 = deconstruct_result893 + pretty_raw_datetime(pp, unwrapped894) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1701 = _get_oneof_field(_dollar_dollar, :string_value) + _t1707 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1701 = nothing + _t1707 = nothing end - deconstruct_result888 = _t1701 - if !isnothing(deconstruct_result888) - unwrapped889 = deconstruct_result888 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped889)) + deconstruct_result891 = _t1707 + if !isnothing(deconstruct_result891) + unwrapped892 = deconstruct_result891 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped892)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1702 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1708 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1702 = nothing + _t1708 = nothing end - deconstruct_result886 = _t1702 - if !isnothing(deconstruct_result886) - unwrapped887 = deconstruct_result886 - write(pp, (string(Int64(unwrapped887)) * "i32")) + deconstruct_result889 = _t1708 + if !isnothing(deconstruct_result889) + unwrapped890 = deconstruct_result889 + write(pp, (string(Int64(unwrapped890)) * "i32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1703 = _get_oneof_field(_dollar_dollar, :int_value) + _t1709 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1703 = nothing + _t1709 = nothing end - deconstruct_result884 = _t1703 - if !isnothing(deconstruct_result884) - unwrapped885 = deconstruct_result884 - write(pp, string(unwrapped885)) + deconstruct_result887 = _t1709 + if !isnothing(deconstruct_result887) + unwrapped888 = deconstruct_result887 + write(pp, string(unwrapped888)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1704 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1710 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1704 = nothing + _t1710 = nothing end - deconstruct_result882 = _t1704 - if !isnothing(deconstruct_result882) - unwrapped883 = deconstruct_result882 - write(pp, format_float32_literal(unwrapped883)) + deconstruct_result885 = _t1710 + if !isnothing(deconstruct_result885) + unwrapped886 = deconstruct_result885 + write(pp, format_float32_literal(unwrapped886)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1705 = _get_oneof_field(_dollar_dollar, :float_value) + _t1711 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1705 = nothing + _t1711 = nothing end - deconstruct_result880 = _t1705 - if !isnothing(deconstruct_result880) - unwrapped881 = deconstruct_result880 - write(pp, lowercase(string(unwrapped881))) + deconstruct_result883 = _t1711 + if !isnothing(deconstruct_result883) + unwrapped884 = deconstruct_result883 + write(pp, lowercase(string(unwrapped884))) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1706 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1712 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1706 = nothing + _t1712 = nothing end - deconstruct_result878 = _t1706 - if !isnothing(deconstruct_result878) - unwrapped879 = deconstruct_result878 - write(pp, (string(Int64(unwrapped879)) * "u32")) + deconstruct_result881 = _t1712 + if !isnothing(deconstruct_result881) + unwrapped882 = deconstruct_result881 + write(pp, (string(Int64(unwrapped882)) * "u32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1707 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1713 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1707 = nothing + _t1713 = nothing end - deconstruct_result876 = _t1707 - if !isnothing(deconstruct_result876) - unwrapped877 = deconstruct_result876 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped877)) + deconstruct_result879 = _t1713 + if !isnothing(deconstruct_result879) + unwrapped880 = deconstruct_result879 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped880)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1708 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1714 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1708 = nothing + _t1714 = nothing end - deconstruct_result874 = _t1708 - if !isnothing(deconstruct_result874) - unwrapped875 = deconstruct_result874 - write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped875)) + deconstruct_result877 = _t1714 + if !isnothing(deconstruct_result877) + unwrapped878 = deconstruct_result877 + write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped878)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1709 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1715 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1709 = nothing + _t1715 = nothing end - deconstruct_result872 = _t1709 - if !isnothing(deconstruct_result872) - unwrapped873 = deconstruct_result872 - write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped873)) + deconstruct_result875 = _t1715 + if !isnothing(deconstruct_result875) + unwrapped876 = deconstruct_result875 + write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped876)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1710 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1716 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1710 = nothing + _t1716 = nothing end - deconstruct_result870 = _t1710 - if !isnothing(deconstruct_result870) - unwrapped871 = deconstruct_result870 - pretty_boolean_value(pp, unwrapped871) + deconstruct_result873 = _t1716 + if !isnothing(deconstruct_result873) + unwrapped874 = deconstruct_result873 + pretty_boolean_value(pp, unwrapped874) else - fields869 = msg + fields872 = msg write(pp, "missing") end end @@ -931,25 +935,25 @@ function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat900 = try_flat(pp, msg, pretty_raw_date) - if !isnothing(flat900) - write(pp, flat900) + flat903 = try_flat(pp, msg, pretty_raw_date) + if !isnothing(flat903) + write(pp, flat903) return nothing else _dollar_dollar = msg - fields895 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields896 = fields895 + fields898 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields899 = fields898 write(pp, "(date") indent_sexp!(pp) newline(pp) - field897 = unwrapped_fields896[1] - write(pp, string(field897)) + field900 = unwrapped_fields899[1] + write(pp, string(field900)) newline(pp) - field898 = unwrapped_fields896[2] - write(pp, string(field898)) + field901 = unwrapped_fields899[2] + write(pp, string(field901)) newline(pp) - field899 = unwrapped_fields896[3] - write(pp, string(field899)) + field902 = unwrapped_fields899[3] + write(pp, string(field902)) dedent!(pp) write(pp, ")") end @@ -957,39 +961,39 @@ function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_raw_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat911 = try_flat(pp, msg, pretty_raw_datetime) - if !isnothing(flat911) - write(pp, flat911) + flat914 = try_flat(pp, msg, pretty_raw_datetime) + if !isnothing(flat914) + write(pp, flat914) return nothing else _dollar_dollar = msg - fields901 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),) - unwrapped_fields902 = fields901 + fields904 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),) + unwrapped_fields905 = fields904 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field903 = unwrapped_fields902[1] - write(pp, string(field903)) - newline(pp) - field904 = unwrapped_fields902[2] - write(pp, string(field904)) - newline(pp) - field905 = unwrapped_fields902[3] - write(pp, string(field905)) - newline(pp) - field906 = unwrapped_fields902[4] + field906 = unwrapped_fields905[1] write(pp, string(field906)) newline(pp) - field907 = unwrapped_fields902[5] + field907 = unwrapped_fields905[2] write(pp, string(field907)) newline(pp) - field908 = unwrapped_fields902[6] + field908 = unwrapped_fields905[3] write(pp, string(field908)) - field909 = unwrapped_fields902[7] - if !isnothing(field909) + newline(pp) + field909 = unwrapped_fields905[4] + write(pp, string(field909)) + newline(pp) + field910 = unwrapped_fields905[5] + write(pp, string(field910)) + newline(pp) + field911 = unwrapped_fields905[6] + write(pp, string(field911)) + field912 = unwrapped_fields905[7] + if !isnothing(field912) newline(pp) - opt_val910 = field909 - write(pp, string(opt_val910)) + opt_val913 = field912 + write(pp, string(opt_val913)) end dedent!(pp) write(pp, ")") @@ -1000,24 +1004,24 @@ end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) _dollar_dollar = msg if _dollar_dollar - _t1711 = () + _t1717 = () else - _t1711 = nothing + _t1717 = nothing end - deconstruct_result914 = _t1711 - if !isnothing(deconstruct_result914) - unwrapped915 = deconstruct_result914 + deconstruct_result917 = _t1717 + if !isnothing(deconstruct_result917) + unwrapped918 = deconstruct_result917 write(pp, "true") else _dollar_dollar = msg if !_dollar_dollar - _t1712 = () + _t1718 = () else - _t1712 = nothing + _t1718 = nothing end - deconstruct_result912 = _t1712 - if !isnothing(deconstruct_result912) - unwrapped913 = deconstruct_result912 + deconstruct_result915 = _t1718 + if !isnothing(deconstruct_result915) + unwrapped916 = deconstruct_result915 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -1027,24 +1031,24 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat920 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat920) - write(pp, flat920) + flat923 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat923) + write(pp, flat923) return nothing else _dollar_dollar = msg - fields916 = _dollar_dollar.fragments - unwrapped_fields917 = fields916 + fields919 = _dollar_dollar.fragments + unwrapped_fields920 = fields919 write(pp, "(sync") indent_sexp!(pp) - if !isempty(unwrapped_fields917) + if !isempty(unwrapped_fields920) newline(pp) - for (i1713, elem918) in enumerate(unwrapped_fields917) - i919 = i1713 - 1 - if (i919 > 0) + for (i1719, elem921) in enumerate(unwrapped_fields920) + i922 = i1719 - 1 + if (i922 > 0) newline(pp) end - pretty_fragment_id(pp, elem918) + pretty_fragment_id(pp, elem921) end end dedent!(pp) @@ -1054,52 +1058,52 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat923 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat923) - write(pp, flat923) + flat926 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat926) + write(pp, flat926) return nothing else _dollar_dollar = msg - fields921 = fragment_id_to_string(pp, _dollar_dollar) - unwrapped_fields922 = fields921 + fields924 = fragment_id_to_string(pp, _dollar_dollar) + unwrapped_fields925 = fields924 write(pp, ":") - write(pp, unwrapped_fields922) + write(pp, unwrapped_fields925) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat930 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat930) - write(pp, flat930) + flat933 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat933) + write(pp, flat933) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.writes) - _t1714 = _dollar_dollar.writes + _t1720 = _dollar_dollar.writes else - _t1714 = nothing + _t1720 = nothing end if !isempty(_dollar_dollar.reads) - _t1715 = _dollar_dollar.reads + _t1721 = _dollar_dollar.reads else - _t1715 = nothing + _t1721 = nothing end - fields924 = (_t1714, _t1715,) - unwrapped_fields925 = fields924 + fields927 = (_t1720, _t1721,) + unwrapped_fields928 = fields927 write(pp, "(epoch") indent_sexp!(pp) - field926 = unwrapped_fields925[1] - if !isnothing(field926) + field929 = unwrapped_fields928[1] + if !isnothing(field929) newline(pp) - opt_val927 = field926 - pretty_epoch_writes(pp, opt_val927) + opt_val930 = field929 + pretty_epoch_writes(pp, opt_val930) end - field928 = unwrapped_fields925[2] - if !isnothing(field928) + field931 = unwrapped_fields928[2] + if !isnothing(field931) newline(pp) - opt_val929 = field928 - pretty_epoch_reads(pp, opt_val929) + opt_val932 = field931 + pretty_epoch_reads(pp, opt_val932) end dedent!(pp) write(pp, ")") @@ -1108,22 +1112,22 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat934 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat934) - write(pp, flat934) + flat937 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat937) + write(pp, flat937) return nothing else - fields931 = msg + fields934 = msg write(pp, "(writes") indent_sexp!(pp) - if !isempty(fields931) + if !isempty(fields934) newline(pp) - for (i1716, elem932) in enumerate(fields931) - i933 = i1716 - 1 - if (i933 > 0) + for (i1722, elem935) in enumerate(fields934) + i936 = i1722 - 1 + if (i936 > 0) newline(pp) end - pretty_write(pp, elem932) + pretty_write(pp, elem935) end end dedent!(pp) @@ -1133,54 +1137,54 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat943 = try_flat(pp, msg, pretty_write) - if !isnothing(flat943) - write(pp, flat943) + flat946 = try_flat(pp, msg, pretty_write) + if !isnothing(flat946) + write(pp, flat946) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1717 = _get_oneof_field(_dollar_dollar, :define) + _t1723 = _get_oneof_field(_dollar_dollar, :define) else - _t1717 = nothing + _t1723 = nothing end - deconstruct_result941 = _t1717 - if !isnothing(deconstruct_result941) - unwrapped942 = deconstruct_result941 - pretty_define(pp, unwrapped942) + deconstruct_result944 = _t1723 + if !isnothing(deconstruct_result944) + unwrapped945 = deconstruct_result944 + pretty_define(pp, unwrapped945) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1718 = _get_oneof_field(_dollar_dollar, :undefine) + _t1724 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1718 = nothing + _t1724 = nothing end - deconstruct_result939 = _t1718 - if !isnothing(deconstruct_result939) - unwrapped940 = deconstruct_result939 - pretty_undefine(pp, unwrapped940) + deconstruct_result942 = _t1724 + if !isnothing(deconstruct_result942) + unwrapped943 = deconstruct_result942 + pretty_undefine(pp, unwrapped943) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1719 = _get_oneof_field(_dollar_dollar, :context) + _t1725 = _get_oneof_field(_dollar_dollar, :context) else - _t1719 = nothing + _t1725 = nothing end - deconstruct_result937 = _t1719 - if !isnothing(deconstruct_result937) - unwrapped938 = deconstruct_result937 - pretty_context(pp, unwrapped938) + deconstruct_result940 = _t1725 + if !isnothing(deconstruct_result940) + unwrapped941 = deconstruct_result940 + pretty_context(pp, unwrapped941) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1720 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1726 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1720 = nothing + _t1726 = nothing end - deconstruct_result935 = _t1720 - if !isnothing(deconstruct_result935) - unwrapped936 = deconstruct_result935 - pretty_snapshot(pp, unwrapped936) + deconstruct_result938 = _t1726 + if !isnothing(deconstruct_result938) + unwrapped939 = deconstruct_result938 + pretty_snapshot(pp, unwrapped939) else throw(ParseError("No matching rule for write")) end @@ -1192,18 +1196,18 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat946 = try_flat(pp, msg, pretty_define) - if !isnothing(flat946) - write(pp, flat946) + flat949 = try_flat(pp, msg, pretty_define) + if !isnothing(flat949) + write(pp, flat949) return nothing else _dollar_dollar = msg - fields944 = _dollar_dollar.fragment - unwrapped_fields945 = fields944 + fields947 = _dollar_dollar.fragment + unwrapped_fields948 = fields947 write(pp, "(define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields945) + pretty_fragment(pp, unwrapped_fields948) dedent!(pp) write(pp, ")") end @@ -1211,29 +1215,29 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat953 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat953) - write(pp, flat953) + flat956 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat956) + write(pp, flat956) return nothing else _dollar_dollar = msg start_pretty_fragment(pp, _dollar_dollar) - fields947 = (_dollar_dollar.id, _dollar_dollar.declarations,) - unwrapped_fields948 = fields947 + fields950 = (_dollar_dollar.id, _dollar_dollar.declarations,) + unwrapped_fields951 = fields950 write(pp, "(fragment") indent_sexp!(pp) newline(pp) - field949 = unwrapped_fields948[1] - pretty_new_fragment_id(pp, field949) - field950 = unwrapped_fields948[2] - if !isempty(field950) + field952 = unwrapped_fields951[1] + pretty_new_fragment_id(pp, field952) + field953 = unwrapped_fields951[2] + if !isempty(field953) newline(pp) - for (i1721, elem951) in enumerate(field950) - i952 = i1721 - 1 - if (i952 > 0) + for (i1727, elem954) in enumerate(field953) + i955 = i1727 - 1 + if (i955 > 0) newline(pp) end - pretty_declaration(pp, elem951) + pretty_declaration(pp, elem954) end end dedent!(pp) @@ -1243,66 +1247,66 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat955 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat955) - write(pp, flat955) + flat958 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat958) + write(pp, flat958) return nothing else - fields954 = msg - pretty_fragment_id(pp, fields954) + fields957 = msg + pretty_fragment_id(pp, fields957) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat964 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat964) - write(pp, flat964) + flat967 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat967) + write(pp, flat967) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1722 = _get_oneof_field(_dollar_dollar, :def) + _t1728 = _get_oneof_field(_dollar_dollar, :def) else - _t1722 = nothing + _t1728 = nothing end - deconstruct_result962 = _t1722 - if !isnothing(deconstruct_result962) - unwrapped963 = deconstruct_result962 - pretty_def(pp, unwrapped963) + deconstruct_result965 = _t1728 + if !isnothing(deconstruct_result965) + unwrapped966 = deconstruct_result965 + pretty_def(pp, unwrapped966) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1723 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1729 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1723 = nothing + _t1729 = nothing end - deconstruct_result960 = _t1723 - if !isnothing(deconstruct_result960) - unwrapped961 = deconstruct_result960 - pretty_algorithm(pp, unwrapped961) + deconstruct_result963 = _t1729 + if !isnothing(deconstruct_result963) + unwrapped964 = deconstruct_result963 + pretty_algorithm(pp, unwrapped964) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1724 = _get_oneof_field(_dollar_dollar, :constraint) + _t1730 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1724 = nothing + _t1730 = nothing end - deconstruct_result958 = _t1724 - if !isnothing(deconstruct_result958) - unwrapped959 = deconstruct_result958 - pretty_constraint(pp, unwrapped959) + deconstruct_result961 = _t1730 + if !isnothing(deconstruct_result961) + unwrapped962 = deconstruct_result961 + pretty_constraint(pp, unwrapped962) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1725 = _get_oneof_field(_dollar_dollar, :data) + _t1731 = _get_oneof_field(_dollar_dollar, :data) else - _t1725 = nothing + _t1731 = nothing end - deconstruct_result956 = _t1725 - if !isnothing(deconstruct_result956) - unwrapped957 = deconstruct_result956 - pretty_data(pp, unwrapped957) + deconstruct_result959 = _t1731 + if !isnothing(deconstruct_result959) + unwrapped960 = deconstruct_result959 + pretty_data(pp, unwrapped960) else throw(ParseError("No matching rule for declaration")) end @@ -1314,32 +1318,32 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat971 = try_flat(pp, msg, pretty_def) - if !isnothing(flat971) - write(pp, flat971) + flat974 = try_flat(pp, msg, pretty_def) + if !isnothing(flat974) + write(pp, flat974) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1726 = _dollar_dollar.attrs + _t1732 = _dollar_dollar.attrs else - _t1726 = nothing + _t1732 = nothing end - fields965 = (_dollar_dollar.name, _dollar_dollar.body, _t1726,) - unwrapped_fields966 = fields965 + fields968 = (_dollar_dollar.name, _dollar_dollar.body, _t1732,) + unwrapped_fields969 = fields968 write(pp, "(def") indent_sexp!(pp) newline(pp) - field967 = unwrapped_fields966[1] - pretty_relation_id(pp, field967) + field970 = unwrapped_fields969[1] + pretty_relation_id(pp, field970) newline(pp) - field968 = unwrapped_fields966[2] - pretty_abstraction(pp, field968) - field969 = unwrapped_fields966[3] - if !isnothing(field969) + field971 = unwrapped_fields969[2] + pretty_abstraction(pp, field971) + field972 = unwrapped_fields969[3] + if !isnothing(field972) newline(pp) - opt_val970 = field969 - pretty_attrs(pp, opt_val970) + opt_val973 = field972 + pretty_attrs(pp, opt_val973) end dedent!(pp) write(pp, ")") @@ -1348,30 +1352,30 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat976 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat976) - write(pp, flat976) + flat979 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat979) + write(pp, flat979) return nothing else _dollar_dollar = msg if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1728 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1727 = _t1728 + _t1734 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1733 = _t1734 else - _t1727 = nothing + _t1733 = nothing end - deconstruct_result974 = _t1727 - if !isnothing(deconstruct_result974) - unwrapped975 = deconstruct_result974 + deconstruct_result977 = _t1733 + if !isnothing(deconstruct_result977) + unwrapped978 = deconstruct_result977 write(pp, ":") - write(pp, unwrapped975) + write(pp, unwrapped978) else _dollar_dollar = msg - _t1729 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - deconstruct_result972 = _t1729 - if !isnothing(deconstruct_result972) - unwrapped973 = deconstruct_result972 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped973)) + _t1735 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + deconstruct_result975 = _t1735 + if !isnothing(deconstruct_result975) + unwrapped976 = deconstruct_result975 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped976)) else throw(ParseError("No matching rule for relation_id")) end @@ -1381,22 +1385,22 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat981 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat981) - write(pp, flat981) + flat984 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat984) + write(pp, flat984) return nothing else _dollar_dollar = msg - _t1730 = deconstruct_bindings(pp, _dollar_dollar) - fields977 = (_t1730, _dollar_dollar.value,) - unwrapped_fields978 = fields977 + _t1736 = deconstruct_bindings(pp, _dollar_dollar) + fields980 = (_t1736, _dollar_dollar.value,) + unwrapped_fields981 = fields980 write(pp, "(") indent!(pp) - field979 = unwrapped_fields978[1] - pretty_bindings(pp, field979) + field982 = unwrapped_fields981[1] + pretty_bindings(pp, field982) newline(pp) - field980 = unwrapped_fields978[2] - pretty_formula(pp, field980) + field983 = unwrapped_fields981[2] + pretty_formula(pp, field983) dedent!(pp) write(pp, ")") end @@ -1404,34 +1408,34 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat989 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat989) - write(pp, flat989) + flat992 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat992) + write(pp, flat992) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar[2]) - _t1731 = _dollar_dollar[2] + _t1737 = _dollar_dollar[2] else - _t1731 = nothing + _t1737 = nothing end - fields982 = (_dollar_dollar[1], _t1731,) - unwrapped_fields983 = fields982 + fields985 = (_dollar_dollar[1], _t1737,) + unwrapped_fields986 = fields985 write(pp, "[") indent!(pp) - field984 = unwrapped_fields983[1] - for (i1732, elem985) in enumerate(field984) - i986 = i1732 - 1 - if (i986 > 0) + field987 = unwrapped_fields986[1] + for (i1738, elem988) in enumerate(field987) + i989 = i1738 - 1 + if (i989 > 0) newline(pp) end - pretty_binding(pp, elem985) + pretty_binding(pp, elem988) end - field987 = unwrapped_fields983[2] - if !isnothing(field987) + field990 = unwrapped_fields986[2] + if !isnothing(field990) newline(pp) - opt_val988 = field987 - pretty_value_bindings(pp, opt_val988) + opt_val991 = field990 + pretty_value_bindings(pp, opt_val991) end dedent!(pp) write(pp, "]") @@ -1440,182 +1444,182 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat994 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat994) - write(pp, flat994) + flat997 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat997) + write(pp, flat997) return nothing else _dollar_dollar = msg - fields990 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) - unwrapped_fields991 = fields990 - field992 = unwrapped_fields991[1] - write(pp, field992) + fields993 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) + unwrapped_fields994 = fields993 + field995 = unwrapped_fields994[1] + write(pp, field995) write(pp, "::") - field993 = unwrapped_fields991[2] - pretty_type(pp, field993) + field996 = unwrapped_fields994[2] + pretty_type(pp, field996) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat1023 = try_flat(pp, msg, pretty_type) - if !isnothing(flat1023) - write(pp, flat1023) + flat1026 = try_flat(pp, msg, pretty_type) + if !isnothing(flat1026) + write(pp, flat1026) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1733 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1739 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1733 = nothing + _t1739 = nothing end - deconstruct_result1021 = _t1733 - if !isnothing(deconstruct_result1021) - unwrapped1022 = deconstruct_result1021 - pretty_unspecified_type(pp, unwrapped1022) + deconstruct_result1024 = _t1739 + if !isnothing(deconstruct_result1024) + unwrapped1025 = deconstruct_result1024 + pretty_unspecified_type(pp, unwrapped1025) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1734 = _get_oneof_field(_dollar_dollar, :string_type) + _t1740 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1734 = nothing + _t1740 = nothing end - deconstruct_result1019 = _t1734 - if !isnothing(deconstruct_result1019) - unwrapped1020 = deconstruct_result1019 - pretty_string_type(pp, unwrapped1020) + deconstruct_result1022 = _t1740 + if !isnothing(deconstruct_result1022) + unwrapped1023 = deconstruct_result1022 + pretty_string_type(pp, unwrapped1023) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1735 = _get_oneof_field(_dollar_dollar, :int_type) + _t1741 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1735 = nothing + _t1741 = nothing end - deconstruct_result1017 = _t1735 - if !isnothing(deconstruct_result1017) - unwrapped1018 = deconstruct_result1017 - pretty_int_type(pp, unwrapped1018) + deconstruct_result1020 = _t1741 + if !isnothing(deconstruct_result1020) + unwrapped1021 = deconstruct_result1020 + pretty_int_type(pp, unwrapped1021) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1736 = _get_oneof_field(_dollar_dollar, :float_type) + _t1742 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1736 = nothing + _t1742 = nothing end - deconstruct_result1015 = _t1736 - if !isnothing(deconstruct_result1015) - unwrapped1016 = deconstruct_result1015 - pretty_float_type(pp, unwrapped1016) + deconstruct_result1018 = _t1742 + if !isnothing(deconstruct_result1018) + unwrapped1019 = deconstruct_result1018 + pretty_float_type(pp, unwrapped1019) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1737 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1743 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1737 = nothing + _t1743 = nothing end - deconstruct_result1013 = _t1737 - if !isnothing(deconstruct_result1013) - unwrapped1014 = deconstruct_result1013 - pretty_uint128_type(pp, unwrapped1014) + deconstruct_result1016 = _t1743 + if !isnothing(deconstruct_result1016) + unwrapped1017 = deconstruct_result1016 + pretty_uint128_type(pp, unwrapped1017) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1738 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1744 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1738 = nothing + _t1744 = nothing end - deconstruct_result1011 = _t1738 - if !isnothing(deconstruct_result1011) - unwrapped1012 = deconstruct_result1011 - pretty_int128_type(pp, unwrapped1012) + deconstruct_result1014 = _t1744 + if !isnothing(deconstruct_result1014) + unwrapped1015 = deconstruct_result1014 + pretty_int128_type(pp, unwrapped1015) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1739 = _get_oneof_field(_dollar_dollar, :date_type) + _t1745 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1739 = nothing + _t1745 = nothing end - deconstruct_result1009 = _t1739 - if !isnothing(deconstruct_result1009) - unwrapped1010 = deconstruct_result1009 - pretty_date_type(pp, unwrapped1010) + deconstruct_result1012 = _t1745 + if !isnothing(deconstruct_result1012) + unwrapped1013 = deconstruct_result1012 + pretty_date_type(pp, unwrapped1013) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1740 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1746 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1740 = nothing + _t1746 = nothing end - deconstruct_result1007 = _t1740 - if !isnothing(deconstruct_result1007) - unwrapped1008 = deconstruct_result1007 - pretty_datetime_type(pp, unwrapped1008) + deconstruct_result1010 = _t1746 + if !isnothing(deconstruct_result1010) + unwrapped1011 = deconstruct_result1010 + pretty_datetime_type(pp, unwrapped1011) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1741 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1747 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1741 = nothing + _t1747 = nothing end - deconstruct_result1005 = _t1741 - if !isnothing(deconstruct_result1005) - unwrapped1006 = deconstruct_result1005 - pretty_missing_type(pp, unwrapped1006) + deconstruct_result1008 = _t1747 + if !isnothing(deconstruct_result1008) + unwrapped1009 = deconstruct_result1008 + pretty_missing_type(pp, unwrapped1009) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1742 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1748 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1742 = nothing + _t1748 = nothing end - deconstruct_result1003 = _t1742 - if !isnothing(deconstruct_result1003) - unwrapped1004 = deconstruct_result1003 - pretty_decimal_type(pp, unwrapped1004) + deconstruct_result1006 = _t1748 + if !isnothing(deconstruct_result1006) + unwrapped1007 = deconstruct_result1006 + pretty_decimal_type(pp, unwrapped1007) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1743 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1749 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1743 = nothing + _t1749 = nothing end - deconstruct_result1001 = _t1743 - if !isnothing(deconstruct_result1001) - unwrapped1002 = deconstruct_result1001 - pretty_boolean_type(pp, unwrapped1002) + deconstruct_result1004 = _t1749 + if !isnothing(deconstruct_result1004) + unwrapped1005 = deconstruct_result1004 + pretty_boolean_type(pp, unwrapped1005) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_type")) - _t1744 = _get_oneof_field(_dollar_dollar, :int32_type) + _t1750 = _get_oneof_field(_dollar_dollar, :int32_type) else - _t1744 = nothing + _t1750 = nothing end - deconstruct_result999 = _t1744 - if !isnothing(deconstruct_result999) - unwrapped1000 = deconstruct_result999 - pretty_int32_type(pp, unwrapped1000) + deconstruct_result1002 = _t1750 + if !isnothing(deconstruct_result1002) + unwrapped1003 = deconstruct_result1002 + pretty_int32_type(pp, unwrapped1003) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_type")) - _t1745 = _get_oneof_field(_dollar_dollar, :float32_type) + _t1751 = _get_oneof_field(_dollar_dollar, :float32_type) else - _t1745 = nothing + _t1751 = nothing end - deconstruct_result997 = _t1745 - if !isnothing(deconstruct_result997) - unwrapped998 = deconstruct_result997 - pretty_float32_type(pp, unwrapped998) + deconstruct_result1000 = _t1751 + if !isnothing(deconstruct_result1000) + unwrapped1001 = deconstruct_result1000 + pretty_float32_type(pp, unwrapped1001) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_type")) - _t1746 = _get_oneof_field(_dollar_dollar, :uint32_type) + _t1752 = _get_oneof_field(_dollar_dollar, :uint32_type) else - _t1746 = nothing + _t1752 = nothing end - deconstruct_result995 = _t1746 - if !isnothing(deconstruct_result995) - unwrapped996 = deconstruct_result995 - pretty_uint32_type(pp, unwrapped996) + deconstruct_result998 = _t1752 + if !isnothing(deconstruct_result998) + unwrapped999 = deconstruct_result998 + pretty_uint32_type(pp, unwrapped999) else throw(ParseError("No matching rule for type")) end @@ -1637,76 +1641,76 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields1024 = msg + fields1027 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields1025 = msg + fields1028 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields1026 = msg + fields1029 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields1027 = msg + fields1030 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields1028 = msg + fields1031 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields1029 = msg + fields1032 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields1030 = msg + fields1033 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields1031 = msg + fields1034 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields1032 = msg + fields1035 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat1037 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat1037) - write(pp, flat1037) + flat1040 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat1040) + write(pp, flat1040) return nothing else _dollar_dollar = msg - fields1033 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) - unwrapped_fields1034 = fields1033 + fields1036 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) + unwrapped_fields1037 = fields1036 write(pp, "(DECIMAL") indent_sexp!(pp) newline(pp) - field1035 = unwrapped_fields1034[1] - write(pp, string(field1035)) + field1038 = unwrapped_fields1037[1] + write(pp, string(field1038)) newline(pp) - field1036 = unwrapped_fields1034[2] - write(pp, string(field1036)) + field1039 = unwrapped_fields1037[2] + write(pp, string(field1039)) dedent!(pp) write(pp, ")") end @@ -1714,45 +1718,45 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields1038 = msg + fields1041 = msg write(pp, "BOOLEAN") return nothing end function pretty_int32_type(pp::PrettyPrinter, msg::Proto.Int32Type) - fields1039 = msg + fields1042 = msg write(pp, "INT32") return nothing end function pretty_float32_type(pp::PrettyPrinter, msg::Proto.Float32Type) - fields1040 = msg + fields1043 = msg write(pp, "FLOAT32") return nothing end function pretty_uint32_type(pp::PrettyPrinter, msg::Proto.UInt32Type) - fields1041 = msg + fields1044 = msg write(pp, "UINT32") return nothing end function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat1045 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat1045) - write(pp, flat1045) + flat1048 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat1048) + write(pp, flat1048) return nothing else - fields1042 = msg + fields1045 = msg write(pp, "|") - if !isempty(fields1042) + if !isempty(fields1045) write(pp, " ") - for (i1747, elem1043) in enumerate(fields1042) - i1044 = i1747 - 1 - if (i1044 > 0) + for (i1753, elem1046) in enumerate(fields1045) + i1047 = i1753 - 1 + if (i1047 > 0) newline(pp) end - pretty_binding(pp, elem1043) + pretty_binding(pp, elem1046) end end end @@ -1760,153 +1764,153 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat1072 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat1072) - write(pp, flat1072) + flat1075 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat1075) + write(pp, flat1075) return nothing else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1748 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1754 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1748 = nothing + _t1754 = nothing end - deconstruct_result1070 = _t1748 - if !isnothing(deconstruct_result1070) - unwrapped1071 = deconstruct_result1070 - pretty_true(pp, unwrapped1071) + deconstruct_result1073 = _t1754 + if !isnothing(deconstruct_result1073) + unwrapped1074 = deconstruct_result1073 + pretty_true(pp, unwrapped1074) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1749 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1755 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1749 = nothing + _t1755 = nothing end - deconstruct_result1068 = _t1749 - if !isnothing(deconstruct_result1068) - unwrapped1069 = deconstruct_result1068 - pretty_false(pp, unwrapped1069) + deconstruct_result1071 = _t1755 + if !isnothing(deconstruct_result1071) + unwrapped1072 = deconstruct_result1071 + pretty_false(pp, unwrapped1072) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1750 = _get_oneof_field(_dollar_dollar, :exists) + _t1756 = _get_oneof_field(_dollar_dollar, :exists) else - _t1750 = nothing + _t1756 = nothing end - deconstruct_result1066 = _t1750 - if !isnothing(deconstruct_result1066) - unwrapped1067 = deconstruct_result1066 - pretty_exists(pp, unwrapped1067) + deconstruct_result1069 = _t1756 + if !isnothing(deconstruct_result1069) + unwrapped1070 = deconstruct_result1069 + pretty_exists(pp, unwrapped1070) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1751 = _get_oneof_field(_dollar_dollar, :reduce) + _t1757 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1751 = nothing + _t1757 = nothing end - deconstruct_result1064 = _t1751 - if !isnothing(deconstruct_result1064) - unwrapped1065 = deconstruct_result1064 - pretty_reduce(pp, unwrapped1065) + deconstruct_result1067 = _t1757 + if !isnothing(deconstruct_result1067) + unwrapped1068 = deconstruct_result1067 + pretty_reduce(pp, unwrapped1068) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1752 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1758 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1752 = nothing + _t1758 = nothing end - deconstruct_result1062 = _t1752 - if !isnothing(deconstruct_result1062) - unwrapped1063 = deconstruct_result1062 - pretty_conjunction(pp, unwrapped1063) + deconstruct_result1065 = _t1758 + if !isnothing(deconstruct_result1065) + unwrapped1066 = deconstruct_result1065 + pretty_conjunction(pp, unwrapped1066) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1753 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1759 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1753 = nothing + _t1759 = nothing end - deconstruct_result1060 = _t1753 - if !isnothing(deconstruct_result1060) - unwrapped1061 = deconstruct_result1060 - pretty_disjunction(pp, unwrapped1061) + deconstruct_result1063 = _t1759 + if !isnothing(deconstruct_result1063) + unwrapped1064 = deconstruct_result1063 + pretty_disjunction(pp, unwrapped1064) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1754 = _get_oneof_field(_dollar_dollar, :not) + _t1760 = _get_oneof_field(_dollar_dollar, :not) else - _t1754 = nothing + _t1760 = nothing end - deconstruct_result1058 = _t1754 - if !isnothing(deconstruct_result1058) - unwrapped1059 = deconstruct_result1058 - pretty_not(pp, unwrapped1059) + deconstruct_result1061 = _t1760 + if !isnothing(deconstruct_result1061) + unwrapped1062 = deconstruct_result1061 + pretty_not(pp, unwrapped1062) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1755 = _get_oneof_field(_dollar_dollar, :ffi) + _t1761 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1755 = nothing + _t1761 = nothing end - deconstruct_result1056 = _t1755 - if !isnothing(deconstruct_result1056) - unwrapped1057 = deconstruct_result1056 - pretty_ffi(pp, unwrapped1057) + deconstruct_result1059 = _t1761 + if !isnothing(deconstruct_result1059) + unwrapped1060 = deconstruct_result1059 + pretty_ffi(pp, unwrapped1060) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1756 = _get_oneof_field(_dollar_dollar, :atom) + _t1762 = _get_oneof_field(_dollar_dollar, :atom) else - _t1756 = nothing + _t1762 = nothing end - deconstruct_result1054 = _t1756 - if !isnothing(deconstruct_result1054) - unwrapped1055 = deconstruct_result1054 - pretty_atom(pp, unwrapped1055) + deconstruct_result1057 = _t1762 + if !isnothing(deconstruct_result1057) + unwrapped1058 = deconstruct_result1057 + pretty_atom(pp, unwrapped1058) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1757 = _get_oneof_field(_dollar_dollar, :pragma) + _t1763 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1757 = nothing + _t1763 = nothing end - deconstruct_result1052 = _t1757 - if !isnothing(deconstruct_result1052) - unwrapped1053 = deconstruct_result1052 - pretty_pragma(pp, unwrapped1053) + deconstruct_result1055 = _t1763 + if !isnothing(deconstruct_result1055) + unwrapped1056 = deconstruct_result1055 + pretty_pragma(pp, unwrapped1056) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1758 = _get_oneof_field(_dollar_dollar, :primitive) + _t1764 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1758 = nothing + _t1764 = nothing end - deconstruct_result1050 = _t1758 - if !isnothing(deconstruct_result1050) - unwrapped1051 = deconstruct_result1050 - pretty_primitive(pp, unwrapped1051) + deconstruct_result1053 = _t1764 + if !isnothing(deconstruct_result1053) + unwrapped1054 = deconstruct_result1053 + pretty_primitive(pp, unwrapped1054) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1759 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1765 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1759 = nothing + _t1765 = nothing end - deconstruct_result1048 = _t1759 - if !isnothing(deconstruct_result1048) - unwrapped1049 = deconstruct_result1048 - pretty_rel_atom(pp, unwrapped1049) + deconstruct_result1051 = _t1765 + if !isnothing(deconstruct_result1051) + unwrapped1052 = deconstruct_result1051 + pretty_rel_atom(pp, unwrapped1052) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1760 = _get_oneof_field(_dollar_dollar, :cast) + _t1766 = _get_oneof_field(_dollar_dollar, :cast) else - _t1760 = nothing + _t1766 = nothing end - deconstruct_result1046 = _t1760 - if !isnothing(deconstruct_result1046) - unwrapped1047 = deconstruct_result1046 - pretty_cast(pp, unwrapped1047) + deconstruct_result1049 = _t1766 + if !isnothing(deconstruct_result1049) + unwrapped1050 = deconstruct_result1049 + pretty_cast(pp, unwrapped1050) else throw(ParseError("No matching rule for formula")) end @@ -1927,35 +1931,35 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields1073 = msg + fields1076 = msg write(pp, "(true)") return nothing end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields1074 = msg + fields1077 = msg write(pp, "(false)") return nothing end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat1079 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat1079) - write(pp, flat1079) + flat1082 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat1082) + write(pp, flat1082) return nothing else _dollar_dollar = msg - _t1761 = deconstruct_bindings(pp, _dollar_dollar.body) - fields1075 = (_t1761, _dollar_dollar.body.value,) - unwrapped_fields1076 = fields1075 + _t1767 = deconstruct_bindings(pp, _dollar_dollar.body) + fields1078 = (_t1767, _dollar_dollar.body.value,) + unwrapped_fields1079 = fields1078 write(pp, "(exists") indent_sexp!(pp) newline(pp) - field1077 = unwrapped_fields1076[1] - pretty_bindings(pp, field1077) + field1080 = unwrapped_fields1079[1] + pretty_bindings(pp, field1080) newline(pp) - field1078 = unwrapped_fields1076[2] - pretty_formula(pp, field1078) + field1081 = unwrapped_fields1079[2] + pretty_formula(pp, field1081) dedent!(pp) write(pp, ")") end @@ -1963,25 +1967,25 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat1085 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat1085) - write(pp, flat1085) + flat1088 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat1088) + write(pp, flat1088) return nothing else _dollar_dollar = msg - fields1080 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - unwrapped_fields1081 = fields1080 + fields1083 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + unwrapped_fields1084 = fields1083 write(pp, "(reduce") indent_sexp!(pp) newline(pp) - field1082 = unwrapped_fields1081[1] - pretty_abstraction(pp, field1082) + field1085 = unwrapped_fields1084[1] + pretty_abstraction(pp, field1085) newline(pp) - field1083 = unwrapped_fields1081[2] - pretty_abstraction(pp, field1083) + field1086 = unwrapped_fields1084[2] + pretty_abstraction(pp, field1086) newline(pp) - field1084 = unwrapped_fields1081[3] - pretty_terms(pp, field1084) + field1087 = unwrapped_fields1084[3] + pretty_terms(pp, field1087) dedent!(pp) write(pp, ")") end @@ -1989,22 +1993,22 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat1089 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat1089) - write(pp, flat1089) + flat1092 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat1092) + write(pp, flat1092) return nothing else - fields1086 = msg + fields1089 = msg write(pp, "(terms") indent_sexp!(pp) - if !isempty(fields1086) + if !isempty(fields1089) newline(pp) - for (i1762, elem1087) in enumerate(fields1086) - i1088 = i1762 - 1 - if (i1088 > 0) + for (i1768, elem1090) in enumerate(fields1089) + i1091 = i1768 - 1 + if (i1091 > 0) newline(pp) end - pretty_term(pp, elem1087) + pretty_term(pp, elem1090) end end dedent!(pp) @@ -2014,32 +2018,32 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat1094 = try_flat(pp, msg, pretty_term) - if !isnothing(flat1094) - write(pp, flat1094) + flat1097 = try_flat(pp, msg, pretty_term) + if !isnothing(flat1097) + write(pp, flat1097) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1763 = _get_oneof_field(_dollar_dollar, :var) + _t1769 = _get_oneof_field(_dollar_dollar, :var) else - _t1763 = nothing + _t1769 = nothing end - deconstruct_result1092 = _t1763 - if !isnothing(deconstruct_result1092) - unwrapped1093 = deconstruct_result1092 - pretty_var(pp, unwrapped1093) + deconstruct_result1095 = _t1769 + if !isnothing(deconstruct_result1095) + unwrapped1096 = deconstruct_result1095 + pretty_var(pp, unwrapped1096) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1764 = _get_oneof_field(_dollar_dollar, :constant) + _t1770 = _get_oneof_field(_dollar_dollar, :constant) else - _t1764 = nothing + _t1770 = nothing end - deconstruct_result1090 = _t1764 - if !isnothing(deconstruct_result1090) - unwrapped1091 = deconstruct_result1090 - pretty_value(pp, unwrapped1091) + deconstruct_result1093 = _t1770 + if !isnothing(deconstruct_result1093) + unwrapped1094 = deconstruct_result1093 + pretty_value(pp, unwrapped1094) else throw(ParseError("No matching rule for term")) end @@ -2049,158 +2053,158 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat1097 = try_flat(pp, msg, pretty_var) - if !isnothing(flat1097) - write(pp, flat1097) + flat1100 = try_flat(pp, msg, pretty_var) + if !isnothing(flat1100) + write(pp, flat1100) return nothing else _dollar_dollar = msg - fields1095 = _dollar_dollar.name - unwrapped_fields1096 = fields1095 - write(pp, unwrapped_fields1096) + fields1098 = _dollar_dollar.name + unwrapped_fields1099 = fields1098 + write(pp, unwrapped_fields1099) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat1123 = try_flat(pp, msg, pretty_value) - if !isnothing(flat1123) - write(pp, flat1123) + flat1126 = try_flat(pp, msg, pretty_value) + if !isnothing(flat1126) + write(pp, flat1126) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1765 = _get_oneof_field(_dollar_dollar, :date_value) + _t1771 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1765 = nothing + _t1771 = nothing end - deconstruct_result1121 = _t1765 - if !isnothing(deconstruct_result1121) - unwrapped1122 = deconstruct_result1121 - pretty_date(pp, unwrapped1122) + deconstruct_result1124 = _t1771 + if !isnothing(deconstruct_result1124) + unwrapped1125 = deconstruct_result1124 + pretty_date(pp, unwrapped1125) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1766 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1772 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1766 = nothing + _t1772 = nothing end - deconstruct_result1119 = _t1766 - if !isnothing(deconstruct_result1119) - unwrapped1120 = deconstruct_result1119 - pretty_datetime(pp, unwrapped1120) + deconstruct_result1122 = _t1772 + if !isnothing(deconstruct_result1122) + unwrapped1123 = deconstruct_result1122 + pretty_datetime(pp, unwrapped1123) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1767 = _get_oneof_field(_dollar_dollar, :string_value) + _t1773 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1767 = nothing + _t1773 = nothing end - deconstruct_result1117 = _t1767 - if !isnothing(deconstruct_result1117) - unwrapped1118 = deconstruct_result1117 - write(pp, format_string(pp, unwrapped1118)) + deconstruct_result1120 = _t1773 + if !isnothing(deconstruct_result1120) + unwrapped1121 = deconstruct_result1120 + write(pp, format_string(pp, unwrapped1121)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1768 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1774 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1768 = nothing + _t1774 = nothing end - deconstruct_result1115 = _t1768 - if !isnothing(deconstruct_result1115) - unwrapped1116 = deconstruct_result1115 - write(pp, format_int32(pp, unwrapped1116)) + deconstruct_result1118 = _t1774 + if !isnothing(deconstruct_result1118) + unwrapped1119 = deconstruct_result1118 + write(pp, format_int32(pp, unwrapped1119)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1769 = _get_oneof_field(_dollar_dollar, :int_value) + _t1775 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1769 = nothing + _t1775 = nothing end - deconstruct_result1113 = _t1769 - if !isnothing(deconstruct_result1113) - unwrapped1114 = deconstruct_result1113 - write(pp, format_int(pp, unwrapped1114)) + deconstruct_result1116 = _t1775 + if !isnothing(deconstruct_result1116) + unwrapped1117 = deconstruct_result1116 + write(pp, format_int(pp, unwrapped1117)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1770 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1776 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1770 = nothing + _t1776 = nothing end - deconstruct_result1111 = _t1770 - if !isnothing(deconstruct_result1111) - unwrapped1112 = deconstruct_result1111 - write(pp, format_float32(pp, unwrapped1112)) + deconstruct_result1114 = _t1776 + if !isnothing(deconstruct_result1114) + unwrapped1115 = deconstruct_result1114 + write(pp, format_float32(pp, unwrapped1115)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1771 = _get_oneof_field(_dollar_dollar, :float_value) + _t1777 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1771 = nothing + _t1777 = nothing end - deconstruct_result1109 = _t1771 - if !isnothing(deconstruct_result1109) - unwrapped1110 = deconstruct_result1109 - write(pp, format_float(pp, unwrapped1110)) + deconstruct_result1112 = _t1777 + if !isnothing(deconstruct_result1112) + unwrapped1113 = deconstruct_result1112 + write(pp, format_float(pp, unwrapped1113)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1772 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1778 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1772 = nothing + _t1778 = nothing end - deconstruct_result1107 = _t1772 - if !isnothing(deconstruct_result1107) - unwrapped1108 = deconstruct_result1107 - write(pp, format_uint32(pp, unwrapped1108)) + deconstruct_result1110 = _t1778 + if !isnothing(deconstruct_result1110) + unwrapped1111 = deconstruct_result1110 + write(pp, format_uint32(pp, unwrapped1111)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1773 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1779 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1773 = nothing + _t1779 = nothing end - deconstruct_result1105 = _t1773 - if !isnothing(deconstruct_result1105) - unwrapped1106 = deconstruct_result1105 - write(pp, format_uint128(pp, unwrapped1106)) + deconstruct_result1108 = _t1779 + if !isnothing(deconstruct_result1108) + unwrapped1109 = deconstruct_result1108 + write(pp, format_uint128(pp, unwrapped1109)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1774 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1780 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1774 = nothing + _t1780 = nothing end - deconstruct_result1103 = _t1774 - if !isnothing(deconstruct_result1103) - unwrapped1104 = deconstruct_result1103 - write(pp, format_int128(pp, unwrapped1104)) + deconstruct_result1106 = _t1780 + if !isnothing(deconstruct_result1106) + unwrapped1107 = deconstruct_result1106 + write(pp, format_int128(pp, unwrapped1107)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1775 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1781 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1775 = nothing + _t1781 = nothing end - deconstruct_result1101 = _t1775 - if !isnothing(deconstruct_result1101) - unwrapped1102 = deconstruct_result1101 - write(pp, format_decimal(pp, unwrapped1102)) + deconstruct_result1104 = _t1781 + if !isnothing(deconstruct_result1104) + unwrapped1105 = deconstruct_result1104 + write(pp, format_decimal(pp, unwrapped1105)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1776 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1782 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1776 = nothing + _t1782 = nothing end - deconstruct_result1099 = _t1776 - if !isnothing(deconstruct_result1099) - unwrapped1100 = deconstruct_result1099 - pretty_boolean_value(pp, unwrapped1100) + deconstruct_result1102 = _t1782 + if !isnothing(deconstruct_result1102) + unwrapped1103 = deconstruct_result1102 + pretty_boolean_value(pp, unwrapped1103) else - fields1098 = msg + fields1101 = msg write(pp, "missing") end end @@ -2219,25 +2223,25 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat1129 = try_flat(pp, msg, pretty_date) - if !isnothing(flat1129) - write(pp, flat1129) + flat1132 = try_flat(pp, msg, pretty_date) + if !isnothing(flat1132) + write(pp, flat1132) return nothing else _dollar_dollar = msg - fields1124 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields1125 = fields1124 + fields1127 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields1128 = fields1127 write(pp, "(date") indent_sexp!(pp) newline(pp) - field1126 = unwrapped_fields1125[1] - write(pp, format_int(pp, field1126)) + field1129 = unwrapped_fields1128[1] + write(pp, format_int(pp, field1129)) newline(pp) - field1127 = unwrapped_fields1125[2] - write(pp, format_int(pp, field1127)) + field1130 = unwrapped_fields1128[2] + write(pp, format_int(pp, field1130)) newline(pp) - field1128 = unwrapped_fields1125[3] - write(pp, format_int(pp, field1128)) + field1131 = unwrapped_fields1128[3] + write(pp, format_int(pp, field1131)) dedent!(pp) write(pp, ")") end @@ -2245,39 +2249,39 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat1140 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat1140) - write(pp, flat1140) + flat1143 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat1143) + write(pp, flat1143) return nothing else _dollar_dollar = msg - fields1130 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),) - unwrapped_fields1131 = fields1130 + fields1133 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),) + unwrapped_fields1134 = fields1133 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field1132 = unwrapped_fields1131[1] - write(pp, format_int(pp, field1132)) - newline(pp) - field1133 = unwrapped_fields1131[2] - write(pp, format_int(pp, field1133)) - newline(pp) - field1134 = unwrapped_fields1131[3] - write(pp, format_int(pp, field1134)) - newline(pp) - field1135 = unwrapped_fields1131[4] + field1135 = unwrapped_fields1134[1] write(pp, format_int(pp, field1135)) newline(pp) - field1136 = unwrapped_fields1131[5] + field1136 = unwrapped_fields1134[2] write(pp, format_int(pp, field1136)) newline(pp) - field1137 = unwrapped_fields1131[6] + field1137 = unwrapped_fields1134[3] write(pp, format_int(pp, field1137)) - field1138 = unwrapped_fields1131[7] - if !isnothing(field1138) + newline(pp) + field1138 = unwrapped_fields1134[4] + write(pp, format_int(pp, field1138)) + newline(pp) + field1139 = unwrapped_fields1134[5] + write(pp, format_int(pp, field1139)) + newline(pp) + field1140 = unwrapped_fields1134[6] + write(pp, format_int(pp, field1140)) + field1141 = unwrapped_fields1134[7] + if !isnothing(field1141) newline(pp) - opt_val1139 = field1138 - write(pp, format_int(pp, opt_val1139)) + opt_val1142 = field1141 + write(pp, format_int(pp, opt_val1142)) end dedent!(pp) write(pp, ")") @@ -2286,24 +2290,24 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat1145 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat1145) - write(pp, flat1145) + flat1148 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat1148) + write(pp, flat1148) return nothing else _dollar_dollar = msg - fields1141 = _dollar_dollar.args - unwrapped_fields1142 = fields1141 + fields1144 = _dollar_dollar.args + unwrapped_fields1145 = fields1144 write(pp, "(and") indent_sexp!(pp) - if !isempty(unwrapped_fields1142) + if !isempty(unwrapped_fields1145) newline(pp) - for (i1777, elem1143) in enumerate(unwrapped_fields1142) - i1144 = i1777 - 1 - if (i1144 > 0) + for (i1783, elem1146) in enumerate(unwrapped_fields1145) + i1147 = i1783 - 1 + if (i1147 > 0) newline(pp) end - pretty_formula(pp, elem1143) + pretty_formula(pp, elem1146) end end dedent!(pp) @@ -2313,24 +2317,24 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat1150 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat1150) - write(pp, flat1150) + flat1153 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat1153) + write(pp, flat1153) return nothing else _dollar_dollar = msg - fields1146 = _dollar_dollar.args - unwrapped_fields1147 = fields1146 + fields1149 = _dollar_dollar.args + unwrapped_fields1150 = fields1149 write(pp, "(or") indent_sexp!(pp) - if !isempty(unwrapped_fields1147) + if !isempty(unwrapped_fields1150) newline(pp) - for (i1778, elem1148) in enumerate(unwrapped_fields1147) - i1149 = i1778 - 1 - if (i1149 > 0) + for (i1784, elem1151) in enumerate(unwrapped_fields1150) + i1152 = i1784 - 1 + if (i1152 > 0) newline(pp) end - pretty_formula(pp, elem1148) + pretty_formula(pp, elem1151) end end dedent!(pp) @@ -2340,18 +2344,18 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat1153 = try_flat(pp, msg, pretty_not) - if !isnothing(flat1153) - write(pp, flat1153) + flat1156 = try_flat(pp, msg, pretty_not) + if !isnothing(flat1156) + write(pp, flat1156) return nothing else _dollar_dollar = msg - fields1151 = _dollar_dollar.arg - unwrapped_fields1152 = fields1151 + fields1154 = _dollar_dollar.arg + unwrapped_fields1155 = fields1154 write(pp, "(not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields1152) + pretty_formula(pp, unwrapped_fields1155) dedent!(pp) write(pp, ")") end @@ -2359,25 +2363,25 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat1159 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat1159) - write(pp, flat1159) + flat1162 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat1162) + write(pp, flat1162) return nothing else _dollar_dollar = msg - fields1154 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - unwrapped_fields1155 = fields1154 + fields1157 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + unwrapped_fields1158 = fields1157 write(pp, "(ffi") indent_sexp!(pp) newline(pp) - field1156 = unwrapped_fields1155[1] - pretty_name(pp, field1156) + field1159 = unwrapped_fields1158[1] + pretty_name(pp, field1159) newline(pp) - field1157 = unwrapped_fields1155[2] - pretty_ffi_args(pp, field1157) + field1160 = unwrapped_fields1158[2] + pretty_ffi_args(pp, field1160) newline(pp) - field1158 = unwrapped_fields1155[3] - pretty_terms(pp, field1158) + field1161 = unwrapped_fields1158[3] + pretty_terms(pp, field1161) dedent!(pp) write(pp, ")") end @@ -2385,35 +2389,35 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat1161 = try_flat(pp, msg, pretty_name) - if !isnothing(flat1161) - write(pp, flat1161) + flat1164 = try_flat(pp, msg, pretty_name) + if !isnothing(flat1164) + write(pp, flat1164) return nothing else - fields1160 = msg + fields1163 = msg write(pp, ":") - write(pp, fields1160) + write(pp, fields1163) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat1165 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat1165) - write(pp, flat1165) + flat1168 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat1168) + write(pp, flat1168) return nothing else - fields1162 = msg + fields1165 = msg write(pp, "(args") indent_sexp!(pp) - if !isempty(fields1162) + if !isempty(fields1165) newline(pp) - for (i1779, elem1163) in enumerate(fields1162) - i1164 = i1779 - 1 - if (i1164 > 0) + for (i1785, elem1166) in enumerate(fields1165) + i1167 = i1785 - 1 + if (i1167 > 0) newline(pp) end - pretty_abstraction(pp, elem1163) + pretty_abstraction(pp, elem1166) end end dedent!(pp) @@ -2423,28 +2427,28 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat1172 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat1172) - write(pp, flat1172) + flat1175 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat1175) + write(pp, flat1175) return nothing else _dollar_dollar = msg - fields1166 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1167 = fields1166 + fields1169 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1170 = fields1169 write(pp, "(atom") indent_sexp!(pp) newline(pp) - field1168 = unwrapped_fields1167[1] - pretty_relation_id(pp, field1168) - field1169 = unwrapped_fields1167[2] - if !isempty(field1169) + field1171 = unwrapped_fields1170[1] + pretty_relation_id(pp, field1171) + field1172 = unwrapped_fields1170[2] + if !isempty(field1172) newline(pp) - for (i1780, elem1170) in enumerate(field1169) - i1171 = i1780 - 1 - if (i1171 > 0) + for (i1786, elem1173) in enumerate(field1172) + i1174 = i1786 - 1 + if (i1174 > 0) newline(pp) end - pretty_term(pp, elem1170) + pretty_term(pp, elem1173) end end dedent!(pp) @@ -2454,28 +2458,28 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat1179 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat1179) - write(pp, flat1179) + flat1182 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat1182) + write(pp, flat1182) return nothing else _dollar_dollar = msg - fields1173 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1174 = fields1173 + fields1176 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1177 = fields1176 write(pp, "(pragma") indent_sexp!(pp) newline(pp) - field1175 = unwrapped_fields1174[1] - pretty_name(pp, field1175) - field1176 = unwrapped_fields1174[2] - if !isempty(field1176) + field1178 = unwrapped_fields1177[1] + pretty_name(pp, field1178) + field1179 = unwrapped_fields1177[2] + if !isempty(field1179) newline(pp) - for (i1781, elem1177) in enumerate(field1176) - i1178 = i1781 - 1 - if (i1178 > 0) + for (i1787, elem1180) in enumerate(field1179) + i1181 = i1787 - 1 + if (i1181 > 0) newline(pp) end - pretty_term(pp, elem1177) + pretty_term(pp, elem1180) end end dedent!(pp) @@ -2485,118 +2489,118 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat1195 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat1195) - write(pp, flat1195) + flat1198 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat1198) + write(pp, flat1198) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1782 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1788 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1782 = nothing + _t1788 = nothing end - guard_result1194 = _t1782 - if !isnothing(guard_result1194) + guard_result1197 = _t1788 + if !isnothing(guard_result1197) pretty_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1783 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1789 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1783 = nothing + _t1789 = nothing end - guard_result1193 = _t1783 - if !isnothing(guard_result1193) + guard_result1196 = _t1789 + if !isnothing(guard_result1196) pretty_lt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1784 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1790 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1784 = nothing + _t1790 = nothing end - guard_result1192 = _t1784 - if !isnothing(guard_result1192) + guard_result1195 = _t1790 + if !isnothing(guard_result1195) pretty_lt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1785 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1791 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1785 = nothing + _t1791 = nothing end - guard_result1191 = _t1785 - if !isnothing(guard_result1191) + guard_result1194 = _t1791 + if !isnothing(guard_result1194) pretty_gt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1786 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1792 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1786 = nothing + _t1792 = nothing end - guard_result1190 = _t1786 - if !isnothing(guard_result1190) + guard_result1193 = _t1792 + if !isnothing(guard_result1193) pretty_gt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1787 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1793 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1787 = nothing + _t1793 = nothing end - guard_result1189 = _t1787 - if !isnothing(guard_result1189) + guard_result1192 = _t1793 + if !isnothing(guard_result1192) pretty_add(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1788 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1794 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1788 = nothing + _t1794 = nothing end - guard_result1188 = _t1788 - if !isnothing(guard_result1188) + guard_result1191 = _t1794 + if !isnothing(guard_result1191) pretty_minus(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1789 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1795 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1789 = nothing + _t1795 = nothing end - guard_result1187 = _t1789 - if !isnothing(guard_result1187) + guard_result1190 = _t1795 + if !isnothing(guard_result1190) pretty_multiply(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1790 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1796 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1790 = nothing + _t1796 = nothing end - guard_result1186 = _t1790 - if !isnothing(guard_result1186) + guard_result1189 = _t1796 + if !isnothing(guard_result1189) pretty_divide(pp, msg) else _dollar_dollar = msg - fields1180 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1181 = fields1180 + fields1183 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1184 = fields1183 write(pp, "(primitive") indent_sexp!(pp) newline(pp) - field1182 = unwrapped_fields1181[1] - pretty_name(pp, field1182) - field1183 = unwrapped_fields1181[2] - if !isempty(field1183) + field1185 = unwrapped_fields1184[1] + pretty_name(pp, field1185) + field1186 = unwrapped_fields1184[2] + if !isempty(field1186) newline(pp) - for (i1791, elem1184) in enumerate(field1183) - i1185 = i1791 - 1 - if (i1185 > 0) + for (i1797, elem1187) in enumerate(field1186) + i1188 = i1797 - 1 + if (i1188 > 0) newline(pp) end - pretty_rel_term(pp, elem1184) + pretty_rel_term(pp, elem1187) end end dedent!(pp) @@ -2615,27 +2619,27 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1200 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat1200) - write(pp, flat1200) + flat1203 = try_flat(pp, msg, pretty_eq) + if !isnothing(flat1203) + write(pp, flat1203) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1792 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1798 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1792 = nothing + _t1798 = nothing end - fields1196 = _t1792 - unwrapped_fields1197 = fields1196 + fields1199 = _t1798 + unwrapped_fields1200 = fields1199 write(pp, "(=") indent_sexp!(pp) newline(pp) - field1198 = unwrapped_fields1197[1] - pretty_term(pp, field1198) + field1201 = unwrapped_fields1200[1] + pretty_term(pp, field1201) newline(pp) - field1199 = unwrapped_fields1197[2] - pretty_term(pp, field1199) + field1202 = unwrapped_fields1200[2] + pretty_term(pp, field1202) dedent!(pp) write(pp, ")") end @@ -2643,27 +2647,27 @@ function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1205 = try_flat(pp, msg, pretty_lt) - if !isnothing(flat1205) - write(pp, flat1205) + flat1208 = try_flat(pp, msg, pretty_lt) + if !isnothing(flat1208) + write(pp, flat1208) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1793 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1799 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1793 = nothing + _t1799 = nothing end - fields1201 = _t1793 - unwrapped_fields1202 = fields1201 + fields1204 = _t1799 + unwrapped_fields1205 = fields1204 write(pp, "(<") indent_sexp!(pp) newline(pp) - field1203 = unwrapped_fields1202[1] - pretty_term(pp, field1203) + field1206 = unwrapped_fields1205[1] + pretty_term(pp, field1206) newline(pp) - field1204 = unwrapped_fields1202[2] - pretty_term(pp, field1204) + field1207 = unwrapped_fields1205[2] + pretty_term(pp, field1207) dedent!(pp) write(pp, ")") end @@ -2671,27 +2675,27 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1210 = try_flat(pp, msg, pretty_lt_eq) - if !isnothing(flat1210) - write(pp, flat1210) + flat1213 = try_flat(pp, msg, pretty_lt_eq) + if !isnothing(flat1213) + write(pp, flat1213) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1794 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1800 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1794 = nothing + _t1800 = nothing end - fields1206 = _t1794 - unwrapped_fields1207 = fields1206 + fields1209 = _t1800 + unwrapped_fields1210 = fields1209 write(pp, "(<=") indent_sexp!(pp) newline(pp) - field1208 = unwrapped_fields1207[1] - pretty_term(pp, field1208) + field1211 = unwrapped_fields1210[1] + pretty_term(pp, field1211) newline(pp) - field1209 = unwrapped_fields1207[2] - pretty_term(pp, field1209) + field1212 = unwrapped_fields1210[2] + pretty_term(pp, field1212) dedent!(pp) write(pp, ")") end @@ -2699,27 +2703,27 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1215 = try_flat(pp, msg, pretty_gt) - if !isnothing(flat1215) - write(pp, flat1215) + flat1218 = try_flat(pp, msg, pretty_gt) + if !isnothing(flat1218) + write(pp, flat1218) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1795 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1801 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1795 = nothing + _t1801 = nothing end - fields1211 = _t1795 - unwrapped_fields1212 = fields1211 + fields1214 = _t1801 + unwrapped_fields1215 = fields1214 write(pp, "(>") indent_sexp!(pp) newline(pp) - field1213 = unwrapped_fields1212[1] - pretty_term(pp, field1213) + field1216 = unwrapped_fields1215[1] + pretty_term(pp, field1216) newline(pp) - field1214 = unwrapped_fields1212[2] - pretty_term(pp, field1214) + field1217 = unwrapped_fields1215[2] + pretty_term(pp, field1217) dedent!(pp) write(pp, ")") end @@ -2727,27 +2731,27 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1220 = try_flat(pp, msg, pretty_gt_eq) - if !isnothing(flat1220) - write(pp, flat1220) + flat1223 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat1223) + write(pp, flat1223) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1796 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1802 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1796 = nothing + _t1802 = nothing end - fields1216 = _t1796 - unwrapped_fields1217 = fields1216 + fields1219 = _t1802 + unwrapped_fields1220 = fields1219 write(pp, "(>=") indent_sexp!(pp) newline(pp) - field1218 = unwrapped_fields1217[1] - pretty_term(pp, field1218) + field1221 = unwrapped_fields1220[1] + pretty_term(pp, field1221) newline(pp) - field1219 = unwrapped_fields1217[2] - pretty_term(pp, field1219) + field1222 = unwrapped_fields1220[2] + pretty_term(pp, field1222) dedent!(pp) write(pp, ")") end @@ -2755,30 +2759,30 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat1226 = try_flat(pp, msg, pretty_add) - if !isnothing(flat1226) - write(pp, flat1226) + flat1229 = try_flat(pp, msg, pretty_add) + if !isnothing(flat1229) + write(pp, flat1229) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1797 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1803 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1797 = nothing + _t1803 = nothing end - fields1221 = _t1797 - unwrapped_fields1222 = fields1221 + fields1224 = _t1803 + unwrapped_fields1225 = fields1224 write(pp, "(+") indent_sexp!(pp) newline(pp) - field1223 = unwrapped_fields1222[1] - pretty_term(pp, field1223) + field1226 = unwrapped_fields1225[1] + pretty_term(pp, field1226) newline(pp) - field1224 = unwrapped_fields1222[2] - pretty_term(pp, field1224) + field1227 = unwrapped_fields1225[2] + pretty_term(pp, field1227) newline(pp) - field1225 = unwrapped_fields1222[3] - pretty_term(pp, field1225) + field1228 = unwrapped_fields1225[3] + pretty_term(pp, field1228) dedent!(pp) write(pp, ")") end @@ -2786,30 +2790,30 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat1232 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat1232) - write(pp, flat1232) + flat1235 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat1235) + write(pp, flat1235) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1798 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1804 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1798 = nothing + _t1804 = nothing end - fields1227 = _t1798 - unwrapped_fields1228 = fields1227 + fields1230 = _t1804 + unwrapped_fields1231 = fields1230 write(pp, "(-") indent_sexp!(pp) newline(pp) - field1229 = unwrapped_fields1228[1] - pretty_term(pp, field1229) + field1232 = unwrapped_fields1231[1] + pretty_term(pp, field1232) newline(pp) - field1230 = unwrapped_fields1228[2] - pretty_term(pp, field1230) + field1233 = unwrapped_fields1231[2] + pretty_term(pp, field1233) newline(pp) - field1231 = unwrapped_fields1228[3] - pretty_term(pp, field1231) + field1234 = unwrapped_fields1231[3] + pretty_term(pp, field1234) dedent!(pp) write(pp, ")") end @@ -2817,30 +2821,30 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat1238 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat1238) - write(pp, flat1238) + flat1241 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat1241) + write(pp, flat1241) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1799 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1805 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1799 = nothing + _t1805 = nothing end - fields1233 = _t1799 - unwrapped_fields1234 = fields1233 + fields1236 = _t1805 + unwrapped_fields1237 = fields1236 write(pp, "(*") indent_sexp!(pp) newline(pp) - field1235 = unwrapped_fields1234[1] - pretty_term(pp, field1235) + field1238 = unwrapped_fields1237[1] + pretty_term(pp, field1238) newline(pp) - field1236 = unwrapped_fields1234[2] - pretty_term(pp, field1236) + field1239 = unwrapped_fields1237[2] + pretty_term(pp, field1239) newline(pp) - field1237 = unwrapped_fields1234[3] - pretty_term(pp, field1237) + field1240 = unwrapped_fields1237[3] + pretty_term(pp, field1240) dedent!(pp) write(pp, ")") end @@ -2848,30 +2852,30 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat1244 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat1244) - write(pp, flat1244) + flat1247 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat1247) + write(pp, flat1247) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1800 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1806 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1800 = nothing + _t1806 = nothing end - fields1239 = _t1800 - unwrapped_fields1240 = fields1239 + fields1242 = _t1806 + unwrapped_fields1243 = fields1242 write(pp, "(/") indent_sexp!(pp) newline(pp) - field1241 = unwrapped_fields1240[1] - pretty_term(pp, field1241) + field1244 = unwrapped_fields1243[1] + pretty_term(pp, field1244) newline(pp) - field1242 = unwrapped_fields1240[2] - pretty_term(pp, field1242) + field1245 = unwrapped_fields1243[2] + pretty_term(pp, field1245) newline(pp) - field1243 = unwrapped_fields1240[3] - pretty_term(pp, field1243) + field1246 = unwrapped_fields1243[3] + pretty_term(pp, field1246) dedent!(pp) write(pp, ")") end @@ -2879,32 +2883,32 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat1249 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat1249) - write(pp, flat1249) + flat1252 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat1252) + write(pp, flat1252) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1801 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1807 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1801 = nothing + _t1807 = nothing end - deconstruct_result1247 = _t1801 - if !isnothing(deconstruct_result1247) - unwrapped1248 = deconstruct_result1247 - pretty_specialized_value(pp, unwrapped1248) + deconstruct_result1250 = _t1807 + if !isnothing(deconstruct_result1250) + unwrapped1251 = deconstruct_result1250 + pretty_specialized_value(pp, unwrapped1251) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1802 = _get_oneof_field(_dollar_dollar, :term) + _t1808 = _get_oneof_field(_dollar_dollar, :term) else - _t1802 = nothing + _t1808 = nothing end - deconstruct_result1245 = _t1802 - if !isnothing(deconstruct_result1245) - unwrapped1246 = deconstruct_result1245 - pretty_term(pp, unwrapped1246) + deconstruct_result1248 = _t1808 + if !isnothing(deconstruct_result1248) + unwrapped1249 = deconstruct_result1248 + pretty_term(pp, unwrapped1249) else throw(ParseError("No matching rule for rel_term")) end @@ -2914,41 +2918,41 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat1251 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat1251) - write(pp, flat1251) + flat1254 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat1254) + write(pp, flat1254) return nothing else - fields1250 = msg + fields1253 = msg write(pp, "#") - pretty_raw_value(pp, fields1250) + pretty_raw_value(pp, fields1253) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat1258 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat1258) - write(pp, flat1258) + flat1261 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat1261) + write(pp, flat1261) return nothing else _dollar_dollar = msg - fields1252 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1253 = fields1252 + fields1255 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1256 = fields1255 write(pp, "(relatom") indent_sexp!(pp) newline(pp) - field1254 = unwrapped_fields1253[1] - pretty_name(pp, field1254) - field1255 = unwrapped_fields1253[2] - if !isempty(field1255) + field1257 = unwrapped_fields1256[1] + pretty_name(pp, field1257) + field1258 = unwrapped_fields1256[2] + if !isempty(field1258) newline(pp) - for (i1803, elem1256) in enumerate(field1255) - i1257 = i1803 - 1 - if (i1257 > 0) + for (i1809, elem1259) in enumerate(field1258) + i1260 = i1809 - 1 + if (i1260 > 0) newline(pp) end - pretty_rel_term(pp, elem1256) + pretty_rel_term(pp, elem1259) end end dedent!(pp) @@ -2958,22 +2962,22 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat1263 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat1263) - write(pp, flat1263) + flat1266 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat1266) + write(pp, flat1266) return nothing else _dollar_dollar = msg - fields1259 = (_dollar_dollar.input, _dollar_dollar.result,) - unwrapped_fields1260 = fields1259 + fields1262 = (_dollar_dollar.input, _dollar_dollar.result,) + unwrapped_fields1263 = fields1262 write(pp, "(cast") indent_sexp!(pp) newline(pp) - field1261 = unwrapped_fields1260[1] - pretty_term(pp, field1261) + field1264 = unwrapped_fields1263[1] + pretty_term(pp, field1264) newline(pp) - field1262 = unwrapped_fields1260[2] - pretty_term(pp, field1262) + field1265 = unwrapped_fields1263[2] + pretty_term(pp, field1265) dedent!(pp) write(pp, ")") end @@ -2981,22 +2985,22 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat1267 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat1267) - write(pp, flat1267) + flat1270 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1270) + write(pp, flat1270) return nothing else - fields1264 = msg + fields1267 = msg write(pp, "(attrs") indent_sexp!(pp) - if !isempty(fields1264) + if !isempty(fields1267) newline(pp) - for (i1804, elem1265) in enumerate(fields1264) - i1266 = i1804 - 1 - if (i1266 > 0) + for (i1810, elem1268) in enumerate(fields1267) + i1269 = i1810 - 1 + if (i1269 > 0) newline(pp) end - pretty_attribute(pp, elem1265) + pretty_attribute(pp, elem1268) end end dedent!(pp) @@ -3006,28 +3010,28 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1274 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1274) - write(pp, flat1274) + flat1277 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1277) + write(pp, flat1277) return nothing else _dollar_dollar = msg - fields1268 = (_dollar_dollar.name, _dollar_dollar.args,) - unwrapped_fields1269 = fields1268 + fields1271 = (_dollar_dollar.name, _dollar_dollar.args,) + unwrapped_fields1272 = fields1271 write(pp, "(attribute") indent_sexp!(pp) newline(pp) - field1270 = unwrapped_fields1269[1] - pretty_name(pp, field1270) - field1271 = unwrapped_fields1269[2] - if !isempty(field1271) + field1273 = unwrapped_fields1272[1] + pretty_name(pp, field1273) + field1274 = unwrapped_fields1272[2] + if !isempty(field1274) newline(pp) - for (i1805, elem1272) in enumerate(field1271) - i1273 = i1805 - 1 - if (i1273 > 0) + for (i1811, elem1275) in enumerate(field1274) + i1276 = i1811 - 1 + if (i1276 > 0) newline(pp) end - pretty_raw_value(pp, elem1272) + pretty_raw_value(pp, elem1275) end end dedent!(pp) @@ -3037,40 +3041,40 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1283 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1283) - write(pp, flat1283) + flat1286 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1286) + write(pp, flat1286) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1806 = _dollar_dollar.attrs + _t1812 = _dollar_dollar.attrs else - _t1806 = nothing + _t1812 = nothing end - fields1275 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1806,) - unwrapped_fields1276 = fields1275 + fields1278 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1812,) + unwrapped_fields1279 = fields1278 write(pp, "(algorithm") indent_sexp!(pp) - field1277 = unwrapped_fields1276[1] - if !isempty(field1277) + field1280 = unwrapped_fields1279[1] + if !isempty(field1280) newline(pp) - for (i1807, elem1278) in enumerate(field1277) - i1279 = i1807 - 1 - if (i1279 > 0) + for (i1813, elem1281) in enumerate(field1280) + i1282 = i1813 - 1 + if (i1282 > 0) newline(pp) end - pretty_relation_id(pp, elem1278) + pretty_relation_id(pp, elem1281) end end newline(pp) - field1280 = unwrapped_fields1276[2] - pretty_script(pp, field1280) - field1281 = unwrapped_fields1276[3] - if !isnothing(field1281) + field1283 = unwrapped_fields1279[2] + pretty_script(pp, field1283) + field1284 = unwrapped_fields1279[3] + if !isnothing(field1284) newline(pp) - opt_val1282 = field1281 - pretty_attrs(pp, opt_val1282) + opt_val1285 = field1284 + pretty_attrs(pp, opt_val1285) end dedent!(pp) write(pp, ")") @@ -3079,24 +3083,24 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1288 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1288) - write(pp, flat1288) + flat1291 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1291) + write(pp, flat1291) return nothing else _dollar_dollar = msg - fields1284 = _dollar_dollar.constructs - unwrapped_fields1285 = fields1284 + fields1287 = _dollar_dollar.constructs + unwrapped_fields1288 = fields1287 write(pp, "(script") indent_sexp!(pp) - if !isempty(unwrapped_fields1285) + if !isempty(unwrapped_fields1288) newline(pp) - for (i1808, elem1286) in enumerate(unwrapped_fields1285) - i1287 = i1808 - 1 - if (i1287 > 0) + for (i1814, elem1289) in enumerate(unwrapped_fields1288) + i1290 = i1814 - 1 + if (i1290 > 0) newline(pp) end - pretty_construct(pp, elem1286) + pretty_construct(pp, elem1289) end end dedent!(pp) @@ -3106,32 +3110,32 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1293 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1293) - write(pp, flat1293) + flat1296 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1296) + write(pp, flat1296) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1809 = _get_oneof_field(_dollar_dollar, :loop) + _t1815 = _get_oneof_field(_dollar_dollar, :loop) else - _t1809 = nothing + _t1815 = nothing end - deconstruct_result1291 = _t1809 - if !isnothing(deconstruct_result1291) - unwrapped1292 = deconstruct_result1291 - pretty_loop(pp, unwrapped1292) + deconstruct_result1294 = _t1815 + if !isnothing(deconstruct_result1294) + unwrapped1295 = deconstruct_result1294 + pretty_loop(pp, unwrapped1295) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1810 = _get_oneof_field(_dollar_dollar, :instruction) + _t1816 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1810 = nothing + _t1816 = nothing end - deconstruct_result1289 = _t1810 - if !isnothing(deconstruct_result1289) - unwrapped1290 = deconstruct_result1289 - pretty_instruction(pp, unwrapped1290) + deconstruct_result1292 = _t1816 + if !isnothing(deconstruct_result1292) + unwrapped1293 = deconstruct_result1292 + pretty_instruction(pp, unwrapped1293) else throw(ParseError("No matching rule for construct")) end @@ -3141,32 +3145,32 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1300 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1300) - write(pp, flat1300) + flat1303 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1303) + write(pp, flat1303) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1811 = _dollar_dollar.attrs + _t1817 = _dollar_dollar.attrs else - _t1811 = nothing + _t1817 = nothing end - fields1294 = (_dollar_dollar.init, _dollar_dollar.body, _t1811,) - unwrapped_fields1295 = fields1294 + fields1297 = (_dollar_dollar.init, _dollar_dollar.body, _t1817,) + unwrapped_fields1298 = fields1297 write(pp, "(loop") indent_sexp!(pp) newline(pp) - field1296 = unwrapped_fields1295[1] - pretty_init(pp, field1296) + field1299 = unwrapped_fields1298[1] + pretty_init(pp, field1299) newline(pp) - field1297 = unwrapped_fields1295[2] - pretty_script(pp, field1297) - field1298 = unwrapped_fields1295[3] - if !isnothing(field1298) + field1300 = unwrapped_fields1298[2] + pretty_script(pp, field1300) + field1301 = unwrapped_fields1298[3] + if !isnothing(field1301) newline(pp) - opt_val1299 = field1298 - pretty_attrs(pp, opt_val1299) + opt_val1302 = field1301 + pretty_attrs(pp, opt_val1302) end dedent!(pp) write(pp, ")") @@ -3175,22 +3179,22 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1304 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1304) - write(pp, flat1304) + flat1307 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1307) + write(pp, flat1307) return nothing else - fields1301 = msg + fields1304 = msg write(pp, "(init") indent_sexp!(pp) - if !isempty(fields1301) + if !isempty(fields1304) newline(pp) - for (i1812, elem1302) in enumerate(fields1301) - i1303 = i1812 - 1 - if (i1303 > 0) + for (i1818, elem1305) in enumerate(fields1304) + i1306 = i1818 - 1 + if (i1306 > 0) newline(pp) end - pretty_instruction(pp, elem1302) + pretty_instruction(pp, elem1305) end end dedent!(pp) @@ -3200,65 +3204,65 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1315 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1315) - write(pp, flat1315) + flat1318 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1318) + write(pp, flat1318) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1813 = _get_oneof_field(_dollar_dollar, :assign) + _t1819 = _get_oneof_field(_dollar_dollar, :assign) else - _t1813 = nothing + _t1819 = nothing end - deconstruct_result1313 = _t1813 - if !isnothing(deconstruct_result1313) - unwrapped1314 = deconstruct_result1313 - pretty_assign(pp, unwrapped1314) + deconstruct_result1316 = _t1819 + if !isnothing(deconstruct_result1316) + unwrapped1317 = deconstruct_result1316 + pretty_assign(pp, unwrapped1317) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1814 = _get_oneof_field(_dollar_dollar, :upsert) + _t1820 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1814 = nothing + _t1820 = nothing end - deconstruct_result1311 = _t1814 - if !isnothing(deconstruct_result1311) - unwrapped1312 = deconstruct_result1311 - pretty_upsert(pp, unwrapped1312) + deconstruct_result1314 = _t1820 + if !isnothing(deconstruct_result1314) + unwrapped1315 = deconstruct_result1314 + pretty_upsert(pp, unwrapped1315) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1815 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1821 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1815 = nothing + _t1821 = nothing end - deconstruct_result1309 = _t1815 - if !isnothing(deconstruct_result1309) - unwrapped1310 = deconstruct_result1309 - pretty_break(pp, unwrapped1310) + deconstruct_result1312 = _t1821 + if !isnothing(deconstruct_result1312) + unwrapped1313 = deconstruct_result1312 + pretty_break(pp, unwrapped1313) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1816 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1822 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1816 = nothing + _t1822 = nothing end - deconstruct_result1307 = _t1816 - if !isnothing(deconstruct_result1307) - unwrapped1308 = deconstruct_result1307 - pretty_monoid_def(pp, unwrapped1308) + deconstruct_result1310 = _t1822 + if !isnothing(deconstruct_result1310) + unwrapped1311 = deconstruct_result1310 + pretty_monoid_def(pp, unwrapped1311) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1817 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1823 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1817 = nothing + _t1823 = nothing end - deconstruct_result1305 = _t1817 - if !isnothing(deconstruct_result1305) - unwrapped1306 = deconstruct_result1305 - pretty_monus_def(pp, unwrapped1306) + deconstruct_result1308 = _t1823 + if !isnothing(deconstruct_result1308) + unwrapped1309 = deconstruct_result1308 + pretty_monus_def(pp, unwrapped1309) else throw(ParseError("No matching rule for instruction")) end @@ -3271,32 +3275,32 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1322 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1322) - write(pp, flat1322) + flat1325 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1325) + write(pp, flat1325) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1818 = _dollar_dollar.attrs + _t1824 = _dollar_dollar.attrs else - _t1818 = nothing + _t1824 = nothing end - fields1316 = (_dollar_dollar.name, _dollar_dollar.body, _t1818,) - unwrapped_fields1317 = fields1316 + fields1319 = (_dollar_dollar.name, _dollar_dollar.body, _t1824,) + unwrapped_fields1320 = fields1319 write(pp, "(assign") indent_sexp!(pp) newline(pp) - field1318 = unwrapped_fields1317[1] - pretty_relation_id(pp, field1318) + field1321 = unwrapped_fields1320[1] + pretty_relation_id(pp, field1321) newline(pp) - field1319 = unwrapped_fields1317[2] - pretty_abstraction(pp, field1319) - field1320 = unwrapped_fields1317[3] - if !isnothing(field1320) + field1322 = unwrapped_fields1320[2] + pretty_abstraction(pp, field1322) + field1323 = unwrapped_fields1320[3] + if !isnothing(field1323) newline(pp) - opt_val1321 = field1320 - pretty_attrs(pp, opt_val1321) + opt_val1324 = field1323 + pretty_attrs(pp, opt_val1324) end dedent!(pp) write(pp, ")") @@ -3305,32 +3309,32 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1329 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1329) - write(pp, flat1329) + flat1332 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1332) + write(pp, flat1332) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1819 = _dollar_dollar.attrs + _t1825 = _dollar_dollar.attrs else - _t1819 = nothing + _t1825 = nothing end - fields1323 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1819,) - unwrapped_fields1324 = fields1323 + fields1326 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1825,) + unwrapped_fields1327 = fields1326 write(pp, "(upsert") indent_sexp!(pp) newline(pp) - field1325 = unwrapped_fields1324[1] - pretty_relation_id(pp, field1325) + field1328 = unwrapped_fields1327[1] + pretty_relation_id(pp, field1328) newline(pp) - field1326 = unwrapped_fields1324[2] - pretty_abstraction_with_arity(pp, field1326) - field1327 = unwrapped_fields1324[3] - if !isnothing(field1327) + field1329 = unwrapped_fields1327[2] + pretty_abstraction_with_arity(pp, field1329) + field1330 = unwrapped_fields1327[3] + if !isnothing(field1330) newline(pp) - opt_val1328 = field1327 - pretty_attrs(pp, opt_val1328) + opt_val1331 = field1330 + pretty_attrs(pp, opt_val1331) end dedent!(pp) write(pp, ")") @@ -3339,22 +3343,22 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1334 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1334) - write(pp, flat1334) + flat1337 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1337) + write(pp, flat1337) return nothing else _dollar_dollar = msg - _t1820 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - fields1330 = (_t1820, _dollar_dollar[1].value,) - unwrapped_fields1331 = fields1330 + _t1826 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + fields1333 = (_t1826, _dollar_dollar[1].value,) + unwrapped_fields1334 = fields1333 write(pp, "(") indent!(pp) - field1332 = unwrapped_fields1331[1] - pretty_bindings(pp, field1332) + field1335 = unwrapped_fields1334[1] + pretty_bindings(pp, field1335) newline(pp) - field1333 = unwrapped_fields1331[2] - pretty_formula(pp, field1333) + field1336 = unwrapped_fields1334[2] + pretty_formula(pp, field1336) dedent!(pp) write(pp, ")") end @@ -3362,32 +3366,32 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1341 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1341) - write(pp, flat1341) + flat1344 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1344) + write(pp, flat1344) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1821 = _dollar_dollar.attrs + _t1827 = _dollar_dollar.attrs else - _t1821 = nothing + _t1827 = nothing end - fields1335 = (_dollar_dollar.name, _dollar_dollar.body, _t1821,) - unwrapped_fields1336 = fields1335 + fields1338 = (_dollar_dollar.name, _dollar_dollar.body, _t1827,) + unwrapped_fields1339 = fields1338 write(pp, "(break") indent_sexp!(pp) newline(pp) - field1337 = unwrapped_fields1336[1] - pretty_relation_id(pp, field1337) + field1340 = unwrapped_fields1339[1] + pretty_relation_id(pp, field1340) newline(pp) - field1338 = unwrapped_fields1336[2] - pretty_abstraction(pp, field1338) - field1339 = unwrapped_fields1336[3] - if !isnothing(field1339) + field1341 = unwrapped_fields1339[2] + pretty_abstraction(pp, field1341) + field1342 = unwrapped_fields1339[3] + if !isnothing(field1342) newline(pp) - opt_val1340 = field1339 - pretty_attrs(pp, opt_val1340) + opt_val1343 = field1342 + pretty_attrs(pp, opt_val1343) end dedent!(pp) write(pp, ")") @@ -3396,35 +3400,35 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1349 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1349) - write(pp, flat1349) + flat1352 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1352) + write(pp, flat1352) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1822 = _dollar_dollar.attrs + _t1828 = _dollar_dollar.attrs else - _t1822 = nothing + _t1828 = nothing end - fields1342 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1822,) - unwrapped_fields1343 = fields1342 + fields1345 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1828,) + unwrapped_fields1346 = fields1345 write(pp, "(monoid") indent_sexp!(pp) newline(pp) - field1344 = unwrapped_fields1343[1] - pretty_monoid(pp, field1344) + field1347 = unwrapped_fields1346[1] + pretty_monoid(pp, field1347) newline(pp) - field1345 = unwrapped_fields1343[2] - pretty_relation_id(pp, field1345) + field1348 = unwrapped_fields1346[2] + pretty_relation_id(pp, field1348) newline(pp) - field1346 = unwrapped_fields1343[3] - pretty_abstraction_with_arity(pp, field1346) - field1347 = unwrapped_fields1343[4] - if !isnothing(field1347) + field1349 = unwrapped_fields1346[3] + pretty_abstraction_with_arity(pp, field1349) + field1350 = unwrapped_fields1346[4] + if !isnothing(field1350) newline(pp) - opt_val1348 = field1347 - pretty_attrs(pp, opt_val1348) + opt_val1351 = field1350 + pretty_attrs(pp, opt_val1351) end dedent!(pp) write(pp, ")") @@ -3433,54 +3437,54 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1358 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1358) - write(pp, flat1358) + flat1361 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1361) + write(pp, flat1361) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1823 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1829 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1823 = nothing + _t1829 = nothing end - deconstruct_result1356 = _t1823 - if !isnothing(deconstruct_result1356) - unwrapped1357 = deconstruct_result1356 - pretty_or_monoid(pp, unwrapped1357) + deconstruct_result1359 = _t1829 + if !isnothing(deconstruct_result1359) + unwrapped1360 = deconstruct_result1359 + pretty_or_monoid(pp, unwrapped1360) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1824 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1830 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1824 = nothing + _t1830 = nothing end - deconstruct_result1354 = _t1824 - if !isnothing(deconstruct_result1354) - unwrapped1355 = deconstruct_result1354 - pretty_min_monoid(pp, unwrapped1355) + deconstruct_result1357 = _t1830 + if !isnothing(deconstruct_result1357) + unwrapped1358 = deconstruct_result1357 + pretty_min_monoid(pp, unwrapped1358) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1825 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1831 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1825 = nothing + _t1831 = nothing end - deconstruct_result1352 = _t1825 - if !isnothing(deconstruct_result1352) - unwrapped1353 = deconstruct_result1352 - pretty_max_monoid(pp, unwrapped1353) + deconstruct_result1355 = _t1831 + if !isnothing(deconstruct_result1355) + unwrapped1356 = deconstruct_result1355 + pretty_max_monoid(pp, unwrapped1356) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1826 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1832 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1826 = nothing + _t1832 = nothing end - deconstruct_result1350 = _t1826 - if !isnothing(deconstruct_result1350) - unwrapped1351 = deconstruct_result1350 - pretty_sum_monoid(pp, unwrapped1351) + deconstruct_result1353 = _t1832 + if !isnothing(deconstruct_result1353) + unwrapped1354 = deconstruct_result1353 + pretty_sum_monoid(pp, unwrapped1354) else throw(ParseError("No matching rule for monoid")) end @@ -3492,24 +3496,24 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1359 = msg + fields1362 = msg write(pp, "(or)") return nothing end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1362 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1362) - write(pp, flat1362) + flat1365 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1365) + write(pp, flat1365) return nothing else _dollar_dollar = msg - fields1360 = _dollar_dollar.var"#type" - unwrapped_fields1361 = fields1360 + fields1363 = _dollar_dollar.var"#type" + unwrapped_fields1364 = fields1363 write(pp, "(min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1361) + pretty_type(pp, unwrapped_fields1364) dedent!(pp) write(pp, ")") end @@ -3517,18 +3521,18 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1365 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1365) - write(pp, flat1365) + flat1368 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1368) + write(pp, flat1368) return nothing else _dollar_dollar = msg - fields1363 = _dollar_dollar.var"#type" - unwrapped_fields1364 = fields1363 + fields1366 = _dollar_dollar.var"#type" + unwrapped_fields1367 = fields1366 write(pp, "(max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1364) + pretty_type(pp, unwrapped_fields1367) dedent!(pp) write(pp, ")") end @@ -3536,18 +3540,18 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1368 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1368) - write(pp, flat1368) + flat1371 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1371) + write(pp, flat1371) return nothing else _dollar_dollar = msg - fields1366 = _dollar_dollar.var"#type" - unwrapped_fields1367 = fields1366 + fields1369 = _dollar_dollar.var"#type" + unwrapped_fields1370 = fields1369 write(pp, "(sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1367) + pretty_type(pp, unwrapped_fields1370) dedent!(pp) write(pp, ")") end @@ -3555,35 +3559,35 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1376 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1376) - write(pp, flat1376) + flat1379 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1379) + write(pp, flat1379) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1827 = _dollar_dollar.attrs + _t1833 = _dollar_dollar.attrs else - _t1827 = nothing + _t1833 = nothing end - fields1369 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1827,) - unwrapped_fields1370 = fields1369 + fields1372 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1833,) + unwrapped_fields1373 = fields1372 write(pp, "(monus") indent_sexp!(pp) newline(pp) - field1371 = unwrapped_fields1370[1] - pretty_monoid(pp, field1371) + field1374 = unwrapped_fields1373[1] + pretty_monoid(pp, field1374) newline(pp) - field1372 = unwrapped_fields1370[2] - pretty_relation_id(pp, field1372) + field1375 = unwrapped_fields1373[2] + pretty_relation_id(pp, field1375) newline(pp) - field1373 = unwrapped_fields1370[3] - pretty_abstraction_with_arity(pp, field1373) - field1374 = unwrapped_fields1370[4] - if !isnothing(field1374) + field1376 = unwrapped_fields1373[3] + pretty_abstraction_with_arity(pp, field1376) + field1377 = unwrapped_fields1373[4] + if !isnothing(field1377) newline(pp) - opt_val1375 = field1374 - pretty_attrs(pp, opt_val1375) + opt_val1378 = field1377 + pretty_attrs(pp, opt_val1378) end dedent!(pp) write(pp, ")") @@ -3592,28 +3596,28 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1383 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1383) - write(pp, flat1383) + flat1386 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1386) + write(pp, flat1386) return nothing else _dollar_dollar = msg - fields1377 = (_dollar_dollar.name, _get_oneof_field(_dollar_dollar, :functional_dependency).guard, _get_oneof_field(_dollar_dollar, :functional_dependency).keys, _get_oneof_field(_dollar_dollar, :functional_dependency).values,) - unwrapped_fields1378 = fields1377 + fields1380 = (_dollar_dollar.name, _get_oneof_field(_dollar_dollar, :functional_dependency).guard, _get_oneof_field(_dollar_dollar, :functional_dependency).keys, _get_oneof_field(_dollar_dollar, :functional_dependency).values,) + unwrapped_fields1381 = fields1380 write(pp, "(functional_dependency") indent_sexp!(pp) newline(pp) - field1379 = unwrapped_fields1378[1] - pretty_relation_id(pp, field1379) + field1382 = unwrapped_fields1381[1] + pretty_relation_id(pp, field1382) newline(pp) - field1380 = unwrapped_fields1378[2] - pretty_abstraction(pp, field1380) + field1383 = unwrapped_fields1381[2] + pretty_abstraction(pp, field1383) newline(pp) - field1381 = unwrapped_fields1378[3] - pretty_functional_dependency_keys(pp, field1381) + field1384 = unwrapped_fields1381[3] + pretty_functional_dependency_keys(pp, field1384) newline(pp) - field1382 = unwrapped_fields1378[4] - pretty_functional_dependency_values(pp, field1382) + field1385 = unwrapped_fields1381[4] + pretty_functional_dependency_values(pp, field1385) dedent!(pp) write(pp, ")") end @@ -3621,22 +3625,22 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1387 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1387) - write(pp, flat1387) + flat1390 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1390) + write(pp, flat1390) return nothing else - fields1384 = msg + fields1387 = msg write(pp, "(keys") indent_sexp!(pp) - if !isempty(fields1384) + if !isempty(fields1387) newline(pp) - for (i1828, elem1385) in enumerate(fields1384) - i1386 = i1828 - 1 - if (i1386 > 0) + for (i1834, elem1388) in enumerate(fields1387) + i1389 = i1834 - 1 + if (i1389 > 0) newline(pp) end - pretty_var(pp, elem1385) + pretty_var(pp, elem1388) end end dedent!(pp) @@ -3646,22 +3650,22 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1391 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1391) - write(pp, flat1391) + flat1394 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1394) + write(pp, flat1394) return nothing else - fields1388 = msg + fields1391 = msg write(pp, "(values") indent_sexp!(pp) - if !isempty(fields1388) + if !isempty(fields1391) newline(pp) - for (i1829, elem1389) in enumerate(fields1388) - i1390 = i1829 - 1 - if (i1390 > 0) + for (i1835, elem1392) in enumerate(fields1391) + i1393 = i1835 - 1 + if (i1393 > 0) newline(pp) end - pretty_var(pp, elem1389) + pretty_var(pp, elem1392) end end dedent!(pp) @@ -3671,54 +3675,54 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1400 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1400) - write(pp, flat1400) + flat1403 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1403) + write(pp, flat1403) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("edb")) - _t1830 = _get_oneof_field(_dollar_dollar, :edb) + _t1836 = _get_oneof_field(_dollar_dollar, :edb) else - _t1830 = nothing + _t1836 = nothing end - deconstruct_result1398 = _t1830 - if !isnothing(deconstruct_result1398) - unwrapped1399 = deconstruct_result1398 - pretty_edb(pp, unwrapped1399) + deconstruct_result1401 = _t1836 + if !isnothing(deconstruct_result1401) + unwrapped1402 = deconstruct_result1401 + pretty_edb(pp, unwrapped1402) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1831 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1837 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1831 = nothing + _t1837 = nothing end - deconstruct_result1396 = _t1831 - if !isnothing(deconstruct_result1396) - unwrapped1397 = deconstruct_result1396 - pretty_betree_relation(pp, unwrapped1397) + deconstruct_result1399 = _t1837 + if !isnothing(deconstruct_result1399) + unwrapped1400 = deconstruct_result1399 + pretty_betree_relation(pp, unwrapped1400) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1832 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1838 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1832 = nothing + _t1838 = nothing end - deconstruct_result1394 = _t1832 - if !isnothing(deconstruct_result1394) - unwrapped1395 = deconstruct_result1394 - pretty_csv_data(pp, unwrapped1395) + deconstruct_result1397 = _t1838 + if !isnothing(deconstruct_result1397) + unwrapped1398 = deconstruct_result1397 + pretty_csv_data(pp, unwrapped1398) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_data")) - _t1833 = _get_oneof_field(_dollar_dollar, :iceberg_data) + _t1839 = _get_oneof_field(_dollar_dollar, :iceberg_data) else - _t1833 = nothing + _t1839 = nothing end - deconstruct_result1392 = _t1833 - if !isnothing(deconstruct_result1392) - unwrapped1393 = deconstruct_result1392 - pretty_iceberg_data(pp, unwrapped1393) + deconstruct_result1395 = _t1839 + if !isnothing(deconstruct_result1395) + unwrapped1396 = deconstruct_result1395 + pretty_iceberg_data(pp, unwrapped1396) else throw(ParseError("No matching rule for data")) end @@ -3730,25 +3734,25 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) end function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) - flat1406 = try_flat(pp, msg, pretty_edb) - if !isnothing(flat1406) - write(pp, flat1406) + flat1409 = try_flat(pp, msg, pretty_edb) + if !isnothing(flat1409) + write(pp, flat1409) return nothing else _dollar_dollar = msg - fields1401 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - unwrapped_fields1402 = fields1401 + fields1404 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + unwrapped_fields1405 = fields1404 write(pp, "(edb") indent_sexp!(pp) newline(pp) - field1403 = unwrapped_fields1402[1] - pretty_relation_id(pp, field1403) + field1406 = unwrapped_fields1405[1] + pretty_relation_id(pp, field1406) newline(pp) - field1404 = unwrapped_fields1402[2] - pretty_edb_path(pp, field1404) + field1407 = unwrapped_fields1405[2] + pretty_edb_path(pp, field1407) newline(pp) - field1405 = unwrapped_fields1402[3] - pretty_edb_types(pp, field1405) + field1408 = unwrapped_fields1405[3] + pretty_edb_types(pp, field1408) dedent!(pp) write(pp, ")") end @@ -3756,20 +3760,20 @@ function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) end function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1410 = try_flat(pp, msg, pretty_edb_path) - if !isnothing(flat1410) - write(pp, flat1410) + flat1413 = try_flat(pp, msg, pretty_edb_path) + if !isnothing(flat1413) + write(pp, flat1413) return nothing else - fields1407 = msg + fields1410 = msg write(pp, "[") indent!(pp) - for (i1834, elem1408) in enumerate(fields1407) - i1409 = i1834 - 1 - if (i1409 > 0) + for (i1840, elem1411) in enumerate(fields1410) + i1412 = i1840 - 1 + if (i1412 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1408)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1411)) end dedent!(pp) write(pp, "]") @@ -3778,20 +3782,20 @@ function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1414 = try_flat(pp, msg, pretty_edb_types) - if !isnothing(flat1414) - write(pp, flat1414) + flat1417 = try_flat(pp, msg, pretty_edb_types) + if !isnothing(flat1417) + write(pp, flat1417) return nothing else - fields1411 = msg + fields1414 = msg write(pp, "[") indent!(pp) - for (i1835, elem1412) in enumerate(fields1411) - i1413 = i1835 - 1 - if (i1413 > 0) + for (i1841, elem1415) in enumerate(fields1414) + i1416 = i1841 - 1 + if (i1416 > 0) newline(pp) end - pretty_type(pp, elem1412) + pretty_type(pp, elem1415) end dedent!(pp) write(pp, "]") @@ -3800,22 +3804,22 @@ function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1419 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1419) - write(pp, flat1419) + flat1422 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1422) + write(pp, flat1422) return nothing else _dollar_dollar = msg - fields1415 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - unwrapped_fields1416 = fields1415 + fields1418 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + unwrapped_fields1419 = fields1418 write(pp, "(betree_relation") indent_sexp!(pp) newline(pp) - field1417 = unwrapped_fields1416[1] - pretty_relation_id(pp, field1417) + field1420 = unwrapped_fields1419[1] + pretty_relation_id(pp, field1420) newline(pp) - field1418 = unwrapped_fields1416[2] - pretty_betree_info(pp, field1418) + field1421 = unwrapped_fields1419[2] + pretty_betree_info(pp, field1421) dedent!(pp) write(pp, ")") end @@ -3823,26 +3827,26 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1425 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1425) - write(pp, flat1425) + flat1428 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1428) + write(pp, flat1428) return nothing else _dollar_dollar = msg - _t1836 = deconstruct_betree_info_config(pp, _dollar_dollar) - fields1420 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1836,) - unwrapped_fields1421 = fields1420 + _t1842 = deconstruct_betree_info_config(pp, _dollar_dollar) + fields1423 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1842,) + unwrapped_fields1424 = fields1423 write(pp, "(betree_info") indent_sexp!(pp) newline(pp) - field1422 = unwrapped_fields1421[1] - pretty_betree_info_key_types(pp, field1422) + field1425 = unwrapped_fields1424[1] + pretty_betree_info_key_types(pp, field1425) newline(pp) - field1423 = unwrapped_fields1421[2] - pretty_betree_info_value_types(pp, field1423) + field1426 = unwrapped_fields1424[2] + pretty_betree_info_value_types(pp, field1426) newline(pp) - field1424 = unwrapped_fields1421[3] - pretty_config_dict(pp, field1424) + field1427 = unwrapped_fields1424[3] + pretty_config_dict(pp, field1427) dedent!(pp) write(pp, ")") end @@ -3850,22 +3854,22 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1429 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1429) - write(pp, flat1429) + flat1432 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1432) + write(pp, flat1432) return nothing else - fields1426 = msg + fields1429 = msg write(pp, "(key_types") indent_sexp!(pp) - if !isempty(fields1426) + if !isempty(fields1429) newline(pp) - for (i1837, elem1427) in enumerate(fields1426) - i1428 = i1837 - 1 - if (i1428 > 0) + for (i1843, elem1430) in enumerate(fields1429) + i1431 = i1843 - 1 + if (i1431 > 0) newline(pp) end - pretty_type(pp, elem1427) + pretty_type(pp, elem1430) end end dedent!(pp) @@ -3875,22 +3879,22 @@ function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"# end function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1433 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1433) - write(pp, flat1433) + flat1436 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1436) + write(pp, flat1436) return nothing else - fields1430 = msg + fields1433 = msg write(pp, "(value_types") indent_sexp!(pp) - if !isempty(fields1430) + if !isempty(fields1433) newline(pp) - for (i1838, elem1431) in enumerate(fields1430) - i1432 = i1838 - 1 - if (i1432 > 0) + for (i1844, elem1434) in enumerate(fields1433) + i1435 = i1844 - 1 + if (i1435 > 0) newline(pp) end - pretty_type(pp, elem1431) + pretty_type(pp, elem1434) end end dedent!(pp) @@ -3900,39 +3904,39 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1443 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1443) - write(pp, flat1443) + flat1446 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1446) + write(pp, flat1446) return nothing else _dollar_dollar = msg - _t1839 = deconstruct_csv_data_columns_optional(pp, _dollar_dollar) - _t1840 = deconstruct_csv_data_relations_optional(pp, _dollar_dollar) - fields1434 = (_dollar_dollar.locator, _dollar_dollar.config, _t1839, _t1840, _dollar_dollar.asof,) - unwrapped_fields1435 = fields1434 + _t1845 = deconstruct_csv_data_columns_optional(pp, _dollar_dollar) + _t1846 = deconstruct_csv_data_relations_optional(pp, _dollar_dollar) + fields1437 = (_dollar_dollar.locator, _dollar_dollar.config, _t1845, _t1846, _dollar_dollar.asof,) + unwrapped_fields1438 = fields1437 write(pp, "(csv_data") indent_sexp!(pp) newline(pp) - field1436 = unwrapped_fields1435[1] - pretty_csvlocator(pp, field1436) + field1439 = unwrapped_fields1438[1] + pretty_csvlocator(pp, field1439) newline(pp) - field1437 = unwrapped_fields1435[2] - pretty_csv_config(pp, field1437) - field1438 = unwrapped_fields1435[3] - if !isnothing(field1438) + field1440 = unwrapped_fields1438[2] + pretty_csv_config(pp, field1440) + field1441 = unwrapped_fields1438[3] + if !isnothing(field1441) newline(pp) - opt_val1439 = field1438 - pretty_gnf_columns(pp, opt_val1439) + opt_val1442 = field1441 + pretty_gnf_columns(pp, opt_val1442) end - field1440 = unwrapped_fields1435[4] - if !isnothing(field1440) + field1443 = unwrapped_fields1438[4] + if !isnothing(field1443) newline(pp) - opt_val1441 = field1440 - pretty_target_relations(pp, opt_val1441) + opt_val1444 = field1443 + pretty_target_relations(pp, opt_val1444) end newline(pp) - field1442 = unwrapped_fields1435[5] - pretty_csv_asof(pp, field1442) + field1445 = unwrapped_fields1438[5] + pretty_csv_asof(pp, field1445) dedent!(pp) write(pp, ")") end @@ -3940,37 +3944,37 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1450 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1450) - write(pp, flat1450) + flat1453 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1453) + write(pp, flat1453) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.paths) - _t1841 = _dollar_dollar.paths + _t1847 = _dollar_dollar.paths else - _t1841 = nothing + _t1847 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1842 = String(copy(_dollar_dollar.inline_data)) + _t1848 = String(copy(_dollar_dollar.inline_data)) else - _t1842 = nothing + _t1848 = nothing end - fields1444 = (_t1841, _t1842,) - unwrapped_fields1445 = fields1444 + fields1447 = (_t1847, _t1848,) + unwrapped_fields1448 = fields1447 write(pp, "(csv_locator") indent_sexp!(pp) - field1446 = unwrapped_fields1445[1] - if !isnothing(field1446) + field1449 = unwrapped_fields1448[1] + if !isnothing(field1449) newline(pp) - opt_val1447 = field1446 - pretty_csv_locator_paths(pp, opt_val1447) + opt_val1450 = field1449 + pretty_csv_locator_paths(pp, opt_val1450) end - field1448 = unwrapped_fields1445[2] - if !isnothing(field1448) + field1451 = unwrapped_fields1448[2] + if !isnothing(field1451) newline(pp) - opt_val1449 = field1448 - pretty_csv_locator_inline_data(pp, opt_val1449) + opt_val1452 = field1451 + pretty_csv_locator_inline_data(pp, opt_val1452) end dedent!(pp) write(pp, ")") @@ -3979,22 +3983,22 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1454 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1454) - write(pp, flat1454) + flat1457 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1457) + write(pp, flat1457) return nothing else - fields1451 = msg + fields1454 = msg write(pp, "(paths") indent_sexp!(pp) - if !isempty(fields1451) + if !isempty(fields1454) newline(pp) - for (i1843, elem1452) in enumerate(fields1451) - i1453 = i1843 - 1 - if (i1453 > 0) + for (i1849, elem1455) in enumerate(fields1454) + i1456 = i1849 - 1 + if (i1456 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1452)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1455)) end end dedent!(pp) @@ -4004,16 +4008,16 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1456 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1456) - write(pp, flat1456) + flat1459 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1459) + write(pp, flat1459) return nothing else - fields1455 = msg + fields1458 = msg write(pp, "(inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1455)) + write(pp, format_string(pp, fields1458)) dedent!(pp) write(pp, ")") end @@ -4021,26 +4025,26 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1462 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1462) - write(pp, flat1462) + flat1465 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1465) + write(pp, flat1465) return nothing else _dollar_dollar = msg - _t1844 = deconstruct_csv_config(pp, _dollar_dollar) - _t1845 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) - fields1457 = (_t1844, _t1845,) - unwrapped_fields1458 = fields1457 + _t1850 = deconstruct_csv_config(pp, _dollar_dollar) + _t1851 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) + fields1460 = (_t1850, _t1851,) + unwrapped_fields1461 = fields1460 write(pp, "(csv_config") indent_sexp!(pp) newline(pp) - field1459 = unwrapped_fields1458[1] - pretty_config_dict(pp, field1459) - field1460 = unwrapped_fields1458[2] - if !isnothing(field1460) + field1462 = unwrapped_fields1461[1] + pretty_config_dict(pp, field1462) + field1463 = unwrapped_fields1461[2] + if !isnothing(field1463) newline(pp) - opt_val1461 = field1460 - pretty__storage_integration(pp, opt_val1461) + opt_val1464 = field1463 + pretty__storage_integration(pp, opt_val1464) end dedent!(pp) write(pp, ")") @@ -4049,16 +4053,16 @@ function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) end function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat1464 = try_flat(pp, msg, pretty__storage_integration) - if !isnothing(flat1464) - write(pp, flat1464) + flat1467 = try_flat(pp, msg, pretty__storage_integration) + if !isnothing(flat1467) + write(pp, flat1467) return nothing else - fields1463 = msg + fields1466 = msg write(pp, "(storage_integration") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, fields1463) + pretty_config_dict(pp, fields1466) dedent!(pp) write(pp, ")") end @@ -4066,22 +4070,22 @@ function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String end function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) - flat1468 = try_flat(pp, msg, pretty_gnf_columns) - if !isnothing(flat1468) - write(pp, flat1468) + flat1471 = try_flat(pp, msg, pretty_gnf_columns) + if !isnothing(flat1471) + write(pp, flat1471) return nothing else - fields1465 = msg + fields1468 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1465) + if !isempty(fields1468) newline(pp) - for (i1846, elem1466) in enumerate(fields1465) - i1467 = i1846 - 1 - if (i1467 > 0) + for (i1852, elem1469) in enumerate(fields1468) + i1470 = i1852 - 1 + if (i1470 > 0) newline(pp) end - pretty_gnf_column(pp, elem1466) + pretty_gnf_column(pp, elem1469) end end dedent!(pp) @@ -4091,39 +4095,39 @@ function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) end function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) - flat1477 = try_flat(pp, msg, pretty_gnf_column) - if !isnothing(flat1477) - write(pp, flat1477) + flat1480 = try_flat(pp, msg, pretty_gnf_column) + if !isnothing(flat1480) + write(pp, flat1480) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("target_id")) - _t1847 = _dollar_dollar.target_id + _t1853 = _dollar_dollar.target_id else - _t1847 = nothing + _t1853 = nothing end - fields1469 = (_dollar_dollar.column_path, _t1847, _dollar_dollar.types,) - unwrapped_fields1470 = fields1469 + fields1472 = (_dollar_dollar.column_path, _t1853, _dollar_dollar.types,) + unwrapped_fields1473 = fields1472 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1471 = unwrapped_fields1470[1] - pretty_gnf_column_path(pp, field1471) - field1472 = unwrapped_fields1470[2] - if !isnothing(field1472) + field1474 = unwrapped_fields1473[1] + pretty_gnf_column_path(pp, field1474) + field1475 = unwrapped_fields1473[2] + if !isnothing(field1475) newline(pp) - opt_val1473 = field1472 - pretty_relation_id(pp, opt_val1473) + opt_val1476 = field1475 + pretty_relation_id(pp, opt_val1476) end newline(pp) write(pp, "[") - field1474 = unwrapped_fields1470[3] - for (i1848, elem1475) in enumerate(field1474) - i1476 = i1848 - 1 - if (i1476 > 0) + field1477 = unwrapped_fields1473[3] + for (i1854, elem1478) in enumerate(field1477) + i1479 = i1854 - 1 + if (i1479 > 0) newline(pp) end - pretty_type(pp, elem1475) + pretty_type(pp, elem1478) end write(pp, "]") dedent!(pp) @@ -4133,39 +4137,39 @@ function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) end function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) - flat1484 = try_flat(pp, msg, pretty_gnf_column_path) - if !isnothing(flat1484) - write(pp, flat1484) + flat1487 = try_flat(pp, msg, pretty_gnf_column_path) + if !isnothing(flat1487) + write(pp, flat1487) return nothing else _dollar_dollar = msg if length(_dollar_dollar) == 1 - _t1849 = _dollar_dollar[1] + _t1855 = _dollar_dollar[1] else - _t1849 = nothing + _t1855 = nothing end - deconstruct_result1482 = _t1849 - if !isnothing(deconstruct_result1482) - unwrapped1483 = deconstruct_result1482 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1483)) + deconstruct_result1485 = _t1855 + if !isnothing(deconstruct_result1485) + unwrapped1486 = deconstruct_result1485 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1486)) else _dollar_dollar = msg if length(_dollar_dollar) != 1 - _t1850 = _dollar_dollar + _t1856 = _dollar_dollar else - _t1850 = nothing + _t1856 = nothing end - deconstruct_result1478 = _t1850 - if !isnothing(deconstruct_result1478) - unwrapped1479 = deconstruct_result1478 + deconstruct_result1481 = _t1856 + if !isnothing(deconstruct_result1481) + unwrapped1482 = deconstruct_result1481 write(pp, "[") indent!(pp) - for (i1851, elem1480) in enumerate(unwrapped1479) - i1481 = i1851 - 1 - if (i1481 > 0) + for (i1857, elem1483) in enumerate(unwrapped1482) + i1484 = i1857 - 1 + if (i1484 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1480)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1483)) end dedent!(pp) write(pp, "]") @@ -4178,70 +4182,100 @@ function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_target_relations(pp::PrettyPrinter, msg::Proto.TargetRelations) - flat1489 = try_flat(pp, msg, pretty_target_relations) - if !isnothing(flat1489) - write(pp, flat1489) + flat1492 = try_flat(pp, msg, pretty_target_relations) + if !isnothing(flat1492) + write(pp, flat1492) return nothing else _dollar_dollar = msg - fields1485 = (_dollar_dollar.keys, _dollar_dollar,) - unwrapped_fields1486 = fields1485 + _t1858 = deconstruct_relation_keys(pp, _dollar_dollar) + fields1488 = (_t1858, _dollar_dollar,) + unwrapped_fields1489 = fields1488 write(pp, "(relations") indent_sexp!(pp) newline(pp) - field1487 = unwrapped_fields1486[1] - pretty_relation_keys(pp, field1487) + field1490 = unwrapped_fields1489[1] + pretty_relation_keys(pp, field1490) newline(pp) - field1488 = unwrapped_fields1486[2] - pretty_relation_body(pp, field1488) + field1491 = unwrapped_fields1489[2] + pretty_relation_body(pp, field1491) dedent!(pp) write(pp, ")") end return nothing end -function pretty_relation_keys(pp::PrettyPrinter, msg::Vector{Proto.NamedColumn}) - flat1493 = try_flat(pp, msg, pretty_relation_keys) - if !isnothing(flat1493) - write(pp, flat1493) +function pretty_relation_keys(pp::PrettyPrinter, msg::Tuple{Vector{Proto.NamedColumn}, Bool}) + flat1499 = try_flat(pp, msg, pretty_relation_keys) + if !isnothing(flat1499) + write(pp, flat1499) return nothing else - fields1490 = msg - write(pp, "(keys") - indent_sexp!(pp) - if !isempty(fields1490) - newline(pp) - for (i1852, elem1491) in enumerate(fields1490) - i1492 = i1852 - 1 - if (i1492 > 0) - newline(pp) + _dollar_dollar = msg + if !_dollar_dollar[2] + _t1859 = _dollar_dollar[1] + else + _t1859 = nothing + end + deconstruct_result1495 = _t1859 + if !isnothing(deconstruct_result1495) + unwrapped1496 = deconstruct_result1495 + write(pp, "(keys") + indent_sexp!(pp) + if !isempty(unwrapped1496) + newline(pp) + for (i1860, elem1497) in enumerate(unwrapped1496) + i1498 = i1860 - 1 + if (i1498 > 0) + newline(pp) + end + pretty_named_column(pp, elem1497) end - pretty_named_column(pp, elem1491) + end + dedent!(pp) + write(pp, ")") + else + _dollar_dollar = msg + if _dollar_dollar[2] + _t1861 = "synthetic_key" + else + _t1861 = nothing + end + deconstruct_result1493 = _t1861 + if !isnothing(deconstruct_result1493) + unwrapped1494 = deconstruct_result1493 + write(pp, "(keys") + indent_sexp!(pp) + newline(pp) + write(pp, ":") + write(pp, unwrapped1494) + dedent!(pp) + write(pp, ")") + else + throw(ParseError("No matching rule for relation_keys")) end end - dedent!(pp) - write(pp, ")") end return nothing end function pretty_named_column(pp::PrettyPrinter, msg::Proto.NamedColumn) - flat1498 = try_flat(pp, msg, pretty_named_column) - if !isnothing(flat1498) - write(pp, flat1498) + flat1504 = try_flat(pp, msg, pretty_named_column) + if !isnothing(flat1504) + write(pp, flat1504) return nothing else _dollar_dollar = msg - fields1494 = (_dollar_dollar.name, _dollar_dollar.var"#type",) - unwrapped_fields1495 = fields1494 + fields1500 = (_dollar_dollar.name, _dollar_dollar.var"#type",) + unwrapped_fields1501 = fields1500 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1496 = unwrapped_fields1495[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1496)) + field1502 = unwrapped_fields1501[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1502)) newline(pp) - field1497 = unwrapped_fields1495[2] - pretty_type(pp, field1497) + field1503 = unwrapped_fields1501[2] + pretty_type(pp, field1503) dedent!(pp) write(pp, ")") end @@ -4249,36 +4283,36 @@ function pretty_named_column(pp::PrettyPrinter, msg::Proto.NamedColumn) end function pretty_relation_body(pp::PrettyPrinter, msg::Proto.TargetRelations) - flat1505 = try_flat(pp, msg, pretty_relation_body) - if !isnothing(flat1505) - write(pp, flat1505) + flat1511 = try_flat(pp, msg, pretty_relation_body) + if !isnothing(flat1511) + write(pp, flat1511) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("plain")) - _t1853 = _get_oneof_field(_dollar_dollar, :plain).targets + _t1862 = _get_oneof_field(_dollar_dollar, :plain).targets else - _t1853 = nothing + _t1862 = nothing end - deconstruct_result1503 = _t1853 - if !isnothing(deconstruct_result1503) - unwrapped1504 = deconstruct_result1503 - pretty_non_cdc_relations(pp, unwrapped1504) + deconstruct_result1509 = _t1862 + if !isnothing(deconstruct_result1509) + unwrapped1510 = deconstruct_result1509 + pretty_non_cdc_relations(pp, unwrapped1510) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cdc")) - _t1854 = (_get_oneof_field(_dollar_dollar, :cdc).inserts, _get_oneof_field(_dollar_dollar, :cdc).deletes,) + _t1863 = (_get_oneof_field(_dollar_dollar, :cdc).inserts, _get_oneof_field(_dollar_dollar, :cdc).deletes,) else - _t1854 = nothing + _t1863 = nothing end - deconstruct_result1499 = _t1854 - if !isnothing(deconstruct_result1499) - unwrapped1500 = deconstruct_result1499 - field1501 = unwrapped1500[1] - pretty_cdc_inserts(pp, field1501) + deconstruct_result1505 = _t1863 + if !isnothing(deconstruct_result1505) + unwrapped1506 = deconstruct_result1505 + field1507 = unwrapped1506[1] + pretty_cdc_inserts(pp, field1507) write(pp, " ") - field1502 = unwrapped1500[2] - pretty_cdc_deletes(pp, field1502) + field1508 = unwrapped1506[2] + pretty_cdc_deletes(pp, field1508) else throw(ParseError("No matching rule for relation_body")) end @@ -4288,46 +4322,46 @@ function pretty_relation_body(pp::PrettyPrinter, msg::Proto.TargetRelations) end function pretty_non_cdc_relations(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation}) - flat1509 = try_flat(pp, msg, pretty_non_cdc_relations) - if !isnothing(flat1509) - write(pp, flat1509) + flat1515 = try_flat(pp, msg, pretty_non_cdc_relations) + if !isnothing(flat1515) + write(pp, flat1515) return nothing else - fields1506 = msg - for (i1855, elem1507) in enumerate(fields1506) - i1508 = i1855 - 1 - if (i1508 > 0) + fields1512 = msg + for (i1864, elem1513) in enumerate(fields1512) + i1514 = i1864 - 1 + if (i1514 > 0) newline(pp) end - pretty_target_relation(pp, elem1507) + pretty_target_relation(pp, elem1513) end end return nothing end function pretty_target_relation(pp::PrettyPrinter, msg::Proto.TargetRelation) - flat1516 = try_flat(pp, msg, pretty_target_relation) - if !isnothing(flat1516) - write(pp, flat1516) + flat1522 = try_flat(pp, msg, pretty_target_relation) + if !isnothing(flat1522) + write(pp, flat1522) return nothing else _dollar_dollar = msg - fields1510 = (_dollar_dollar.target_id, _dollar_dollar.values,) - unwrapped_fields1511 = fields1510 + fields1516 = (_dollar_dollar.target_id, _dollar_dollar.values,) + unwrapped_fields1517 = fields1516 write(pp, "(relation") indent_sexp!(pp) newline(pp) - field1512 = unwrapped_fields1511[1] - pretty_relation_id(pp, field1512) - field1513 = unwrapped_fields1511[2] - if !isempty(field1513) + field1518 = unwrapped_fields1517[1] + pretty_relation_id(pp, field1518) + field1519 = unwrapped_fields1517[2] + if !isempty(field1519) newline(pp) - for (i1856, elem1514) in enumerate(field1513) - i1515 = i1856 - 1 - if (i1515 > 0) + for (i1865, elem1520) in enumerate(field1519) + i1521 = i1865 - 1 + if (i1521 > 0) newline(pp) end - pretty_named_column(pp, elem1514) + pretty_named_column(pp, elem1520) end end dedent!(pp) @@ -4337,22 +4371,22 @@ function pretty_target_relation(pp::PrettyPrinter, msg::Proto.TargetRelation) end function pretty_cdc_inserts(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation}) - flat1520 = try_flat(pp, msg, pretty_cdc_inserts) - if !isnothing(flat1520) - write(pp, flat1520) + flat1526 = try_flat(pp, msg, pretty_cdc_inserts) + if !isnothing(flat1526) + write(pp, flat1526) return nothing else - fields1517 = msg + fields1523 = msg write(pp, "(inserts") indent_sexp!(pp) - if !isempty(fields1517) + if !isempty(fields1523) newline(pp) - for (i1857, elem1518) in enumerate(fields1517) - i1519 = i1857 - 1 - if (i1519 > 0) + for (i1866, elem1524) in enumerate(fields1523) + i1525 = i1866 - 1 + if (i1525 > 0) newline(pp) end - pretty_target_relation(pp, elem1518) + pretty_target_relation(pp, elem1524) end end dedent!(pp) @@ -4362,22 +4396,22 @@ function pretty_cdc_inserts(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation} end function pretty_cdc_deletes(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation}) - flat1524 = try_flat(pp, msg, pretty_cdc_deletes) - if !isnothing(flat1524) - write(pp, flat1524) + flat1530 = try_flat(pp, msg, pretty_cdc_deletes) + if !isnothing(flat1530) + write(pp, flat1530) return nothing else - fields1521 = msg + fields1527 = msg write(pp, "(deletes") indent_sexp!(pp) - if !isempty(fields1521) + if !isempty(fields1527) newline(pp) - for (i1858, elem1522) in enumerate(fields1521) - i1523 = i1858 - 1 - if (i1523 > 0) + for (i1867, elem1528) in enumerate(fields1527) + i1529 = i1867 - 1 + if (i1529 > 0) newline(pp) end - pretty_target_relation(pp, elem1522) + pretty_target_relation(pp, elem1528) end end dedent!(pp) @@ -4387,16 +4421,16 @@ function pretty_cdc_deletes(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation} end function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1526 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1526) - write(pp, flat1526) + flat1532 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1532) + write(pp, flat1532) return nothing else - fields1525 = msg + fields1531 = msg write(pp, "(asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1525)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1531)) dedent!(pp) write(pp, ")") end @@ -4404,42 +4438,42 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) - flat1537 = try_flat(pp, msg, pretty_iceberg_data) - if !isnothing(flat1537) - write(pp, flat1537) + flat1543 = try_flat(pp, msg, pretty_iceberg_data) + if !isnothing(flat1543) + write(pp, flat1543) return nothing else _dollar_dollar = msg - _t1859 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) - _t1860 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) - fields1527 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1859, _t1860, _dollar_dollar.returns_delta,) - unwrapped_fields1528 = fields1527 + _t1868 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) + _t1869 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) + fields1533 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1868, _t1869, _dollar_dollar.returns_delta,) + unwrapped_fields1534 = fields1533 write(pp, "(iceberg_data") indent_sexp!(pp) newline(pp) - field1529 = unwrapped_fields1528[1] - pretty_iceberg_locator(pp, field1529) + field1535 = unwrapped_fields1534[1] + pretty_iceberg_locator(pp, field1535) newline(pp) - field1530 = unwrapped_fields1528[2] - pretty_iceberg_catalog_config(pp, field1530) + field1536 = unwrapped_fields1534[2] + pretty_iceberg_catalog_config(pp, field1536) newline(pp) - field1531 = unwrapped_fields1528[3] - pretty_gnf_columns(pp, field1531) - field1532 = unwrapped_fields1528[4] - if !isnothing(field1532) + field1537 = unwrapped_fields1534[3] + pretty_gnf_columns(pp, field1537) + field1538 = unwrapped_fields1534[4] + if !isnothing(field1538) newline(pp) - opt_val1533 = field1532 - pretty_iceberg_from_snapshot(pp, opt_val1533) + opt_val1539 = field1538 + pretty_iceberg_from_snapshot(pp, opt_val1539) end - field1534 = unwrapped_fields1528[5] - if !isnothing(field1534) + field1540 = unwrapped_fields1534[5] + if !isnothing(field1540) newline(pp) - opt_val1535 = field1534 - pretty_iceberg_to_snapshot(pp, opt_val1535) + opt_val1541 = field1540 + pretty_iceberg_to_snapshot(pp, opt_val1541) end newline(pp) - field1536 = unwrapped_fields1528[6] - pretty_boolean_value(pp, field1536) + field1542 = unwrapped_fields1534[6] + pretty_boolean_value(pp, field1542) dedent!(pp) write(pp, ")") end @@ -4447,25 +4481,25 @@ function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) end function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) - flat1543 = try_flat(pp, msg, pretty_iceberg_locator) - if !isnothing(flat1543) - write(pp, flat1543) + flat1549 = try_flat(pp, msg, pretty_iceberg_locator) + if !isnothing(flat1549) + write(pp, flat1549) return nothing else _dollar_dollar = msg - fields1538 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - unwrapped_fields1539 = fields1538 + fields1544 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + unwrapped_fields1545 = fields1544 write(pp, "(iceberg_locator") indent_sexp!(pp) newline(pp) - field1540 = unwrapped_fields1539[1] - pretty_iceberg_locator_table_name(pp, field1540) + field1546 = unwrapped_fields1545[1] + pretty_iceberg_locator_table_name(pp, field1546) newline(pp) - field1541 = unwrapped_fields1539[2] - pretty_iceberg_locator_namespace(pp, field1541) + field1547 = unwrapped_fields1545[2] + pretty_iceberg_locator_namespace(pp, field1547) newline(pp) - field1542 = unwrapped_fields1539[3] - pretty_iceberg_locator_warehouse(pp, field1542) + field1548 = unwrapped_fields1545[3] + pretty_iceberg_locator_warehouse(pp, field1548) dedent!(pp) write(pp, ")") end @@ -4473,16 +4507,16 @@ function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) end function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) - flat1545 = try_flat(pp, msg, pretty_iceberg_locator_table_name) - if !isnothing(flat1545) - write(pp, flat1545) + flat1551 = try_flat(pp, msg, pretty_iceberg_locator_table_name) + if !isnothing(flat1551) + write(pp, flat1551) return nothing else - fields1544 = msg + fields1550 = msg write(pp, "(table_name") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1544)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1550)) dedent!(pp) write(pp, ")") end @@ -4490,22 +4524,22 @@ function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) end function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String}) - flat1549 = try_flat(pp, msg, pretty_iceberg_locator_namespace) - if !isnothing(flat1549) - write(pp, flat1549) + flat1555 = try_flat(pp, msg, pretty_iceberg_locator_namespace) + if !isnothing(flat1555) + write(pp, flat1555) return nothing else - fields1546 = msg + fields1552 = msg write(pp, "(namespace") indent_sexp!(pp) - if !isempty(fields1546) + if !isempty(fields1552) newline(pp) - for (i1861, elem1547) in enumerate(fields1546) - i1548 = i1861 - 1 - if (i1548 > 0) + for (i1870, elem1553) in enumerate(fields1552) + i1554 = i1870 - 1 + if (i1554 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1547)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1553)) end end dedent!(pp) @@ -4515,16 +4549,16 @@ function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String} end function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) - flat1551 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) - if !isnothing(flat1551) - write(pp, flat1551) + flat1557 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) + if !isnothing(flat1557) + write(pp, flat1557) return nothing else - fields1550 = msg + fields1556 = msg write(pp, "(warehouse") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1550)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1556)) dedent!(pp) write(pp, ")") end @@ -4532,32 +4566,32 @@ function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCatalogConfig) - flat1559 = try_flat(pp, msg, pretty_iceberg_catalog_config) - if !isnothing(flat1559) - write(pp, flat1559) + flat1565 = try_flat(pp, msg, pretty_iceberg_catalog_config) + if !isnothing(flat1565) + write(pp, flat1565) return nothing else _dollar_dollar = msg - _t1862 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) - fields1552 = (_dollar_dollar.catalog_uri, _t1862, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) - unwrapped_fields1553 = fields1552 + _t1871 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) + fields1558 = (_dollar_dollar.catalog_uri, _t1871, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) + unwrapped_fields1559 = fields1558 write(pp, "(iceberg_catalog_config") indent_sexp!(pp) newline(pp) - field1554 = unwrapped_fields1553[1] - pretty_iceberg_catalog_uri(pp, field1554) - field1555 = unwrapped_fields1553[2] - if !isnothing(field1555) + field1560 = unwrapped_fields1559[1] + pretty_iceberg_catalog_uri(pp, field1560) + field1561 = unwrapped_fields1559[2] + if !isnothing(field1561) newline(pp) - opt_val1556 = field1555 - pretty_iceberg_catalog_config_scope(pp, opt_val1556) + opt_val1562 = field1561 + pretty_iceberg_catalog_config_scope(pp, opt_val1562) end newline(pp) - field1557 = unwrapped_fields1553[3] - pretty_iceberg_properties(pp, field1557) + field1563 = unwrapped_fields1559[3] + pretty_iceberg_properties(pp, field1563) newline(pp) - field1558 = unwrapped_fields1553[4] - pretty_iceberg_auth_properties(pp, field1558) + field1564 = unwrapped_fields1559[4] + pretty_iceberg_auth_properties(pp, field1564) dedent!(pp) write(pp, ")") end @@ -4565,16 +4599,16 @@ function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCata end function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) - flat1561 = try_flat(pp, msg, pretty_iceberg_catalog_uri) - if !isnothing(flat1561) - write(pp, flat1561) + flat1567 = try_flat(pp, msg, pretty_iceberg_catalog_uri) + if !isnothing(flat1567) + write(pp, flat1567) return nothing else - fields1560 = msg + fields1566 = msg write(pp, "(catalog_uri") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1560)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1566)) dedent!(pp) write(pp, ")") end @@ -4582,16 +4616,16 @@ function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) - flat1563 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) - if !isnothing(flat1563) - write(pp, flat1563) + flat1569 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) + if !isnothing(flat1569) + write(pp, flat1569) return nothing else - fields1562 = msg + fields1568 = msg write(pp, "(scope") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1562)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1568)) dedent!(pp) write(pp, ")") end @@ -4599,22 +4633,22 @@ function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) end function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1567 = try_flat(pp, msg, pretty_iceberg_properties) - if !isnothing(flat1567) - write(pp, flat1567) + flat1573 = try_flat(pp, msg, pretty_iceberg_properties) + if !isnothing(flat1573) + write(pp, flat1573) return nothing else - fields1564 = msg + fields1570 = msg write(pp, "(properties") indent_sexp!(pp) - if !isempty(fields1564) + if !isempty(fields1570) newline(pp) - for (i1863, elem1565) in enumerate(fields1564) - i1566 = i1863 - 1 - if (i1566 > 0) + for (i1872, elem1571) in enumerate(fields1570) + i1572 = i1872 - 1 + if (i1572 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1565) + pretty_iceberg_property_entry(pp, elem1571) end end dedent!(pp) @@ -4624,22 +4658,22 @@ function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, end function pretty_iceberg_property_entry(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1572 = try_flat(pp, msg, pretty_iceberg_property_entry) - if !isnothing(flat1572) - write(pp, flat1572) + flat1578 = try_flat(pp, msg, pretty_iceberg_property_entry) + if !isnothing(flat1578) + write(pp, flat1578) return nothing else _dollar_dollar = msg - fields1568 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields1569 = fields1568 + fields1574 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields1575 = fields1574 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1570 = unwrapped_fields1569[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1570)) + field1576 = unwrapped_fields1575[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1576)) newline(pp) - field1571 = unwrapped_fields1569[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1571)) + field1577 = unwrapped_fields1575[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1577)) dedent!(pp) write(pp, ")") end @@ -4647,22 +4681,22 @@ function pretty_iceberg_property_entry(pp::PrettyPrinter, msg::Tuple{String, Str end function pretty_iceberg_auth_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1576 = try_flat(pp, msg, pretty_iceberg_auth_properties) - if !isnothing(flat1576) - write(pp, flat1576) + flat1582 = try_flat(pp, msg, pretty_iceberg_auth_properties) + if !isnothing(flat1582) + write(pp, flat1582) return nothing else - fields1573 = msg + fields1579 = msg write(pp, "(auth_properties") indent_sexp!(pp) - if !isempty(fields1573) + if !isempty(fields1579) newline(pp) - for (i1864, elem1574) in enumerate(fields1573) - i1575 = i1864 - 1 - if (i1575 > 0) + for (i1873, elem1580) in enumerate(fields1579) + i1581 = i1873 - 1 + if (i1581 > 0) newline(pp) end - pretty_iceberg_masked_property_entry(pp, elem1574) + pretty_iceberg_masked_property_entry(pp, elem1580) end end dedent!(pp) @@ -4672,23 +4706,23 @@ function pretty_iceberg_auth_properties(pp::PrettyPrinter, msg::Vector{Tuple{Str end function pretty_iceberg_masked_property_entry(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1581 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) - if !isnothing(flat1581) - write(pp, flat1581) + flat1587 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) + if !isnothing(flat1587) + write(pp, flat1587) return nothing else _dollar_dollar = msg - _t1865 = mask_secret_value(pp, _dollar_dollar) - fields1577 = (_dollar_dollar[1], _t1865,) - unwrapped_fields1578 = fields1577 + _t1874 = mask_secret_value(pp, _dollar_dollar) + fields1583 = (_dollar_dollar[1], _t1874,) + unwrapped_fields1584 = fields1583 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1579 = unwrapped_fields1578[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1579)) + field1585 = unwrapped_fields1584[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1585)) newline(pp) - field1580 = unwrapped_fields1578[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1580)) + field1586 = unwrapped_fields1584[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1586)) dedent!(pp) write(pp, ")") end @@ -4696,16 +4730,16 @@ function pretty_iceberg_masked_property_entry(pp::PrettyPrinter, msg::Tuple{Stri end function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) - flat1583 = try_flat(pp, msg, pretty_iceberg_from_snapshot) - if !isnothing(flat1583) - write(pp, flat1583) + flat1589 = try_flat(pp, msg, pretty_iceberg_from_snapshot) + if !isnothing(flat1589) + write(pp, flat1589) return nothing else - fields1582 = msg + fields1588 = msg write(pp, "(from_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1582)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1588)) dedent!(pp) write(pp, ")") end @@ -4713,16 +4747,16 @@ function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) end function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) - flat1585 = try_flat(pp, msg, pretty_iceberg_to_snapshot) - if !isnothing(flat1585) - write(pp, flat1585) + flat1591 = try_flat(pp, msg, pretty_iceberg_to_snapshot) + if !isnothing(flat1591) + write(pp, flat1591) return nothing else - fields1584 = msg + fields1590 = msg write(pp, "(to_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1584)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1590)) dedent!(pp) write(pp, ")") end @@ -4730,18 +4764,18 @@ function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1588 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1588) - write(pp, flat1588) + flat1594 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1594) + write(pp, flat1594) return nothing else _dollar_dollar = msg - fields1586 = _dollar_dollar.fragment_id - unwrapped_fields1587 = fields1586 + fields1592 = _dollar_dollar.fragment_id + unwrapped_fields1593 = fields1592 write(pp, "(undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1587) + pretty_fragment_id(pp, unwrapped_fields1593) dedent!(pp) write(pp, ")") end @@ -4749,24 +4783,24 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1593 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1593) - write(pp, flat1593) + flat1599 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1599) + write(pp, flat1599) return nothing else _dollar_dollar = msg - fields1589 = _dollar_dollar.relations - unwrapped_fields1590 = fields1589 + fields1595 = _dollar_dollar.relations + unwrapped_fields1596 = fields1595 write(pp, "(context") indent_sexp!(pp) - if !isempty(unwrapped_fields1590) + if !isempty(unwrapped_fields1596) newline(pp) - for (i1866, elem1591) in enumerate(unwrapped_fields1590) - i1592 = i1866 - 1 - if (i1592 > 0) + for (i1875, elem1597) in enumerate(unwrapped_fields1596) + i1598 = i1875 - 1 + if (i1598 > 0) newline(pp) end - pretty_relation_id(pp, elem1591) + pretty_relation_id(pp, elem1597) end end dedent!(pp) @@ -4776,28 +4810,28 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1600 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1600) - write(pp, flat1600) + flat1606 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1606) + write(pp, flat1606) return nothing else _dollar_dollar = msg - fields1594 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - unwrapped_fields1595 = fields1594 + fields1600 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + unwrapped_fields1601 = fields1600 write(pp, "(snapshot") indent_sexp!(pp) newline(pp) - field1596 = unwrapped_fields1595[1] - pretty_edb_path(pp, field1596) - field1597 = unwrapped_fields1595[2] - if !isempty(field1597) + field1602 = unwrapped_fields1601[1] + pretty_edb_path(pp, field1602) + field1603 = unwrapped_fields1601[2] + if !isempty(field1603) newline(pp) - for (i1867, elem1598) in enumerate(field1597) - i1599 = i1867 - 1 - if (i1599 > 0) + for (i1876, elem1604) in enumerate(field1603) + i1605 = i1876 - 1 + if (i1605 > 0) newline(pp) end - pretty_snapshot_mapping(pp, elem1598) + pretty_snapshot_mapping(pp, elem1604) end end dedent!(pp) @@ -4807,40 +4841,40 @@ function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) end function pretty_snapshot_mapping(pp::PrettyPrinter, msg::Proto.SnapshotMapping) - flat1605 = try_flat(pp, msg, pretty_snapshot_mapping) - if !isnothing(flat1605) - write(pp, flat1605) + flat1611 = try_flat(pp, msg, pretty_snapshot_mapping) + if !isnothing(flat1611) + write(pp, flat1611) return nothing else _dollar_dollar = msg - fields1601 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - unwrapped_fields1602 = fields1601 - field1603 = unwrapped_fields1602[1] - pretty_edb_path(pp, field1603) + fields1607 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + unwrapped_fields1608 = fields1607 + field1609 = unwrapped_fields1608[1] + pretty_edb_path(pp, field1609) write(pp, " ") - field1604 = unwrapped_fields1602[2] - pretty_relation_id(pp, field1604) + field1610 = unwrapped_fields1608[2] + pretty_relation_id(pp, field1610) end return nothing end function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1609 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1609) - write(pp, flat1609) + flat1615 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1615) + write(pp, flat1615) return nothing else - fields1606 = msg + fields1612 = msg write(pp, "(reads") indent_sexp!(pp) - if !isempty(fields1606) + if !isempty(fields1612) newline(pp) - for (i1868, elem1607) in enumerate(fields1606) - i1608 = i1868 - 1 - if (i1608 > 0) + for (i1877, elem1613) in enumerate(fields1612) + i1614 = i1877 - 1 + if (i1614 > 0) newline(pp) end - pretty_read(pp, elem1607) + pretty_read(pp, elem1613) end end dedent!(pp) @@ -4850,65 +4884,65 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1620 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1620) - write(pp, flat1620) + flat1626 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1626) + write(pp, flat1626) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1869 = _get_oneof_field(_dollar_dollar, :demand) + _t1878 = _get_oneof_field(_dollar_dollar, :demand) else - _t1869 = nothing + _t1878 = nothing end - deconstruct_result1618 = _t1869 - if !isnothing(deconstruct_result1618) - unwrapped1619 = deconstruct_result1618 - pretty_demand(pp, unwrapped1619) + deconstruct_result1624 = _t1878 + if !isnothing(deconstruct_result1624) + unwrapped1625 = deconstruct_result1624 + pretty_demand(pp, unwrapped1625) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1870 = _get_oneof_field(_dollar_dollar, :output) + _t1879 = _get_oneof_field(_dollar_dollar, :output) else - _t1870 = nothing + _t1879 = nothing end - deconstruct_result1616 = _t1870 - if !isnothing(deconstruct_result1616) - unwrapped1617 = deconstruct_result1616 - pretty_output(pp, unwrapped1617) + deconstruct_result1622 = _t1879 + if !isnothing(deconstruct_result1622) + unwrapped1623 = deconstruct_result1622 + pretty_output(pp, unwrapped1623) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1871 = _get_oneof_field(_dollar_dollar, :what_if) + _t1880 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1871 = nothing + _t1880 = nothing end - deconstruct_result1614 = _t1871 - if !isnothing(deconstruct_result1614) - unwrapped1615 = deconstruct_result1614 - pretty_what_if(pp, unwrapped1615) + deconstruct_result1620 = _t1880 + if !isnothing(deconstruct_result1620) + unwrapped1621 = deconstruct_result1620 + pretty_what_if(pp, unwrapped1621) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1872 = _get_oneof_field(_dollar_dollar, :abort) + _t1881 = _get_oneof_field(_dollar_dollar, :abort) else - _t1872 = nothing + _t1881 = nothing end - deconstruct_result1612 = _t1872 - if !isnothing(deconstruct_result1612) - unwrapped1613 = deconstruct_result1612 - pretty_abort(pp, unwrapped1613) + deconstruct_result1618 = _t1881 + if !isnothing(deconstruct_result1618) + unwrapped1619 = deconstruct_result1618 + pretty_abort(pp, unwrapped1619) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1873 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1882 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1873 = nothing + _t1882 = nothing end - deconstruct_result1610 = _t1873 - if !isnothing(deconstruct_result1610) - unwrapped1611 = deconstruct_result1610 - pretty_export(pp, unwrapped1611) + deconstruct_result1616 = _t1882 + if !isnothing(deconstruct_result1616) + unwrapped1617 = deconstruct_result1616 + pretty_export(pp, unwrapped1617) else throw(ParseError("No matching rule for read")) end @@ -4921,18 +4955,18 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1623 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1623) - write(pp, flat1623) + flat1629 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1629) + write(pp, flat1629) return nothing else _dollar_dollar = msg - fields1621 = _dollar_dollar.relation_id - unwrapped_fields1622 = fields1621 + fields1627 = _dollar_dollar.relation_id + unwrapped_fields1628 = fields1627 write(pp, "(demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1622) + pretty_relation_id(pp, unwrapped_fields1628) dedent!(pp) write(pp, ")") end @@ -4940,22 +4974,22 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1628 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1628) - write(pp, flat1628) + flat1634 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1634) + write(pp, flat1634) return nothing else _dollar_dollar = msg - fields1624 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - unwrapped_fields1625 = fields1624 + fields1630 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + unwrapped_fields1631 = fields1630 write(pp, "(output") indent_sexp!(pp) newline(pp) - field1626 = unwrapped_fields1625[1] - pretty_name(pp, field1626) + field1632 = unwrapped_fields1631[1] + pretty_name(pp, field1632) newline(pp) - field1627 = unwrapped_fields1625[2] - pretty_relation_id(pp, field1627) + field1633 = unwrapped_fields1631[2] + pretty_relation_id(pp, field1633) dedent!(pp) write(pp, ")") end @@ -4963,22 +4997,22 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1633 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1633) - write(pp, flat1633) + flat1639 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1639) + write(pp, flat1639) return nothing else _dollar_dollar = msg - fields1629 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - unwrapped_fields1630 = fields1629 + fields1635 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + unwrapped_fields1636 = fields1635 write(pp, "(what_if") indent_sexp!(pp) newline(pp) - field1631 = unwrapped_fields1630[1] - pretty_name(pp, field1631) + field1637 = unwrapped_fields1636[1] + pretty_name(pp, field1637) newline(pp) - field1632 = unwrapped_fields1630[2] - pretty_epoch(pp, field1632) + field1638 = unwrapped_fields1636[2] + pretty_epoch(pp, field1638) dedent!(pp) write(pp, ")") end @@ -4986,30 +5020,30 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1639 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1639) - write(pp, flat1639) + flat1645 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1645) + write(pp, flat1645) return nothing else _dollar_dollar = msg if _dollar_dollar.name != "abort" - _t1874 = _dollar_dollar.name + _t1883 = _dollar_dollar.name else - _t1874 = nothing + _t1883 = nothing end - fields1634 = (_t1874, _dollar_dollar.relation_id,) - unwrapped_fields1635 = fields1634 + fields1640 = (_t1883, _dollar_dollar.relation_id,) + unwrapped_fields1641 = fields1640 write(pp, "(abort") indent_sexp!(pp) - field1636 = unwrapped_fields1635[1] - if !isnothing(field1636) + field1642 = unwrapped_fields1641[1] + if !isnothing(field1642) newline(pp) - opt_val1637 = field1636 - pretty_name(pp, opt_val1637) + opt_val1643 = field1642 + pretty_name(pp, opt_val1643) end newline(pp) - field1638 = unwrapped_fields1635[2] - pretty_relation_id(pp, field1638) + field1644 = unwrapped_fields1641[2] + pretty_relation_id(pp, field1644) dedent!(pp) write(pp, ")") end @@ -5017,40 +5051,40 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1644 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1644) - write(pp, flat1644) + flat1650 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1650) + write(pp, flat1650) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_config")) - _t1875 = _get_oneof_field(_dollar_dollar, :csv_config) + _t1884 = _get_oneof_field(_dollar_dollar, :csv_config) else - _t1875 = nothing + _t1884 = nothing end - deconstruct_result1642 = _t1875 - if !isnothing(deconstruct_result1642) - unwrapped1643 = deconstruct_result1642 + deconstruct_result1648 = _t1884 + if !isnothing(deconstruct_result1648) + unwrapped1649 = deconstruct_result1648 write(pp, "(export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped1643) + pretty_export_csv_config(pp, unwrapped1649) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_config")) - _t1876 = _get_oneof_field(_dollar_dollar, :iceberg_config) + _t1885 = _get_oneof_field(_dollar_dollar, :iceberg_config) else - _t1876 = nothing + _t1885 = nothing end - deconstruct_result1640 = _t1876 - if !isnothing(deconstruct_result1640) - unwrapped1641 = deconstruct_result1640 + deconstruct_result1646 = _t1885 + if !isnothing(deconstruct_result1646) + unwrapped1647 = deconstruct_result1646 write(pp, "(export_iceberg") indent_sexp!(pp) newline(pp) - pretty_export_iceberg_config(pp, unwrapped1641) + pretty_export_iceberg_config(pp, unwrapped1647) dedent!(pp) write(pp, ")") else @@ -5062,56 +5096,56 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1655 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1655) - write(pp, flat1655) + flat1661 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1661) + write(pp, flat1661) return nothing else _dollar_dollar = msg if length(_dollar_dollar.data_columns) == 0 - _t1878 = deconstruct_export_csv_output_location(pp, _dollar_dollar) - _t1877 = (_t1878, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1887 = deconstruct_export_csv_output_location(pp, _dollar_dollar) + _t1886 = (_t1887, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else - _t1877 = nothing + _t1886 = nothing end - deconstruct_result1650 = _t1877 - if !isnothing(deconstruct_result1650) - unwrapped1651 = deconstruct_result1650 + deconstruct_result1656 = _t1886 + if !isnothing(deconstruct_result1656) + unwrapped1657 = deconstruct_result1656 write(pp, "(export_csv_config_v2") indent_sexp!(pp) newline(pp) - field1652 = unwrapped1651[1] - pretty_export_csv_output_location(pp, field1652) + field1658 = unwrapped1657[1] + pretty_export_csv_output_location(pp, field1658) newline(pp) - field1653 = unwrapped1651[2] - pretty_export_csv_source(pp, field1653) + field1659 = unwrapped1657[2] + pretty_export_csv_source(pp, field1659) newline(pp) - field1654 = unwrapped1651[3] - pretty_csv_config(pp, field1654) + field1660 = unwrapped1657[3] + pretty_csv_config(pp, field1660) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if length(_dollar_dollar.data_columns) != 0 - _t1880 = deconstruct_export_csv_config(pp, _dollar_dollar) - _t1879 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1880,) + _t1889 = deconstruct_export_csv_config(pp, _dollar_dollar) + _t1888 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1889,) else - _t1879 = nothing + _t1888 = nothing end - deconstruct_result1645 = _t1879 - if !isnothing(deconstruct_result1645) - unwrapped1646 = deconstruct_result1645 + deconstruct_result1651 = _t1888 + if !isnothing(deconstruct_result1651) + unwrapped1652 = deconstruct_result1651 write(pp, "(export_csv_config") indent_sexp!(pp) newline(pp) - field1647 = unwrapped1646[1] - pretty_export_csv_path(pp, field1647) + field1653 = unwrapped1652[1] + pretty_export_csv_path(pp, field1653) newline(pp) - field1648 = unwrapped1646[2] - pretty_export_csv_columns_list(pp, field1648) + field1654 = unwrapped1652[2] + pretty_export_csv_columns_list(pp, field1654) newline(pp) - field1649 = unwrapped1646[3] - pretty_config_dict(pp, field1649) + field1655 = unwrapped1652[3] + pretty_config_dict(pp, field1655) dedent!(pp) write(pp, ")") else @@ -5123,40 +5157,40 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) end function pretty_export_csv_output_location(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1660 = try_flat(pp, msg, pretty_export_csv_output_location) - if !isnothing(flat1660) - write(pp, flat1660) + flat1666 = try_flat(pp, msg, pretty_export_csv_output_location) + if !isnothing(flat1666) + write(pp, flat1666) return nothing else _dollar_dollar = msg if _dollar_dollar[1] != "" - _t1881 = _dollar_dollar[1] + _t1890 = _dollar_dollar[1] else - _t1881 = nothing + _t1890 = nothing end - deconstruct_result1658 = _t1881 - if !isnothing(deconstruct_result1658) - unwrapped1659 = deconstruct_result1658 + deconstruct_result1664 = _t1890 + if !isnothing(deconstruct_result1664) + unwrapped1665 = deconstruct_result1664 write(pp, "(path") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1659)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1665)) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if _dollar_dollar[2] != "" - _t1882 = _dollar_dollar[2] + _t1891 = _dollar_dollar[2] else - _t1882 = nothing + _t1891 = nothing end - deconstruct_result1656 = _t1882 - if !isnothing(deconstruct_result1656) - unwrapped1657 = deconstruct_result1656 + deconstruct_result1662 = _t1891 + if !isnothing(deconstruct_result1662) + unwrapped1663 = deconstruct_result1662 write(pp, "(transaction_output_name") indent_sexp!(pp) newline(pp) - pretty_name(pp, unwrapped1657) + pretty_name(pp, unwrapped1663) dedent!(pp) write(pp, ")") else @@ -5168,30 +5202,30 @@ function pretty_export_csv_output_location(pp::PrettyPrinter, msg::Tuple{String, end function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) - flat1667 = try_flat(pp, msg, pretty_export_csv_source) - if !isnothing(flat1667) - write(pp, flat1667) + flat1673 = try_flat(pp, msg, pretty_export_csv_source) + if !isnothing(flat1673) + write(pp, flat1673) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("gnf_columns")) - _t1883 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns + _t1892 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns else - _t1883 = nothing + _t1892 = nothing end - deconstruct_result1663 = _t1883 - if !isnothing(deconstruct_result1663) - unwrapped1664 = deconstruct_result1663 + deconstruct_result1669 = _t1892 + if !isnothing(deconstruct_result1669) + unwrapped1670 = deconstruct_result1669 write(pp, "(gnf_columns") indent_sexp!(pp) - if !isempty(unwrapped1664) + if !isempty(unwrapped1670) newline(pp) - for (i1884, elem1665) in enumerate(unwrapped1664) - i1666 = i1884 - 1 - if (i1666 > 0) + for (i1893, elem1671) in enumerate(unwrapped1670) + i1672 = i1893 - 1 + if (i1672 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1665) + pretty_export_csv_column(pp, elem1671) end end dedent!(pp) @@ -5199,17 +5233,17 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("table_def")) - _t1885 = _get_oneof_field(_dollar_dollar, :table_def) + _t1894 = _get_oneof_field(_dollar_dollar, :table_def) else - _t1885 = nothing + _t1894 = nothing end - deconstruct_result1661 = _t1885 - if !isnothing(deconstruct_result1661) - unwrapped1662 = deconstruct_result1661 + deconstruct_result1667 = _t1894 + if !isnothing(deconstruct_result1667) + unwrapped1668 = deconstruct_result1667 write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped1662) + pretty_relation_id(pp, unwrapped1668) dedent!(pp) write(pp, ")") else @@ -5221,22 +5255,22 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1672 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1672) - write(pp, flat1672) + flat1678 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1678) + write(pp, flat1678) return nothing else _dollar_dollar = msg - fields1668 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - unwrapped_fields1669 = fields1668 + fields1674 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + unwrapped_fields1675 = fields1674 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1670 = unwrapped_fields1669[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1670)) + field1676 = unwrapped_fields1675[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1676)) newline(pp) - field1671 = unwrapped_fields1669[2] - pretty_relation_id(pp, field1671) + field1677 = unwrapped_fields1675[2] + pretty_relation_id(pp, field1677) dedent!(pp) write(pp, ")") end @@ -5244,16 +5278,16 @@ function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) end function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1674 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1674) - write(pp, flat1674) + flat1680 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1680) + write(pp, flat1680) return nothing else - fields1673 = msg + fields1679 = msg write(pp, "(path") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1673)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1679)) dedent!(pp) write(pp, ")") end @@ -5261,22 +5295,22 @@ function pretty_export_csv_path(pp::PrettyPrinter, msg::String) end function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1678 = try_flat(pp, msg, pretty_export_csv_columns_list) - if !isnothing(flat1678) - write(pp, flat1678) + flat1684 = try_flat(pp, msg, pretty_export_csv_columns_list) + if !isnothing(flat1684) + write(pp, flat1684) return nothing else - fields1675 = msg + fields1681 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1675) + if !isempty(fields1681) newline(pp) - for (i1886, elem1676) in enumerate(fields1675) - i1677 = i1886 - 1 - if (i1677 > 0) + for (i1895, elem1682) in enumerate(fields1681) + i1683 = i1895 - 1 + if (i1683 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1676) + pretty_export_csv_column(pp, elem1682) end end dedent!(pp) @@ -5286,34 +5320,34 @@ function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.Exp end function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIcebergConfig) - flat1687 = try_flat(pp, msg, pretty_export_iceberg_config) - if !isnothing(flat1687) - write(pp, flat1687) + flat1693 = try_flat(pp, msg, pretty_export_iceberg_config) + if !isnothing(flat1693) + write(pp, flat1693) return nothing else _dollar_dollar = msg - _t1887 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) - fields1679 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1887,) - unwrapped_fields1680 = fields1679 + _t1896 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) + fields1685 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1896,) + unwrapped_fields1686 = fields1685 write(pp, "(export_iceberg_config") indent_sexp!(pp) newline(pp) - field1681 = unwrapped_fields1680[1] - pretty_iceberg_locator(pp, field1681) + field1687 = unwrapped_fields1686[1] + pretty_iceberg_locator(pp, field1687) newline(pp) - field1682 = unwrapped_fields1680[2] - pretty_iceberg_catalog_config(pp, field1682) + field1688 = unwrapped_fields1686[2] + pretty_iceberg_catalog_config(pp, field1688) newline(pp) - field1683 = unwrapped_fields1680[3] - pretty_export_iceberg_table_def(pp, field1683) + field1689 = unwrapped_fields1686[3] + pretty_export_iceberg_table_def(pp, field1689) newline(pp) - field1684 = unwrapped_fields1680[4] - pretty_iceberg_table_properties(pp, field1684) - field1685 = unwrapped_fields1680[5] - if !isnothing(field1685) + field1690 = unwrapped_fields1686[4] + pretty_iceberg_table_properties(pp, field1690) + field1691 = unwrapped_fields1686[5] + if !isnothing(field1691) newline(pp) - opt_val1686 = field1685 - pretty_config_dict(pp, opt_val1686) + opt_val1692 = field1691 + pretty_config_dict(pp, opt_val1692) end dedent!(pp) write(pp, ")") @@ -5322,16 +5356,16 @@ function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIceber end function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationId) - flat1689 = try_flat(pp, msg, pretty_export_iceberg_table_def) - if !isnothing(flat1689) - write(pp, flat1689) + flat1695 = try_flat(pp, msg, pretty_export_iceberg_table_def) + if !isnothing(flat1695) + write(pp, flat1695) return nothing else - fields1688 = msg + fields1694 = msg write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, fields1688) + pretty_relation_id(pp, fields1694) dedent!(pp) write(pp, ")") end @@ -5339,22 +5373,22 @@ function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationI end function pretty_iceberg_table_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1693 = try_flat(pp, msg, pretty_iceberg_table_properties) - if !isnothing(flat1693) - write(pp, flat1693) + flat1699 = try_flat(pp, msg, pretty_iceberg_table_properties) + if !isnothing(flat1699) + write(pp, flat1699) return nothing else - fields1690 = msg + fields1696 = msg write(pp, "(table_properties") indent_sexp!(pp) - if !isempty(fields1690) + if !isempty(fields1696) newline(pp) - for (i1888, elem1691) in enumerate(fields1690) - i1692 = i1888 - 1 - if (i1692 > 0) + for (i1897, elem1697) in enumerate(fields1696) + i1698 = i1897 - 1 + if (i1698 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1691) + pretty_iceberg_property_entry(pp, elem1697) end end dedent!(pp) @@ -5369,12 +5403,12 @@ end function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1942, _rid) in enumerate(msg.ids) - _idx = i1942 - 1 + for (i1951, _rid) in enumerate(msg.ids) + _idx = i1951 - 1 newline(pp) write(pp, "(") - _t1943 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1943) + _t1952 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1952) write(pp, " ") write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -5438,8 +5472,8 @@ function pretty_cdc_targets(pp::PrettyPrinter, msg::Proto.CDCTargets) indent_sexp!(pp) newline(pp) write(pp, ":inserts (") - for (i1944, _elem) in enumerate(msg.inserts) - _idx = i1944 - 1 + for (i1953, _elem) in enumerate(msg.inserts) + _idx = i1953 - 1 if (_idx > 0) write(pp, " ") end @@ -5448,8 +5482,8 @@ function pretty_cdc_targets(pp::PrettyPrinter, msg::Proto.CDCTargets) write(pp, ")") newline(pp) write(pp, ":deletes (") - for (i1945, _elem) in enumerate(msg.deletes) - _idx = i1945 - 1 + for (i1954, _elem) in enumerate(msg.deletes) + _idx = i1954 - 1 if (_idx > 0) write(pp, " ") end @@ -5473,8 +5507,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe _pprint_dispatch(pp, msg.guard) newline(pp) write(pp, ":keys (") - for (i1946, _elem) in enumerate(msg.keys) - _idx = i1946 - 1 + for (i1955, _elem) in enumerate(msg.keys) + _idx = i1955 - 1 if (_idx > 0) write(pp, " ") end @@ -5483,8 +5517,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe write(pp, ")") newline(pp) write(pp, ":values (") - for (i1947, _elem) in enumerate(msg.values) - _idx = i1947 - 1 + for (i1956, _elem) in enumerate(msg.values) + _idx = i1956 - 1 if (_idx > 0) write(pp, " ") end @@ -5510,8 +5544,8 @@ function pretty_plain_targets(pp::PrettyPrinter, msg::Proto.PlainTargets) indent_sexp!(pp) newline(pp) write(pp, ":targets (") - for (i1948, _elem) in enumerate(msg.targets) - _idx = i1948 - 1 + for (i1957, _elem) in enumerate(msg.targets) + _idx = i1957 - 1 if (_idx > 0) write(pp, " ") end @@ -5555,8 +5589,8 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Proto.ExportCSVColumn indent_sexp!(pp) newline(pp) write(pp, ":columns (") - for (i1949, _elem) in enumerate(msg.columns) - _idx = i1949 - 1 + for (i1958, _elem) in enumerate(msg.columns) + _idx = i1958 - 1 if (_idx > 0) write(pp, " ") end @@ -5686,7 +5720,7 @@ _pprint_dispatch(pp::PrettyPrinter, x::Proto.CSVConfig) = pretty_csv_config(pp, _pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.GNFColumn}) = pretty_gnf_columns(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.GNFColumn) = pretty_gnf_column(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.TargetRelations) = pretty_target_relations(pp, x) -_pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.NamedColumn}) = pretty_relation_keys(pp, x) +_pprint_dispatch(pp::PrettyPrinter, x::Tuple{Vector{Proto.NamedColumn}, Bool}) = pretty_relation_keys(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.NamedColumn) = pretty_named_column(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Vector{Proto.TargetRelation}) = pretty_non_cdc_relations(pp, x) _pprint_dispatch(pp::PrettyPrinter, x::Proto.TargetRelation) = pretty_target_relation(pp, x) diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index a1813ac1..6458b90f 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -425,218 +425,225 @@ def _extract_value_int32(self, value: logic_pb2.Value | None, default: int) -> i if value is None: return int(default) else: - _t2199 = None + _t2211 = None assert value is not None if value.HasField("int32_value"): assert value is not None return value.int32_value else: - _t2200 = None + _t2212 = None raise ParseError("expected an int32 value (e.g. `1i32`) for this config field") def _extract_value_int64(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None - _t2201 = value.HasField("int_value") + _t2213 = value.HasField("int_value") else: - _t2201 = False - if _t2201: + _t2213 = False + if _t2213: assert value is not None return value.int_value else: - _t2202 = None + _t2214 = None return default def _extract_value_string(self, value: logic_pb2.Value | None, default: str) -> str: if value is not None: assert value is not None - _t2203 = value.HasField("string_value") + _t2215 = value.HasField("string_value") else: - _t2203 = False - if _t2203: + _t2215 = False + if _t2215: assert value is not None return value.string_value else: - _t2204 = None + _t2216 = None return default def _extract_value_boolean(self, value: logic_pb2.Value | None, default: bool) -> bool: if value is not None: assert value is not None - _t2205 = value.HasField("boolean_value") + _t2217 = value.HasField("boolean_value") else: - _t2205 = False - if _t2205: + _t2217 = False + if _t2217: assert value is not None return value.boolean_value else: - _t2206 = None + _t2218 = None return default def _extract_value_string_list(self, value: logic_pb2.Value | None, default: Sequence[str]) -> Sequence[str]: if value is not None: assert value is not None - _t2207 = value.HasField("string_value") + _t2219 = value.HasField("string_value") else: - _t2207 = False - if _t2207: + _t2219 = False + if _t2219: assert value is not None return [value.string_value] else: - _t2208 = None + _t2220 = None return default def _try_extract_value_int64(self, value: logic_pb2.Value | None) -> int | None: if value is not None: assert value is not None - _t2209 = value.HasField("int_value") + _t2221 = value.HasField("int_value") else: - _t2209 = False - if _t2209: + _t2221 = False + if _t2221: assert value is not None return value.int_value else: - _t2210 = None + _t2222 = None return None def _try_extract_value_float64(self, value: logic_pb2.Value | None) -> float | None: if value is not None: assert value is not None - _t2211 = value.HasField("float_value") + _t2223 = value.HasField("float_value") else: - _t2211 = False - if _t2211: + _t2223 = False + if _t2223: assert value is not None return value.float_value else: - _t2212 = None + _t2224 = None return None def _try_extract_value_bytes(self, value: logic_pb2.Value | None) -> bytes | None: if value is not None: assert value is not None - _t2213 = value.HasField("string_value") + _t2225 = value.HasField("string_value") else: - _t2213 = False - if _t2213: + _t2225 = False + if _t2225: assert value is not None return value.string_value.encode() else: - _t2214 = None + _t2226 = None return None def _try_extract_value_uint128(self, value: logic_pb2.Value | None) -> logic_pb2.UInt128Value | None: if value is not None: assert value is not None - _t2215 = value.HasField("uint128_value") + _t2227 = value.HasField("uint128_value") else: - _t2215 = False - if _t2215: + _t2227 = False + if _t2227: assert value is not None return value.uint128_value else: - _t2216 = None + _t2228 = None return None def construct_non_cdc_relations(self, targets: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2217 = logic_pb2.PlainTargets(targets=targets) - _t2218 = logic_pb2.TargetRelations(keys=[], plain=_t2217) - return _t2218 + _t2229 = logic_pb2.PlainTargets(targets=targets) + _t2230 = logic_pb2.TargetRelations(keys=[], plain=_t2229) + return _t2230 def construct_cdc_relations(self, inserts: Sequence[logic_pb2.TargetRelation], deletes: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2219 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) - _t2220 = logic_pb2.TargetRelations(keys=[], cdc=_t2219) - return _t2220 + _t2231 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) + _t2232 = logic_pb2.TargetRelations(keys=[], cdc=_t2231) + return _t2232 + + def construct_synthetic_keys(self, marker: str) -> tuple[Sequence[logic_pb2.NamedColumn], bool]: + if marker != "synthetic_key": + raise ParseError("expected the `:synthetic_key` marker in the relation keys clause") + else: + _t2233 = None + return ([], True,) - def construct_relations(self, keys: Sequence[logic_pb2.NamedColumn], body: logic_pb2.TargetRelations) -> logic_pb2.TargetRelations: + def construct_relations(self, keys: tuple[Sequence[logic_pb2.NamedColumn], bool], body: logic_pb2.TargetRelations) -> logic_pb2.TargetRelations: if body.HasField("plain"): - _t2222 = logic_pb2.TargetRelations(keys=keys, plain=body.plain) - return _t2222 + _t2235 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], plain=body.plain) + return _t2235 else: - _t2221 = None - _t2223 = logic_pb2.TargetRelations(keys=keys, cdc=body.cdc) - return _t2223 + _t2234 = None + _t2236 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], cdc=body.cdc) + return _t2236 def construct_csv_data(self, locator: logic_pb2.CSVLocator, config: logic_pb2.CSVConfig, columns_opt: Sequence[logic_pb2.GNFColumn] | None, relations_opt: logic_pb2.TargetRelations | None, asof: str) -> logic_pb2.CSVData: - _t2224 = logic_pb2.CSVData(locator=locator, config=config, columns=(columns_opt if columns_opt is not None else []), asof=asof, relations=relations_opt) - return _t2224 + _t2237 = logic_pb2.CSVData(locator=locator, config=config, columns=(columns_opt if columns_opt is not None else []), asof=asof, relations=relations_opt) + return _t2237 def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]], storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t2225 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2225 - _t2226 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2226 - _t2227 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2227 - _t2228 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2228 - _t2229 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2229 - _t2230 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2230 - _t2231 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2231 - _t2232 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2232 - _t2233 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2233 - _t2234 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2234 - _t2235 = self._extract_value_string(config.get("csv_compression"), "") - compression = _t2235 - _t2236 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2236 - _t2237 = self.construct_csv_storage_integration(storage_integration_opt) - storage_integration = _t2237 - _t2238 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2238 + _t2238 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t2238 + _t2239 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t2239 + _t2240 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t2240 + _t2241 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t2241 + _t2242 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t2242 + _t2243 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t2243 + _t2244 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t2244 + _t2245 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t2245 + _t2246 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t2246 + _t2247 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t2247 + _t2248 = self._extract_value_string(config.get("csv_compression"), "") + compression = _t2248 + _t2249 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) + partition_size_mb = _t2249 + _t2250 = self.construct_csv_storage_integration(storage_integration_opt) + storage_integration = _t2250 + _t2251 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) + return _t2251 def construct_csv_storage_integration(self, storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.StorageIntegration | None: if storage_integration_opt is None: return None else: - _t2239 = None + _t2252 = None assert storage_integration_opt is not None config = dict(storage_integration_opt) - _t2240 = self._extract_value_string(config.get("provider"), "") - _t2241 = self._extract_value_string(config.get("azure_sas_token"), "") - _t2242 = self._extract_value_string(config.get("s3_region"), "") - _t2243 = self._extract_value_string(config.get("s3_access_key_id"), "") - _t2244 = self._extract_value_string(config.get("s3_secret_access_key"), "") - _t2245 = logic_pb2.StorageIntegration(provider=_t2240, azure_sas_token=_t2241, s3_region=_t2242, s3_access_key_id=_t2243, s3_secret_access_key=_t2244) - return _t2245 + _t2253 = self._extract_value_string(config.get("provider"), "") + _t2254 = self._extract_value_string(config.get("azure_sas_token"), "") + _t2255 = self._extract_value_string(config.get("s3_region"), "") + _t2256 = self._extract_value_string(config.get("s3_access_key_id"), "") + _t2257 = self._extract_value_string(config.get("s3_secret_access_key"), "") + _t2258 = logic_pb2.StorageIntegration(provider=_t2253, azure_sas_token=_t2254, s3_region=_t2255, s3_access_key_id=_t2256, s3_secret_access_key=_t2257) + return _t2258 def construct_betree_info(self, key_types: Sequence[logic_pb2.Type], value_types: Sequence[logic_pb2.Type], config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> logic_pb2.BeTreeInfo: config = dict(config_dict) - _t2246 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2246 - _t2247 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2247 - _t2248 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2248 - _t2249 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2249 - _t2250 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2250 - _t2251 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2251 - _t2252 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2252 - _t2253 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2253 - _t2254 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2254 - _t2255 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2255 - _t2256 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2256 + _t2259 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t2259 + _t2260 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t2260 + _t2261 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t2261 + _t2262 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t2262 + _t2263 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2263 + _t2264 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t2264 + _t2265 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t2265 + _t2266 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t2266 + _t2267 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t2267 + _t2268 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t2268 + _t2269 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2269 def default_configure(self) -> transactions_pb2.Configure: - _t2257 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2257 - _t2258 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2258 + _t2270 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2270 + _t2271 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2271 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -653,3553 +660,3588 @@ def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]] maintenance_level = transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL else: maintenance_level = transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t2259 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2259 - _t2260 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2260 - _t2261 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2261 + _t2272 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t2272 + _t2273 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t2273 + _t2274 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2274 def construct_export_csv_config(self, path: str, columns: Sequence[transactions_pb2.ExportCSVColumn], config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.ExportCSVConfig: config = dict(config_dict) - _t2262 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2262 - _t2263 = self._extract_value_string(config.get("compression"), "") - compression = _t2263 - _t2264 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2264 - _t2265 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2265 - _t2266 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2266 - _t2267 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2267 - _t2268 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2268 - _t2269 = transactions_pb2.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) - return _t2269 + _t2275 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t2275 + _t2276 = self._extract_value_string(config.get("compression"), "") + compression = _t2276 + _t2277 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t2277 + _t2278 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t2278 + _t2279 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t2279 + _t2280 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t2280 + _t2281 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t2281 + _t2282 = transactions_pb2.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) + return _t2282 def construct_export_csv_config_with_location(self, location: tuple[str, str], csv_source: transactions_pb2.ExportCSVSource, csv_config: logic_pb2.CSVConfig) -> transactions_pb2.ExportCSVConfig: - _t2270 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) - return _t2270 + _t2283 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) + return _t2283 def construct_iceberg_catalog_config(self, catalog_uri: str, scope_opt: str | None, property_pairs: Sequence[tuple[str, str]], auth_property_pairs: Sequence[tuple[str, str]]) -> logic_pb2.IcebergCatalogConfig: props = dict(property_pairs) auth_props = dict(auth_property_pairs) - _t2271 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2271 + _t2284 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) + return _t2284 def construct_iceberg_data(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, columns: Sequence[logic_pb2.GNFColumn], from_snapshot_opt: str | None, to_snapshot_opt: str | None, returns_delta: bool) -> logic_pb2.IcebergData: - _t2272 = logic_pb2.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(from_snapshot_opt if from_snapshot_opt is not None else ""), to_snapshot=(to_snapshot_opt if to_snapshot_opt is not None else ""), returns_delta=returns_delta) - return _t2272 + _t2285 = logic_pb2.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(from_snapshot_opt if from_snapshot_opt is not None else ""), to_snapshot=(to_snapshot_opt if to_snapshot_opt is not None else ""), returns_delta=returns_delta) + return _t2285 def construct_export_iceberg_config_full(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, table_def: logic_pb2.RelationId, table_property_pairs: Sequence[tuple[str, str]], config_dict: Sequence[tuple[str, logic_pb2.Value]] | None) -> transactions_pb2.ExportIcebergConfig: cfg = dict((config_dict if config_dict is not None else [])) - _t2273 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2273 - _t2274 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2274 - _t2275 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2275 + _t2286 = self._extract_value_string(cfg.get("prefix"), "") + prefix = _t2286 + _t2287 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) + target_file_size_bytes = _t2287 + _t2288 = self._extract_value_string(cfg.get("compression"), "") + compression = _t2288 table_props = dict(table_property_pairs) - _t2276 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2276 + _t2289 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2289 # --- Parse methods --- def parse_transaction(self) -> transactions_pb2.Transaction: - span_start713 = self.span_start() + span_start715 = self.span_start() self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t1415 = self.parse_configure() - _t1414 = _t1415 + _t1419 = self.parse_configure() + _t1418 = _t1419 else: - _t1414 = None - configure707 = _t1414 + _t1418 = None + configure709 = _t1418 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t1417 = self.parse_sync() - _t1416 = _t1417 + _t1421 = self.parse_sync() + _t1420 = _t1421 else: - _t1416 = None - sync708 = _t1416 - xs709 = [] - cond710 = self.match_lookahead_literal("(", 0) - while cond710: - _t1418 = self.parse_epoch() - item711 = _t1418 - xs709.append(item711) - cond710 = self.match_lookahead_literal("(", 0) - epochs712 = xs709 + _t1420 = None + sync710 = _t1420 + xs711 = [] + cond712 = self.match_lookahead_literal("(", 0) + while cond712: + _t1422 = self.parse_epoch() + item713 = _t1422 + xs711.append(item713) + cond712 = self.match_lookahead_literal("(", 0) + epochs714 = xs711 self.consume_literal(")") - _t1419 = self.default_configure() - _t1420 = transactions_pb2.Transaction(epochs=epochs712, configure=(configure707 if configure707 is not None else _t1419), sync=sync708) - result714 = _t1420 - self.record_span(span_start713, "Transaction") - return result714 + _t1423 = self.default_configure() + _t1424 = transactions_pb2.Transaction(epochs=epochs714, configure=(configure709 if configure709 is not None else _t1423), sync=sync710) + result716 = _t1424 + self.record_span(span_start715, "Transaction") + return result716 def parse_configure(self) -> transactions_pb2.Configure: - span_start716 = self.span_start() + span_start718 = self.span_start() self.consume_literal("(") self.consume_literal("configure") - _t1421 = self.parse_config_dict() - config_dict715 = _t1421 + _t1425 = self.parse_config_dict() + config_dict717 = _t1425 self.consume_literal(")") - _t1422 = self.construct_configure(config_dict715) - result717 = _t1422 - self.record_span(span_start716, "Configure") - return result717 + _t1426 = self.construct_configure(config_dict717) + result719 = _t1426 + self.record_span(span_start718, "Configure") + return result719 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs718 = [] - cond719 = self.match_lookahead_literal(":", 0) - while cond719: - _t1423 = self.parse_config_key_value() - item720 = _t1423 - xs718.append(item720) - cond719 = self.match_lookahead_literal(":", 0) - config_key_values721 = xs718 + xs720 = [] + cond721 = self.match_lookahead_literal(":", 0) + while cond721: + _t1427 = self.parse_config_key_value() + item722 = _t1427 + xs720.append(item722) + cond721 = self.match_lookahead_literal(":", 0) + config_key_values723 = xs720 self.consume_literal("}") - return config_key_values721 + return config_key_values723 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol722 = self.consume_terminal("SYMBOL") - _t1424 = self.parse_raw_value() - raw_value723 = _t1424 - return (symbol722, raw_value723,) + symbol724 = self.consume_terminal("SYMBOL") + _t1428 = self.parse_raw_value() + raw_value725 = _t1428 + return (symbol724, raw_value725,) def parse_raw_value(self) -> logic_pb2.Value: - span_start737 = self.span_start() + span_start739 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1425 = 12 + _t1429 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1426 = 11 + _t1430 = 11 else: if self.match_lookahead_literal("false", 0): - _t1427 = 12 + _t1431 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1429 = 1 + _t1433 = 1 else: if self.match_lookahead_literal("date", 1): - _t1430 = 0 + _t1434 = 0 else: - _t1430 = -1 - _t1429 = _t1430 - _t1428 = _t1429 + _t1434 = -1 + _t1433 = _t1434 + _t1432 = _t1433 else: if self.match_lookahead_terminal("UINT32", 0): - _t1431 = 7 + _t1435 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1432 = 8 + _t1436 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1433 = 2 + _t1437 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1434 = 3 + _t1438 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1435 = 9 + _t1439 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1436 = 4 + _t1440 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1437 = 5 + _t1441 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1438 = 6 + _t1442 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1439 = 10 + _t1443 = 10 else: - _t1439 = -1 - _t1438 = _t1439 - _t1437 = _t1438 - _t1436 = _t1437 - _t1435 = _t1436 - _t1434 = _t1435 - _t1433 = _t1434 - _t1432 = _t1433 - _t1431 = _t1432 - _t1428 = _t1431 - _t1427 = _t1428 - _t1426 = _t1427 - _t1425 = _t1426 - prediction724 = _t1425 - if prediction724 == 12: - _t1441 = self.parse_boolean_value() - boolean_value736 = _t1441 - _t1442 = logic_pb2.Value(boolean_value=boolean_value736) - _t1440 = _t1442 + _t1443 = -1 + _t1442 = _t1443 + _t1441 = _t1442 + _t1440 = _t1441 + _t1439 = _t1440 + _t1438 = _t1439 + _t1437 = _t1438 + _t1436 = _t1437 + _t1435 = _t1436 + _t1432 = _t1435 + _t1431 = _t1432 + _t1430 = _t1431 + _t1429 = _t1430 + prediction726 = _t1429 + if prediction726 == 12: + _t1445 = self.parse_boolean_value() + boolean_value738 = _t1445 + _t1446 = logic_pb2.Value(boolean_value=boolean_value738) + _t1444 = _t1446 else: - if prediction724 == 11: + if prediction726 == 11: self.consume_literal("missing") - _t1444 = logic_pb2.MissingValue() - _t1445 = logic_pb2.Value(missing_value=_t1444) - _t1443 = _t1445 + _t1448 = logic_pb2.MissingValue() + _t1449 = logic_pb2.Value(missing_value=_t1448) + _t1447 = _t1449 else: - if prediction724 == 10: - decimal735 = self.consume_terminal("DECIMAL") - _t1447 = logic_pb2.Value(decimal_value=decimal735) - _t1446 = _t1447 + if prediction726 == 10: + decimal737 = self.consume_terminal("DECIMAL") + _t1451 = logic_pb2.Value(decimal_value=decimal737) + _t1450 = _t1451 else: - if prediction724 == 9: - int128734 = self.consume_terminal("INT128") - _t1449 = logic_pb2.Value(int128_value=int128734) - _t1448 = _t1449 + if prediction726 == 9: + int128736 = self.consume_terminal("INT128") + _t1453 = logic_pb2.Value(int128_value=int128736) + _t1452 = _t1453 else: - if prediction724 == 8: - uint128733 = self.consume_terminal("UINT128") - _t1451 = logic_pb2.Value(uint128_value=uint128733) - _t1450 = _t1451 + if prediction726 == 8: + uint128735 = self.consume_terminal("UINT128") + _t1455 = logic_pb2.Value(uint128_value=uint128735) + _t1454 = _t1455 else: - if prediction724 == 7: - uint32732 = self.consume_terminal("UINT32") - _t1453 = logic_pb2.Value(uint32_value=uint32732) - _t1452 = _t1453 + if prediction726 == 7: + uint32734 = self.consume_terminal("UINT32") + _t1457 = logic_pb2.Value(uint32_value=uint32734) + _t1456 = _t1457 else: - if prediction724 == 6: - float731 = self.consume_terminal("FLOAT") - _t1455 = logic_pb2.Value(float_value=float731) - _t1454 = _t1455 + if prediction726 == 6: + float733 = self.consume_terminal("FLOAT") + _t1459 = logic_pb2.Value(float_value=float733) + _t1458 = _t1459 else: - if prediction724 == 5: - float32730 = self.consume_terminal("FLOAT32") - _t1457 = logic_pb2.Value(float32_value=float32730) - _t1456 = _t1457 + if prediction726 == 5: + float32732 = self.consume_terminal("FLOAT32") + _t1461 = logic_pb2.Value(float32_value=float32732) + _t1460 = _t1461 else: - if prediction724 == 4: - int729 = self.consume_terminal("INT") - _t1459 = logic_pb2.Value(int_value=int729) - _t1458 = _t1459 + if prediction726 == 4: + int731 = self.consume_terminal("INT") + _t1463 = logic_pb2.Value(int_value=int731) + _t1462 = _t1463 else: - if prediction724 == 3: - int32728 = self.consume_terminal("INT32") - _t1461 = logic_pb2.Value(int32_value=int32728) - _t1460 = _t1461 + if prediction726 == 3: + int32730 = self.consume_terminal("INT32") + _t1465 = logic_pb2.Value(int32_value=int32730) + _t1464 = _t1465 else: - if prediction724 == 2: - string727 = self.consume_terminal("STRING") - _t1463 = logic_pb2.Value(string_value=string727) - _t1462 = _t1463 + if prediction726 == 2: + string729 = self.consume_terminal("STRING") + _t1467 = logic_pb2.Value(string_value=string729) + _t1466 = _t1467 else: - if prediction724 == 1: - _t1465 = self.parse_raw_datetime() - raw_datetime726 = _t1465 - _t1466 = logic_pb2.Value(datetime_value=raw_datetime726) - _t1464 = _t1466 + if prediction726 == 1: + _t1469 = self.parse_raw_datetime() + raw_datetime728 = _t1469 + _t1470 = logic_pb2.Value(datetime_value=raw_datetime728) + _t1468 = _t1470 else: - if prediction724 == 0: - _t1468 = self.parse_raw_date() - raw_date725 = _t1468 - _t1469 = logic_pb2.Value(date_value=raw_date725) - _t1467 = _t1469 + if prediction726 == 0: + _t1472 = self.parse_raw_date() + raw_date727 = _t1472 + _t1473 = logic_pb2.Value(date_value=raw_date727) + _t1471 = _t1473 else: raise ParseError("Unexpected token in raw_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1464 = _t1467 - _t1462 = _t1464 - _t1460 = _t1462 - _t1458 = _t1460 - _t1456 = _t1458 - _t1454 = _t1456 - _t1452 = _t1454 - _t1450 = _t1452 - _t1448 = _t1450 - _t1446 = _t1448 - _t1443 = _t1446 - _t1440 = _t1443 - result738 = _t1440 - self.record_span(span_start737, "Value") - return result738 + _t1468 = _t1471 + _t1466 = _t1468 + _t1464 = _t1466 + _t1462 = _t1464 + _t1460 = _t1462 + _t1458 = _t1460 + _t1456 = _t1458 + _t1454 = _t1456 + _t1452 = _t1454 + _t1450 = _t1452 + _t1447 = _t1450 + _t1444 = _t1447 + result740 = _t1444 + self.record_span(span_start739, "Value") + return result740 def parse_raw_date(self) -> logic_pb2.DateValue: - span_start742 = self.span_start() + span_start744 = self.span_start() self.consume_literal("(") self.consume_literal("date") - int739 = self.consume_terminal("INT") - int_3740 = self.consume_terminal("INT") - int_4741 = self.consume_terminal("INT") + int741 = self.consume_terminal("INT") + int_3742 = self.consume_terminal("INT") + int_4743 = self.consume_terminal("INT") self.consume_literal(")") - _t1470 = logic_pb2.DateValue(year=int(int739), month=int(int_3740), day=int(int_4741)) - result743 = _t1470 - self.record_span(span_start742, "DateValue") - return result743 + _t1474 = logic_pb2.DateValue(year=int(int741), month=int(int_3742), day=int(int_4743)) + result745 = _t1474 + self.record_span(span_start744, "DateValue") + return result745 def parse_raw_datetime(self) -> logic_pb2.DateTimeValue: - span_start751 = self.span_start() + span_start753 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - int744 = self.consume_terminal("INT") - int_3745 = self.consume_terminal("INT") - int_4746 = self.consume_terminal("INT") - int_5747 = self.consume_terminal("INT") - int_6748 = self.consume_terminal("INT") - int_7749 = self.consume_terminal("INT") + int746 = self.consume_terminal("INT") + int_3747 = self.consume_terminal("INT") + int_4748 = self.consume_terminal("INT") + int_5749 = self.consume_terminal("INT") + int_6750 = self.consume_terminal("INT") + int_7751 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1471 = self.consume_terminal("INT") + _t1475 = self.consume_terminal("INT") else: - _t1471 = None - int_8750 = _t1471 + _t1475 = None + int_8752 = _t1475 self.consume_literal(")") - _t1472 = logic_pb2.DateTimeValue(year=int(int744), month=int(int_3745), day=int(int_4746), hour=int(int_5747), minute=int(int_6748), second=int(int_7749), microsecond=int((int_8750 if int_8750 is not None else 0))) - result752 = _t1472 - self.record_span(span_start751, "DateTimeValue") - return result752 + _t1476 = logic_pb2.DateTimeValue(year=int(int746), month=int(int_3747), day=int(int_4748), hour=int(int_5749), minute=int(int_6750), second=int(int_7751), microsecond=int((int_8752 if int_8752 is not None else 0))) + result754 = _t1476 + self.record_span(span_start753, "DateTimeValue") + return result754 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t1473 = 0 + _t1477 = 0 else: if self.match_lookahead_literal("false", 0): - _t1474 = 1 + _t1478 = 1 else: - _t1474 = -1 - _t1473 = _t1474 - prediction753 = _t1473 - if prediction753 == 1: + _t1478 = -1 + _t1477 = _t1478 + prediction755 = _t1477 + if prediction755 == 1: self.consume_literal("false") - _t1475 = False + _t1479 = False else: - if prediction753 == 0: + if prediction755 == 0: self.consume_literal("true") - _t1476 = True + _t1480 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1475 = _t1476 - return _t1475 + _t1479 = _t1480 + return _t1479 def parse_sync(self) -> transactions_pb2.Sync: - span_start758 = self.span_start() + span_start760 = self.span_start() self.consume_literal("(") self.consume_literal("sync") - xs754 = [] - cond755 = self.match_lookahead_literal(":", 0) - while cond755: - _t1477 = self.parse_fragment_id() - item756 = _t1477 - xs754.append(item756) - cond755 = self.match_lookahead_literal(":", 0) - fragment_ids757 = xs754 + xs756 = [] + cond757 = self.match_lookahead_literal(":", 0) + while cond757: + _t1481 = self.parse_fragment_id() + item758 = _t1481 + xs756.append(item758) + cond757 = self.match_lookahead_literal(":", 0) + fragment_ids759 = xs756 self.consume_literal(")") - _t1478 = transactions_pb2.Sync(fragments=fragment_ids757) - result759 = _t1478 - self.record_span(span_start758, "Sync") - return result759 + _t1482 = transactions_pb2.Sync(fragments=fragment_ids759) + result761 = _t1482 + self.record_span(span_start760, "Sync") + return result761 def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start761 = self.span_start() + span_start763 = self.span_start() self.consume_literal(":") - symbol760 = self.consume_terminal("SYMBOL") - result762 = fragments_pb2.FragmentId(id=symbol760.encode()) - self.record_span(span_start761, "FragmentId") - return result762 + symbol762 = self.consume_terminal("SYMBOL") + result764 = fragments_pb2.FragmentId(id=symbol762.encode()) + self.record_span(span_start763, "FragmentId") + return result764 def parse_epoch(self) -> transactions_pb2.Epoch: - span_start765 = self.span_start() + span_start767 = self.span_start() self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t1480 = self.parse_epoch_writes() - _t1479 = _t1480 + _t1484 = self.parse_epoch_writes() + _t1483 = _t1484 else: - _t1479 = None - epoch_writes763 = _t1479 + _t1483 = None + epoch_writes765 = _t1483 if self.match_lookahead_literal("(", 0): - _t1482 = self.parse_epoch_reads() - _t1481 = _t1482 + _t1486 = self.parse_epoch_reads() + _t1485 = _t1486 else: - _t1481 = None - epoch_reads764 = _t1481 + _t1485 = None + epoch_reads766 = _t1485 self.consume_literal(")") - _t1483 = transactions_pb2.Epoch(writes=(epoch_writes763 if epoch_writes763 is not None else []), reads=(epoch_reads764 if epoch_reads764 is not None else [])) - result766 = _t1483 - self.record_span(span_start765, "Epoch") - return result766 + _t1487 = transactions_pb2.Epoch(writes=(epoch_writes765 if epoch_writes765 is not None else []), reads=(epoch_reads766 if epoch_reads766 is not None else [])) + result768 = _t1487 + self.record_span(span_start767, "Epoch") + return result768 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs767 = [] - cond768 = self.match_lookahead_literal("(", 0) - while cond768: - _t1484 = self.parse_write() - item769 = _t1484 - xs767.append(item769) - cond768 = self.match_lookahead_literal("(", 0) - writes770 = xs767 + xs769 = [] + cond770 = self.match_lookahead_literal("(", 0) + while cond770: + _t1488 = self.parse_write() + item771 = _t1488 + xs769.append(item771) + cond770 = self.match_lookahead_literal("(", 0) + writes772 = xs769 self.consume_literal(")") - return writes770 + return writes772 def parse_write(self) -> transactions_pb2.Write: - span_start776 = self.span_start() + span_start778 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t1486 = 1 + _t1490 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t1487 = 3 + _t1491 = 3 else: if self.match_lookahead_literal("define", 1): - _t1488 = 0 + _t1492 = 0 else: if self.match_lookahead_literal("context", 1): - _t1489 = 2 + _t1493 = 2 else: - _t1489 = -1 - _t1488 = _t1489 - _t1487 = _t1488 - _t1486 = _t1487 - _t1485 = _t1486 + _t1493 = -1 + _t1492 = _t1493 + _t1491 = _t1492 + _t1490 = _t1491 + _t1489 = _t1490 else: - _t1485 = -1 - prediction771 = _t1485 - if prediction771 == 3: - _t1491 = self.parse_snapshot() - snapshot775 = _t1491 - _t1492 = transactions_pb2.Write(snapshot=snapshot775) - _t1490 = _t1492 + _t1489 = -1 + prediction773 = _t1489 + if prediction773 == 3: + _t1495 = self.parse_snapshot() + snapshot777 = _t1495 + _t1496 = transactions_pb2.Write(snapshot=snapshot777) + _t1494 = _t1496 else: - if prediction771 == 2: - _t1494 = self.parse_context() - context774 = _t1494 - _t1495 = transactions_pb2.Write(context=context774) - _t1493 = _t1495 + if prediction773 == 2: + _t1498 = self.parse_context() + context776 = _t1498 + _t1499 = transactions_pb2.Write(context=context776) + _t1497 = _t1499 else: - if prediction771 == 1: - _t1497 = self.parse_undefine() - undefine773 = _t1497 - _t1498 = transactions_pb2.Write(undefine=undefine773) - _t1496 = _t1498 + if prediction773 == 1: + _t1501 = self.parse_undefine() + undefine775 = _t1501 + _t1502 = transactions_pb2.Write(undefine=undefine775) + _t1500 = _t1502 else: - if prediction771 == 0: - _t1500 = self.parse_define() - define772 = _t1500 - _t1501 = transactions_pb2.Write(define=define772) - _t1499 = _t1501 + if prediction773 == 0: + _t1504 = self.parse_define() + define774 = _t1504 + _t1505 = transactions_pb2.Write(define=define774) + _t1503 = _t1505 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1496 = _t1499 - _t1493 = _t1496 - _t1490 = _t1493 - result777 = _t1490 - self.record_span(span_start776, "Write") - return result777 + _t1500 = _t1503 + _t1497 = _t1500 + _t1494 = _t1497 + result779 = _t1494 + self.record_span(span_start778, "Write") + return result779 def parse_define(self) -> transactions_pb2.Define: - span_start779 = self.span_start() + span_start781 = self.span_start() self.consume_literal("(") self.consume_literal("define") - _t1502 = self.parse_fragment() - fragment778 = _t1502 + _t1506 = self.parse_fragment() + fragment780 = _t1506 self.consume_literal(")") - _t1503 = transactions_pb2.Define(fragment=fragment778) - result780 = _t1503 - self.record_span(span_start779, "Define") - return result780 + _t1507 = transactions_pb2.Define(fragment=fragment780) + result782 = _t1507 + self.record_span(span_start781, "Define") + return result782 def parse_fragment(self) -> fragments_pb2.Fragment: - span_start786 = self.span_start() + span_start788 = self.span_start() self.consume_literal("(") self.consume_literal("fragment") - _t1504 = self.parse_new_fragment_id() - new_fragment_id781 = _t1504 - xs782 = [] - cond783 = self.match_lookahead_literal("(", 0) - while cond783: - _t1505 = self.parse_declaration() - item784 = _t1505 - xs782.append(item784) - cond783 = self.match_lookahead_literal("(", 0) - declarations785 = xs782 + _t1508 = self.parse_new_fragment_id() + new_fragment_id783 = _t1508 + xs784 = [] + cond785 = self.match_lookahead_literal("(", 0) + while cond785: + _t1509 = self.parse_declaration() + item786 = _t1509 + xs784.append(item786) + cond785 = self.match_lookahead_literal("(", 0) + declarations787 = xs784 self.consume_literal(")") - result787 = self.construct_fragment(new_fragment_id781, declarations785) - self.record_span(span_start786, "Fragment") - return result787 + result789 = self.construct_fragment(new_fragment_id783, declarations787) + self.record_span(span_start788, "Fragment") + return result789 def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - span_start789 = self.span_start() - _t1506 = self.parse_fragment_id() - fragment_id788 = _t1506 - self.start_fragment(fragment_id788) - result790 = fragment_id788 - self.record_span(span_start789, "FragmentId") - return result790 + span_start791 = self.span_start() + _t1510 = self.parse_fragment_id() + fragment_id790 = _t1510 + self.start_fragment(fragment_id790) + result792 = fragment_id790 + self.record_span(span_start791, "FragmentId") + return result792 def parse_declaration(self) -> logic_pb2.Declaration: - span_start796 = self.span_start() + span_start798 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1508 = 3 + _t1512 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t1509 = 2 + _t1513 = 2 else: if self.match_lookahead_literal("edb", 1): - _t1510 = 3 + _t1514 = 3 else: if self.match_lookahead_literal("def", 1): - _t1511 = 0 + _t1515 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1512 = 3 + _t1516 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t1513 = 3 + _t1517 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t1514 = 1 + _t1518 = 1 else: - _t1514 = -1 - _t1513 = _t1514 - _t1512 = _t1513 - _t1511 = _t1512 - _t1510 = _t1511 - _t1509 = _t1510 - _t1508 = _t1509 - _t1507 = _t1508 + _t1518 = -1 + _t1517 = _t1518 + _t1516 = _t1517 + _t1515 = _t1516 + _t1514 = _t1515 + _t1513 = _t1514 + _t1512 = _t1513 + _t1511 = _t1512 else: - _t1507 = -1 - prediction791 = _t1507 - if prediction791 == 3: - _t1516 = self.parse_data() - data795 = _t1516 - _t1517 = logic_pb2.Declaration(data=data795) - _t1515 = _t1517 + _t1511 = -1 + prediction793 = _t1511 + if prediction793 == 3: + _t1520 = self.parse_data() + data797 = _t1520 + _t1521 = logic_pb2.Declaration(data=data797) + _t1519 = _t1521 else: - if prediction791 == 2: - _t1519 = self.parse_constraint() - constraint794 = _t1519 - _t1520 = logic_pb2.Declaration(constraint=constraint794) - _t1518 = _t1520 + if prediction793 == 2: + _t1523 = self.parse_constraint() + constraint796 = _t1523 + _t1524 = logic_pb2.Declaration(constraint=constraint796) + _t1522 = _t1524 else: - if prediction791 == 1: - _t1522 = self.parse_algorithm() - algorithm793 = _t1522 - _t1523 = logic_pb2.Declaration(algorithm=algorithm793) - _t1521 = _t1523 + if prediction793 == 1: + _t1526 = self.parse_algorithm() + algorithm795 = _t1526 + _t1527 = logic_pb2.Declaration(algorithm=algorithm795) + _t1525 = _t1527 else: - if prediction791 == 0: - _t1525 = self.parse_def() - def792 = _t1525 - _t1526 = logic_pb2.Declaration() - getattr(_t1526, 'def').CopyFrom(def792) - _t1524 = _t1526 + if prediction793 == 0: + _t1529 = self.parse_def() + def794 = _t1529 + _t1530 = logic_pb2.Declaration() + getattr(_t1530, 'def').CopyFrom(def794) + _t1528 = _t1530 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1521 = _t1524 - _t1518 = _t1521 - _t1515 = _t1518 - result797 = _t1515 - self.record_span(span_start796, "Declaration") - return result797 + _t1525 = _t1528 + _t1522 = _t1525 + _t1519 = _t1522 + result799 = _t1519 + self.record_span(span_start798, "Declaration") + return result799 def parse_def(self) -> logic_pb2.Def: - span_start801 = self.span_start() + span_start803 = self.span_start() self.consume_literal("(") self.consume_literal("def") - _t1527 = self.parse_relation_id() - relation_id798 = _t1527 - _t1528 = self.parse_abstraction() - abstraction799 = _t1528 + _t1531 = self.parse_relation_id() + relation_id800 = _t1531 + _t1532 = self.parse_abstraction() + abstraction801 = _t1532 if self.match_lookahead_literal("(", 0): - _t1530 = self.parse_attrs() - _t1529 = _t1530 + _t1534 = self.parse_attrs() + _t1533 = _t1534 else: - _t1529 = None - attrs800 = _t1529 + _t1533 = None + attrs802 = _t1533 self.consume_literal(")") - _t1531 = logic_pb2.Def(name=relation_id798, body=abstraction799, attrs=(attrs800 if attrs800 is not None else [])) - result802 = _t1531 - self.record_span(span_start801, "Def") - return result802 + _t1535 = logic_pb2.Def(name=relation_id800, body=abstraction801, attrs=(attrs802 if attrs802 is not None else [])) + result804 = _t1535 + self.record_span(span_start803, "Def") + return result804 def parse_relation_id(self) -> logic_pb2.RelationId: - span_start806 = self.span_start() + span_start808 = self.span_start() if self.match_lookahead_literal(":", 0): - _t1532 = 0 + _t1536 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1533 = 1 + _t1537 = 1 else: - _t1533 = -1 - _t1532 = _t1533 - prediction803 = _t1532 - if prediction803 == 1: - uint128805 = self.consume_terminal("UINT128") - _t1534 = logic_pb2.RelationId(id_low=uint128805.low, id_high=uint128805.high) + _t1537 = -1 + _t1536 = _t1537 + prediction805 = _t1536 + if prediction805 == 1: + uint128807 = self.consume_terminal("UINT128") + _t1538 = logic_pb2.RelationId(id_low=uint128807.low, id_high=uint128807.high) else: - if prediction803 == 0: + if prediction805 == 0: self.consume_literal(":") - symbol804 = self.consume_terminal("SYMBOL") - _t1535 = self.relation_id_from_string(symbol804) + symbol806 = self.consume_terminal("SYMBOL") + _t1539 = self.relation_id_from_string(symbol806) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1534 = _t1535 - result807 = _t1534 - self.record_span(span_start806, "RelationId") - return result807 + _t1538 = _t1539 + result809 = _t1538 + self.record_span(span_start808, "RelationId") + return result809 def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start810 = self.span_start() + span_start812 = self.span_start() self.consume_literal("(") - _t1536 = self.parse_bindings() - bindings808 = _t1536 - _t1537 = self.parse_formula() - formula809 = _t1537 + _t1540 = self.parse_bindings() + bindings810 = _t1540 + _t1541 = self.parse_formula() + formula811 = _t1541 self.consume_literal(")") - _t1538 = logic_pb2.Abstraction(vars=(list(bindings808[0]) + list(bindings808[1] if bindings808[1] is not None else [])), value=formula809) - result811 = _t1538 - self.record_span(span_start810, "Abstraction") - return result811 + _t1542 = logic_pb2.Abstraction(vars=(list(bindings810[0]) + list(bindings810[1] if bindings810[1] is not None else [])), value=formula811) + result813 = _t1542 + self.record_span(span_start812, "Abstraction") + return result813 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs812 = [] - cond813 = self.match_lookahead_terminal("SYMBOL", 0) - while cond813: - _t1539 = self.parse_binding() - item814 = _t1539 - xs812.append(item814) - cond813 = self.match_lookahead_terminal("SYMBOL", 0) - bindings815 = xs812 + xs814 = [] + cond815 = self.match_lookahead_terminal("SYMBOL", 0) + while cond815: + _t1543 = self.parse_binding() + item816 = _t1543 + xs814.append(item816) + cond815 = self.match_lookahead_terminal("SYMBOL", 0) + bindings817 = xs814 if self.match_lookahead_literal("|", 0): - _t1541 = self.parse_value_bindings() - _t1540 = _t1541 + _t1545 = self.parse_value_bindings() + _t1544 = _t1545 else: - _t1540 = None - value_bindings816 = _t1540 + _t1544 = None + value_bindings818 = _t1544 self.consume_literal("]") - return (bindings815, (value_bindings816 if value_bindings816 is not None else []),) + return (bindings817, (value_bindings818 if value_bindings818 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - span_start819 = self.span_start() - symbol817 = self.consume_terminal("SYMBOL") + span_start821 = self.span_start() + symbol819 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t1542 = self.parse_type() - type818 = _t1542 - _t1543 = logic_pb2.Var(name=symbol817) - _t1544 = logic_pb2.Binding(var=_t1543, type=type818) - result820 = _t1544 - self.record_span(span_start819, "Binding") - return result820 + _t1546 = self.parse_type() + type820 = _t1546 + _t1547 = logic_pb2.Var(name=symbol819) + _t1548 = logic_pb2.Binding(var=_t1547, type=type820) + result822 = _t1548 + self.record_span(span_start821, "Binding") + return result822 def parse_type(self) -> logic_pb2.Type: - span_start836 = self.span_start() + span_start838 = self.span_start() if self.match_lookahead_literal("UNKNOWN", 0): - _t1545 = 0 + _t1549 = 0 else: if self.match_lookahead_literal("UINT32", 0): - _t1546 = 13 + _t1550 = 13 else: if self.match_lookahead_literal("UINT128", 0): - _t1547 = 4 + _t1551 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t1548 = 1 + _t1552 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t1549 = 8 + _t1553 = 8 else: if self.match_lookahead_literal("INT32", 0): - _t1550 = 11 + _t1554 = 11 else: if self.match_lookahead_literal("INT128", 0): - _t1551 = 5 + _t1555 = 5 else: if self.match_lookahead_literal("INT", 0): - _t1552 = 2 + _t1556 = 2 else: if self.match_lookahead_literal("FLOAT32", 0): - _t1553 = 12 + _t1557 = 12 else: if self.match_lookahead_literal("FLOAT", 0): - _t1554 = 3 + _t1558 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t1555 = 7 + _t1559 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t1556 = 6 + _t1560 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t1557 = 10 + _t1561 = 10 else: if self.match_lookahead_literal("(", 0): - _t1558 = 9 + _t1562 = 9 else: - _t1558 = -1 - _t1557 = _t1558 - _t1556 = _t1557 - _t1555 = _t1556 - _t1554 = _t1555 - _t1553 = _t1554 - _t1552 = _t1553 - _t1551 = _t1552 - _t1550 = _t1551 - _t1549 = _t1550 - _t1548 = _t1549 - _t1547 = _t1548 - _t1546 = _t1547 - _t1545 = _t1546 - prediction821 = _t1545 - if prediction821 == 13: - _t1560 = self.parse_uint32_type() - uint32_type835 = _t1560 - _t1561 = logic_pb2.Type(uint32_type=uint32_type835) - _t1559 = _t1561 + _t1562 = -1 + _t1561 = _t1562 + _t1560 = _t1561 + _t1559 = _t1560 + _t1558 = _t1559 + _t1557 = _t1558 + _t1556 = _t1557 + _t1555 = _t1556 + _t1554 = _t1555 + _t1553 = _t1554 + _t1552 = _t1553 + _t1551 = _t1552 + _t1550 = _t1551 + _t1549 = _t1550 + prediction823 = _t1549 + if prediction823 == 13: + _t1564 = self.parse_uint32_type() + uint32_type837 = _t1564 + _t1565 = logic_pb2.Type(uint32_type=uint32_type837) + _t1563 = _t1565 else: - if prediction821 == 12: - _t1563 = self.parse_float32_type() - float32_type834 = _t1563 - _t1564 = logic_pb2.Type(float32_type=float32_type834) - _t1562 = _t1564 + if prediction823 == 12: + _t1567 = self.parse_float32_type() + float32_type836 = _t1567 + _t1568 = logic_pb2.Type(float32_type=float32_type836) + _t1566 = _t1568 else: - if prediction821 == 11: - _t1566 = self.parse_int32_type() - int32_type833 = _t1566 - _t1567 = logic_pb2.Type(int32_type=int32_type833) - _t1565 = _t1567 + if prediction823 == 11: + _t1570 = self.parse_int32_type() + int32_type835 = _t1570 + _t1571 = logic_pb2.Type(int32_type=int32_type835) + _t1569 = _t1571 else: - if prediction821 == 10: - _t1569 = self.parse_boolean_type() - boolean_type832 = _t1569 - _t1570 = logic_pb2.Type(boolean_type=boolean_type832) - _t1568 = _t1570 + if prediction823 == 10: + _t1573 = self.parse_boolean_type() + boolean_type834 = _t1573 + _t1574 = logic_pb2.Type(boolean_type=boolean_type834) + _t1572 = _t1574 else: - if prediction821 == 9: - _t1572 = self.parse_decimal_type() - decimal_type831 = _t1572 - _t1573 = logic_pb2.Type(decimal_type=decimal_type831) - _t1571 = _t1573 + if prediction823 == 9: + _t1576 = self.parse_decimal_type() + decimal_type833 = _t1576 + _t1577 = logic_pb2.Type(decimal_type=decimal_type833) + _t1575 = _t1577 else: - if prediction821 == 8: - _t1575 = self.parse_missing_type() - missing_type830 = _t1575 - _t1576 = logic_pb2.Type(missing_type=missing_type830) - _t1574 = _t1576 + if prediction823 == 8: + _t1579 = self.parse_missing_type() + missing_type832 = _t1579 + _t1580 = logic_pb2.Type(missing_type=missing_type832) + _t1578 = _t1580 else: - if prediction821 == 7: - _t1578 = self.parse_datetime_type() - datetime_type829 = _t1578 - _t1579 = logic_pb2.Type(datetime_type=datetime_type829) - _t1577 = _t1579 + if prediction823 == 7: + _t1582 = self.parse_datetime_type() + datetime_type831 = _t1582 + _t1583 = logic_pb2.Type(datetime_type=datetime_type831) + _t1581 = _t1583 else: - if prediction821 == 6: - _t1581 = self.parse_date_type() - date_type828 = _t1581 - _t1582 = logic_pb2.Type(date_type=date_type828) - _t1580 = _t1582 + if prediction823 == 6: + _t1585 = self.parse_date_type() + date_type830 = _t1585 + _t1586 = logic_pb2.Type(date_type=date_type830) + _t1584 = _t1586 else: - if prediction821 == 5: - _t1584 = self.parse_int128_type() - int128_type827 = _t1584 - _t1585 = logic_pb2.Type(int128_type=int128_type827) - _t1583 = _t1585 + if prediction823 == 5: + _t1588 = self.parse_int128_type() + int128_type829 = _t1588 + _t1589 = logic_pb2.Type(int128_type=int128_type829) + _t1587 = _t1589 else: - if prediction821 == 4: - _t1587 = self.parse_uint128_type() - uint128_type826 = _t1587 - _t1588 = logic_pb2.Type(uint128_type=uint128_type826) - _t1586 = _t1588 + if prediction823 == 4: + _t1591 = self.parse_uint128_type() + uint128_type828 = _t1591 + _t1592 = logic_pb2.Type(uint128_type=uint128_type828) + _t1590 = _t1592 else: - if prediction821 == 3: - _t1590 = self.parse_float_type() - float_type825 = _t1590 - _t1591 = logic_pb2.Type(float_type=float_type825) - _t1589 = _t1591 + if prediction823 == 3: + _t1594 = self.parse_float_type() + float_type827 = _t1594 + _t1595 = logic_pb2.Type(float_type=float_type827) + _t1593 = _t1595 else: - if prediction821 == 2: - _t1593 = self.parse_int_type() - int_type824 = _t1593 - _t1594 = logic_pb2.Type(int_type=int_type824) - _t1592 = _t1594 + if prediction823 == 2: + _t1597 = self.parse_int_type() + int_type826 = _t1597 + _t1598 = logic_pb2.Type(int_type=int_type826) + _t1596 = _t1598 else: - if prediction821 == 1: - _t1596 = self.parse_string_type() - string_type823 = _t1596 - _t1597 = logic_pb2.Type(string_type=string_type823) - _t1595 = _t1597 + if prediction823 == 1: + _t1600 = self.parse_string_type() + string_type825 = _t1600 + _t1601 = logic_pb2.Type(string_type=string_type825) + _t1599 = _t1601 else: - if prediction821 == 0: - _t1599 = self.parse_unspecified_type() - unspecified_type822 = _t1599 - _t1600 = logic_pb2.Type(unspecified_type=unspecified_type822) - _t1598 = _t1600 + if prediction823 == 0: + _t1603 = self.parse_unspecified_type() + unspecified_type824 = _t1603 + _t1604 = logic_pb2.Type(unspecified_type=unspecified_type824) + _t1602 = _t1604 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1595 = _t1598 - _t1592 = _t1595 - _t1589 = _t1592 - _t1586 = _t1589 - _t1583 = _t1586 - _t1580 = _t1583 - _t1577 = _t1580 - _t1574 = _t1577 - _t1571 = _t1574 - _t1568 = _t1571 - _t1565 = _t1568 - _t1562 = _t1565 - _t1559 = _t1562 - result837 = _t1559 - self.record_span(span_start836, "Type") - return result837 + _t1599 = _t1602 + _t1596 = _t1599 + _t1593 = _t1596 + _t1590 = _t1593 + _t1587 = _t1590 + _t1584 = _t1587 + _t1581 = _t1584 + _t1578 = _t1581 + _t1575 = _t1578 + _t1572 = _t1575 + _t1569 = _t1572 + _t1566 = _t1569 + _t1563 = _t1566 + result839 = _t1563 + self.record_span(span_start838, "Type") + return result839 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: - span_start838 = self.span_start() + span_start840 = self.span_start() self.consume_literal("UNKNOWN") - _t1601 = logic_pb2.UnspecifiedType() - result839 = _t1601 - self.record_span(span_start838, "UnspecifiedType") - return result839 + _t1605 = logic_pb2.UnspecifiedType() + result841 = _t1605 + self.record_span(span_start840, "UnspecifiedType") + return result841 def parse_string_type(self) -> logic_pb2.StringType: - span_start840 = self.span_start() + span_start842 = self.span_start() self.consume_literal("STRING") - _t1602 = logic_pb2.StringType() - result841 = _t1602 - self.record_span(span_start840, "StringType") - return result841 + _t1606 = logic_pb2.StringType() + result843 = _t1606 + self.record_span(span_start842, "StringType") + return result843 def parse_int_type(self) -> logic_pb2.IntType: - span_start842 = self.span_start() + span_start844 = self.span_start() self.consume_literal("INT") - _t1603 = logic_pb2.IntType() - result843 = _t1603 - self.record_span(span_start842, "IntType") - return result843 + _t1607 = logic_pb2.IntType() + result845 = _t1607 + self.record_span(span_start844, "IntType") + return result845 def parse_float_type(self) -> logic_pb2.FloatType: - span_start844 = self.span_start() + span_start846 = self.span_start() self.consume_literal("FLOAT") - _t1604 = logic_pb2.FloatType() - result845 = _t1604 - self.record_span(span_start844, "FloatType") - return result845 + _t1608 = logic_pb2.FloatType() + result847 = _t1608 + self.record_span(span_start846, "FloatType") + return result847 def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start846 = self.span_start() + span_start848 = self.span_start() self.consume_literal("UINT128") - _t1605 = logic_pb2.UInt128Type() - result847 = _t1605 - self.record_span(span_start846, "UInt128Type") - return result847 + _t1609 = logic_pb2.UInt128Type() + result849 = _t1609 + self.record_span(span_start848, "UInt128Type") + return result849 def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start848 = self.span_start() + span_start850 = self.span_start() self.consume_literal("INT128") - _t1606 = logic_pb2.Int128Type() - result849 = _t1606 - self.record_span(span_start848, "Int128Type") - return result849 + _t1610 = logic_pb2.Int128Type() + result851 = _t1610 + self.record_span(span_start850, "Int128Type") + return result851 def parse_date_type(self) -> logic_pb2.DateType: - span_start850 = self.span_start() + span_start852 = self.span_start() self.consume_literal("DATE") - _t1607 = logic_pb2.DateType() - result851 = _t1607 - self.record_span(span_start850, "DateType") - return result851 + _t1611 = logic_pb2.DateType() + result853 = _t1611 + self.record_span(span_start852, "DateType") + return result853 def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start852 = self.span_start() + span_start854 = self.span_start() self.consume_literal("DATETIME") - _t1608 = logic_pb2.DateTimeType() - result853 = _t1608 - self.record_span(span_start852, "DateTimeType") - return result853 + _t1612 = logic_pb2.DateTimeType() + result855 = _t1612 + self.record_span(span_start854, "DateTimeType") + return result855 def parse_missing_type(self) -> logic_pb2.MissingType: - span_start854 = self.span_start() + span_start856 = self.span_start() self.consume_literal("MISSING") - _t1609 = logic_pb2.MissingType() - result855 = _t1609 - self.record_span(span_start854, "MissingType") - return result855 + _t1613 = logic_pb2.MissingType() + result857 = _t1613 + self.record_span(span_start856, "MissingType") + return result857 def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start858 = self.span_start() + span_start860 = self.span_start() self.consume_literal("(") self.consume_literal("DECIMAL") - int856 = self.consume_terminal("INT") - int_3857 = self.consume_terminal("INT") + int858 = self.consume_terminal("INT") + int_3859 = self.consume_terminal("INT") self.consume_literal(")") - _t1610 = logic_pb2.DecimalType(precision=int(int856), scale=int(int_3857)) - result859 = _t1610 - self.record_span(span_start858, "DecimalType") - return result859 + _t1614 = logic_pb2.DecimalType(precision=int(int858), scale=int(int_3859)) + result861 = _t1614 + self.record_span(span_start860, "DecimalType") + return result861 def parse_boolean_type(self) -> logic_pb2.BooleanType: - span_start860 = self.span_start() + span_start862 = self.span_start() self.consume_literal("BOOLEAN") - _t1611 = logic_pb2.BooleanType() - result861 = _t1611 - self.record_span(span_start860, "BooleanType") - return result861 + _t1615 = logic_pb2.BooleanType() + result863 = _t1615 + self.record_span(span_start862, "BooleanType") + return result863 def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start862 = self.span_start() + span_start864 = self.span_start() self.consume_literal("INT32") - _t1612 = logic_pb2.Int32Type() - result863 = _t1612 - self.record_span(span_start862, "Int32Type") - return result863 + _t1616 = logic_pb2.Int32Type() + result865 = _t1616 + self.record_span(span_start864, "Int32Type") + return result865 def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start864 = self.span_start() + span_start866 = self.span_start() self.consume_literal("FLOAT32") - _t1613 = logic_pb2.Float32Type() - result865 = _t1613 - self.record_span(span_start864, "Float32Type") - return result865 + _t1617 = logic_pb2.Float32Type() + result867 = _t1617 + self.record_span(span_start866, "Float32Type") + return result867 def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start866 = self.span_start() + span_start868 = self.span_start() self.consume_literal("UINT32") - _t1614 = logic_pb2.UInt32Type() - result867 = _t1614 - self.record_span(span_start866, "UInt32Type") - return result867 + _t1618 = logic_pb2.UInt32Type() + result869 = _t1618 + self.record_span(span_start868, "UInt32Type") + return result869 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs868 = [] - cond869 = self.match_lookahead_terminal("SYMBOL", 0) - while cond869: - _t1615 = self.parse_binding() - item870 = _t1615 - xs868.append(item870) - cond869 = self.match_lookahead_terminal("SYMBOL", 0) - bindings871 = xs868 - return bindings871 + xs870 = [] + cond871 = self.match_lookahead_terminal("SYMBOL", 0) + while cond871: + _t1619 = self.parse_binding() + item872 = _t1619 + xs870.append(item872) + cond871 = self.match_lookahead_terminal("SYMBOL", 0) + bindings873 = xs870 + return bindings873 def parse_formula(self) -> logic_pb2.Formula: - span_start886 = self.span_start() + span_start888 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t1617 = 0 + _t1621 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t1618 = 11 + _t1622 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t1619 = 3 + _t1623 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t1620 = 10 + _t1624 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t1621 = 9 + _t1625 = 9 else: if self.match_lookahead_literal("or", 1): - _t1622 = 5 + _t1626 = 5 else: if self.match_lookahead_literal("not", 1): - _t1623 = 6 + _t1627 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t1624 = 7 + _t1628 = 7 else: if self.match_lookahead_literal("false", 1): - _t1625 = 1 + _t1629 = 1 else: if self.match_lookahead_literal("exists", 1): - _t1626 = 2 + _t1630 = 2 else: if self.match_lookahead_literal("cast", 1): - _t1627 = 12 + _t1631 = 12 else: if self.match_lookahead_literal("atom", 1): - _t1628 = 8 + _t1632 = 8 else: if self.match_lookahead_literal("and", 1): - _t1629 = 4 + _t1633 = 4 else: if self.match_lookahead_literal(">=", 1): - _t1630 = 10 + _t1634 = 10 else: if self.match_lookahead_literal(">", 1): - _t1631 = 10 + _t1635 = 10 else: if self.match_lookahead_literal("=", 1): - _t1632 = 10 + _t1636 = 10 else: if self.match_lookahead_literal("<=", 1): - _t1633 = 10 + _t1637 = 10 else: if self.match_lookahead_literal("<", 1): - _t1634 = 10 + _t1638 = 10 else: if self.match_lookahead_literal("/", 1): - _t1635 = 10 + _t1639 = 10 else: if self.match_lookahead_literal("-", 1): - _t1636 = 10 + _t1640 = 10 else: if self.match_lookahead_literal("+", 1): - _t1637 = 10 + _t1641 = 10 else: if self.match_lookahead_literal("*", 1): - _t1638 = 10 + _t1642 = 10 else: - _t1638 = -1 - _t1637 = _t1638 - _t1636 = _t1637 - _t1635 = _t1636 - _t1634 = _t1635 - _t1633 = _t1634 - _t1632 = _t1633 - _t1631 = _t1632 - _t1630 = _t1631 - _t1629 = _t1630 - _t1628 = _t1629 - _t1627 = _t1628 - _t1626 = _t1627 - _t1625 = _t1626 - _t1624 = _t1625 - _t1623 = _t1624 - _t1622 = _t1623 - _t1621 = _t1622 - _t1620 = _t1621 - _t1619 = _t1620 - _t1618 = _t1619 - _t1617 = _t1618 - _t1616 = _t1617 + _t1642 = -1 + _t1641 = _t1642 + _t1640 = _t1641 + _t1639 = _t1640 + _t1638 = _t1639 + _t1637 = _t1638 + _t1636 = _t1637 + _t1635 = _t1636 + _t1634 = _t1635 + _t1633 = _t1634 + _t1632 = _t1633 + _t1631 = _t1632 + _t1630 = _t1631 + _t1629 = _t1630 + _t1628 = _t1629 + _t1627 = _t1628 + _t1626 = _t1627 + _t1625 = _t1626 + _t1624 = _t1625 + _t1623 = _t1624 + _t1622 = _t1623 + _t1621 = _t1622 + _t1620 = _t1621 else: - _t1616 = -1 - prediction872 = _t1616 - if prediction872 == 12: - _t1640 = self.parse_cast() - cast885 = _t1640 - _t1641 = logic_pb2.Formula(cast=cast885) - _t1639 = _t1641 + _t1620 = -1 + prediction874 = _t1620 + if prediction874 == 12: + _t1644 = self.parse_cast() + cast887 = _t1644 + _t1645 = logic_pb2.Formula(cast=cast887) + _t1643 = _t1645 else: - if prediction872 == 11: - _t1643 = self.parse_rel_atom() - rel_atom884 = _t1643 - _t1644 = logic_pb2.Formula(rel_atom=rel_atom884) - _t1642 = _t1644 + if prediction874 == 11: + _t1647 = self.parse_rel_atom() + rel_atom886 = _t1647 + _t1648 = logic_pb2.Formula(rel_atom=rel_atom886) + _t1646 = _t1648 else: - if prediction872 == 10: - _t1646 = self.parse_primitive() - primitive883 = _t1646 - _t1647 = logic_pb2.Formula(primitive=primitive883) - _t1645 = _t1647 + if prediction874 == 10: + _t1650 = self.parse_primitive() + primitive885 = _t1650 + _t1651 = logic_pb2.Formula(primitive=primitive885) + _t1649 = _t1651 else: - if prediction872 == 9: - _t1649 = self.parse_pragma() - pragma882 = _t1649 - _t1650 = logic_pb2.Formula(pragma=pragma882) - _t1648 = _t1650 + if prediction874 == 9: + _t1653 = self.parse_pragma() + pragma884 = _t1653 + _t1654 = logic_pb2.Formula(pragma=pragma884) + _t1652 = _t1654 else: - if prediction872 == 8: - _t1652 = self.parse_atom() - atom881 = _t1652 - _t1653 = logic_pb2.Formula(atom=atom881) - _t1651 = _t1653 + if prediction874 == 8: + _t1656 = self.parse_atom() + atom883 = _t1656 + _t1657 = logic_pb2.Formula(atom=atom883) + _t1655 = _t1657 else: - if prediction872 == 7: - _t1655 = self.parse_ffi() - ffi880 = _t1655 - _t1656 = logic_pb2.Formula(ffi=ffi880) - _t1654 = _t1656 + if prediction874 == 7: + _t1659 = self.parse_ffi() + ffi882 = _t1659 + _t1660 = logic_pb2.Formula(ffi=ffi882) + _t1658 = _t1660 else: - if prediction872 == 6: - _t1658 = self.parse_not() - not879 = _t1658 - _t1659 = logic_pb2.Formula() - getattr(_t1659, 'not').CopyFrom(not879) - _t1657 = _t1659 + if prediction874 == 6: + _t1662 = self.parse_not() + not881 = _t1662 + _t1663 = logic_pb2.Formula() + getattr(_t1663, 'not').CopyFrom(not881) + _t1661 = _t1663 else: - if prediction872 == 5: - _t1661 = self.parse_disjunction() - disjunction878 = _t1661 - _t1662 = logic_pb2.Formula(disjunction=disjunction878) - _t1660 = _t1662 + if prediction874 == 5: + _t1665 = self.parse_disjunction() + disjunction880 = _t1665 + _t1666 = logic_pb2.Formula(disjunction=disjunction880) + _t1664 = _t1666 else: - if prediction872 == 4: - _t1664 = self.parse_conjunction() - conjunction877 = _t1664 - _t1665 = logic_pb2.Formula(conjunction=conjunction877) - _t1663 = _t1665 + if prediction874 == 4: + _t1668 = self.parse_conjunction() + conjunction879 = _t1668 + _t1669 = logic_pb2.Formula(conjunction=conjunction879) + _t1667 = _t1669 else: - if prediction872 == 3: - _t1667 = self.parse_reduce() - reduce876 = _t1667 - _t1668 = logic_pb2.Formula(reduce=reduce876) - _t1666 = _t1668 + if prediction874 == 3: + _t1671 = self.parse_reduce() + reduce878 = _t1671 + _t1672 = logic_pb2.Formula(reduce=reduce878) + _t1670 = _t1672 else: - if prediction872 == 2: - _t1670 = self.parse_exists() - exists875 = _t1670 - _t1671 = logic_pb2.Formula(exists=exists875) - _t1669 = _t1671 + if prediction874 == 2: + _t1674 = self.parse_exists() + exists877 = _t1674 + _t1675 = logic_pb2.Formula(exists=exists877) + _t1673 = _t1675 else: - if prediction872 == 1: - _t1673 = self.parse_false() - false874 = _t1673 - _t1674 = logic_pb2.Formula(disjunction=false874) - _t1672 = _t1674 + if prediction874 == 1: + _t1677 = self.parse_false() + false876 = _t1677 + _t1678 = logic_pb2.Formula(disjunction=false876) + _t1676 = _t1678 else: - if prediction872 == 0: - _t1676 = self.parse_true() - true873 = _t1676 - _t1677 = logic_pb2.Formula(conjunction=true873) - _t1675 = _t1677 + if prediction874 == 0: + _t1680 = self.parse_true() + true875 = _t1680 + _t1681 = logic_pb2.Formula(conjunction=true875) + _t1679 = _t1681 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1672 = _t1675 - _t1669 = _t1672 - _t1666 = _t1669 - _t1663 = _t1666 - _t1660 = _t1663 - _t1657 = _t1660 - _t1654 = _t1657 - _t1651 = _t1654 - _t1648 = _t1651 - _t1645 = _t1648 - _t1642 = _t1645 - _t1639 = _t1642 - result887 = _t1639 - self.record_span(span_start886, "Formula") - return result887 + _t1676 = _t1679 + _t1673 = _t1676 + _t1670 = _t1673 + _t1667 = _t1670 + _t1664 = _t1667 + _t1661 = _t1664 + _t1658 = _t1661 + _t1655 = _t1658 + _t1652 = _t1655 + _t1649 = _t1652 + _t1646 = _t1649 + _t1643 = _t1646 + result889 = _t1643 + self.record_span(span_start888, "Formula") + return result889 def parse_true(self) -> logic_pb2.Conjunction: - span_start888 = self.span_start() + span_start890 = self.span_start() self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t1678 = logic_pb2.Conjunction(args=[]) - result889 = _t1678 - self.record_span(span_start888, "Conjunction") - return result889 + _t1682 = logic_pb2.Conjunction(args=[]) + result891 = _t1682 + self.record_span(span_start890, "Conjunction") + return result891 def parse_false(self) -> logic_pb2.Disjunction: - span_start890 = self.span_start() + span_start892 = self.span_start() self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t1679 = logic_pb2.Disjunction(args=[]) - result891 = _t1679 - self.record_span(span_start890, "Disjunction") - return result891 + _t1683 = logic_pb2.Disjunction(args=[]) + result893 = _t1683 + self.record_span(span_start892, "Disjunction") + return result893 def parse_exists(self) -> logic_pb2.Exists: - span_start894 = self.span_start() + span_start896 = self.span_start() self.consume_literal("(") self.consume_literal("exists") - _t1680 = self.parse_bindings() - bindings892 = _t1680 - _t1681 = self.parse_formula() - formula893 = _t1681 + _t1684 = self.parse_bindings() + bindings894 = _t1684 + _t1685 = self.parse_formula() + formula895 = _t1685 self.consume_literal(")") - _t1682 = logic_pb2.Abstraction(vars=(list(bindings892[0]) + list(bindings892[1] if bindings892[1] is not None else [])), value=formula893) - _t1683 = logic_pb2.Exists(body=_t1682) - result895 = _t1683 - self.record_span(span_start894, "Exists") - return result895 + _t1686 = logic_pb2.Abstraction(vars=(list(bindings894[0]) + list(bindings894[1] if bindings894[1] is not None else [])), value=formula895) + _t1687 = logic_pb2.Exists(body=_t1686) + result897 = _t1687 + self.record_span(span_start896, "Exists") + return result897 def parse_reduce(self) -> logic_pb2.Reduce: - span_start899 = self.span_start() + span_start901 = self.span_start() self.consume_literal("(") self.consume_literal("reduce") - _t1684 = self.parse_abstraction() - abstraction896 = _t1684 - _t1685 = self.parse_abstraction() - abstraction_3897 = _t1685 - _t1686 = self.parse_terms() - terms898 = _t1686 + _t1688 = self.parse_abstraction() + abstraction898 = _t1688 + _t1689 = self.parse_abstraction() + abstraction_3899 = _t1689 + _t1690 = self.parse_terms() + terms900 = _t1690 self.consume_literal(")") - _t1687 = logic_pb2.Reduce(op=abstraction896, body=abstraction_3897, terms=terms898) - result900 = _t1687 - self.record_span(span_start899, "Reduce") - return result900 + _t1691 = logic_pb2.Reduce(op=abstraction898, body=abstraction_3899, terms=terms900) + result902 = _t1691 + self.record_span(span_start901, "Reduce") + return result902 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs901 = [] - cond902 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond902: - _t1688 = self.parse_term() - item903 = _t1688 - xs901.append(item903) - cond902 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - terms904 = xs901 + xs903 = [] + cond904 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond904: + _t1692 = self.parse_term() + item905 = _t1692 + xs903.append(item905) + cond904 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + terms906 = xs903 self.consume_literal(")") - return terms904 + return terms906 def parse_term(self) -> logic_pb2.Term: - span_start908 = self.span_start() + span_start910 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1689 = 1 + _t1693 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1690 = 1 + _t1694 = 1 else: if self.match_lookahead_literal("false", 0): - _t1691 = 1 + _t1695 = 1 else: if self.match_lookahead_literal("(", 0): - _t1692 = 1 + _t1696 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1693 = 0 + _t1697 = 0 else: if self.match_lookahead_terminal("UINT32", 0): - _t1694 = 1 + _t1698 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1695 = 1 + _t1699 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1696 = 1 + _t1700 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1697 = 1 + _t1701 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1698 = 1 + _t1702 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1699 = 1 + _t1703 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1700 = 1 + _t1704 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1701 = 1 + _t1705 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1702 = 1 + _t1706 = 1 else: - _t1702 = -1 - _t1701 = _t1702 - _t1700 = _t1701 - _t1699 = _t1700 - _t1698 = _t1699 - _t1697 = _t1698 - _t1696 = _t1697 - _t1695 = _t1696 - _t1694 = _t1695 - _t1693 = _t1694 - _t1692 = _t1693 - _t1691 = _t1692 - _t1690 = _t1691 - _t1689 = _t1690 - prediction905 = _t1689 - if prediction905 == 1: - _t1704 = self.parse_value() - value907 = _t1704 - _t1705 = logic_pb2.Term(constant=value907) - _t1703 = _t1705 + _t1706 = -1 + _t1705 = _t1706 + _t1704 = _t1705 + _t1703 = _t1704 + _t1702 = _t1703 + _t1701 = _t1702 + _t1700 = _t1701 + _t1699 = _t1700 + _t1698 = _t1699 + _t1697 = _t1698 + _t1696 = _t1697 + _t1695 = _t1696 + _t1694 = _t1695 + _t1693 = _t1694 + prediction907 = _t1693 + if prediction907 == 1: + _t1708 = self.parse_value() + value909 = _t1708 + _t1709 = logic_pb2.Term(constant=value909) + _t1707 = _t1709 else: - if prediction905 == 0: - _t1707 = self.parse_var() - var906 = _t1707 - _t1708 = logic_pb2.Term(var=var906) - _t1706 = _t1708 + if prediction907 == 0: + _t1711 = self.parse_var() + var908 = _t1711 + _t1712 = logic_pb2.Term(var=var908) + _t1710 = _t1712 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1703 = _t1706 - result909 = _t1703 - self.record_span(span_start908, "Term") - return result909 + _t1707 = _t1710 + result911 = _t1707 + self.record_span(span_start910, "Term") + return result911 def parse_var(self) -> logic_pb2.Var: - span_start911 = self.span_start() - symbol910 = self.consume_terminal("SYMBOL") - _t1709 = logic_pb2.Var(name=symbol910) - result912 = _t1709 - self.record_span(span_start911, "Var") - return result912 + span_start913 = self.span_start() + symbol912 = self.consume_terminal("SYMBOL") + _t1713 = logic_pb2.Var(name=symbol912) + result914 = _t1713 + self.record_span(span_start913, "Var") + return result914 def parse_value(self) -> logic_pb2.Value: - span_start926 = self.span_start() + span_start928 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1710 = 12 + _t1714 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1711 = 11 + _t1715 = 11 else: if self.match_lookahead_literal("false", 0): - _t1712 = 12 + _t1716 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1714 = 1 + _t1718 = 1 else: if self.match_lookahead_literal("date", 1): - _t1715 = 0 + _t1719 = 0 else: - _t1715 = -1 - _t1714 = _t1715 - _t1713 = _t1714 + _t1719 = -1 + _t1718 = _t1719 + _t1717 = _t1718 else: if self.match_lookahead_terminal("UINT32", 0): - _t1716 = 7 + _t1720 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1717 = 8 + _t1721 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1718 = 2 + _t1722 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1719 = 3 + _t1723 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1720 = 9 + _t1724 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1721 = 4 + _t1725 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1722 = 5 + _t1726 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1723 = 6 + _t1727 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1724 = 10 + _t1728 = 10 else: - _t1724 = -1 - _t1723 = _t1724 - _t1722 = _t1723 - _t1721 = _t1722 - _t1720 = _t1721 - _t1719 = _t1720 - _t1718 = _t1719 - _t1717 = _t1718 - _t1716 = _t1717 - _t1713 = _t1716 - _t1712 = _t1713 - _t1711 = _t1712 - _t1710 = _t1711 - prediction913 = _t1710 - if prediction913 == 12: - _t1726 = self.parse_boolean_value() - boolean_value925 = _t1726 - _t1727 = logic_pb2.Value(boolean_value=boolean_value925) - _t1725 = _t1727 + _t1728 = -1 + _t1727 = _t1728 + _t1726 = _t1727 + _t1725 = _t1726 + _t1724 = _t1725 + _t1723 = _t1724 + _t1722 = _t1723 + _t1721 = _t1722 + _t1720 = _t1721 + _t1717 = _t1720 + _t1716 = _t1717 + _t1715 = _t1716 + _t1714 = _t1715 + prediction915 = _t1714 + if prediction915 == 12: + _t1730 = self.parse_boolean_value() + boolean_value927 = _t1730 + _t1731 = logic_pb2.Value(boolean_value=boolean_value927) + _t1729 = _t1731 else: - if prediction913 == 11: + if prediction915 == 11: self.consume_literal("missing") - _t1729 = logic_pb2.MissingValue() - _t1730 = logic_pb2.Value(missing_value=_t1729) - _t1728 = _t1730 + _t1733 = logic_pb2.MissingValue() + _t1734 = logic_pb2.Value(missing_value=_t1733) + _t1732 = _t1734 else: - if prediction913 == 10: - formatted_decimal924 = self.consume_terminal("DECIMAL") - _t1732 = logic_pb2.Value(decimal_value=formatted_decimal924) - _t1731 = _t1732 + if prediction915 == 10: + formatted_decimal926 = self.consume_terminal("DECIMAL") + _t1736 = logic_pb2.Value(decimal_value=formatted_decimal926) + _t1735 = _t1736 else: - if prediction913 == 9: - formatted_int128923 = self.consume_terminal("INT128") - _t1734 = logic_pb2.Value(int128_value=formatted_int128923) - _t1733 = _t1734 + if prediction915 == 9: + formatted_int128925 = self.consume_terminal("INT128") + _t1738 = logic_pb2.Value(int128_value=formatted_int128925) + _t1737 = _t1738 else: - if prediction913 == 8: - formatted_uint128922 = self.consume_terminal("UINT128") - _t1736 = logic_pb2.Value(uint128_value=formatted_uint128922) - _t1735 = _t1736 + if prediction915 == 8: + formatted_uint128924 = self.consume_terminal("UINT128") + _t1740 = logic_pb2.Value(uint128_value=formatted_uint128924) + _t1739 = _t1740 else: - if prediction913 == 7: - formatted_uint32921 = self.consume_terminal("UINT32") - _t1738 = logic_pb2.Value(uint32_value=formatted_uint32921) - _t1737 = _t1738 + if prediction915 == 7: + formatted_uint32923 = self.consume_terminal("UINT32") + _t1742 = logic_pb2.Value(uint32_value=formatted_uint32923) + _t1741 = _t1742 else: - if prediction913 == 6: - formatted_float920 = self.consume_terminal("FLOAT") - _t1740 = logic_pb2.Value(float_value=formatted_float920) - _t1739 = _t1740 + if prediction915 == 6: + formatted_float922 = self.consume_terminal("FLOAT") + _t1744 = logic_pb2.Value(float_value=formatted_float922) + _t1743 = _t1744 else: - if prediction913 == 5: - formatted_float32919 = self.consume_terminal("FLOAT32") - _t1742 = logic_pb2.Value(float32_value=formatted_float32919) - _t1741 = _t1742 + if prediction915 == 5: + formatted_float32921 = self.consume_terminal("FLOAT32") + _t1746 = logic_pb2.Value(float32_value=formatted_float32921) + _t1745 = _t1746 else: - if prediction913 == 4: - formatted_int918 = self.consume_terminal("INT") - _t1744 = logic_pb2.Value(int_value=formatted_int918) - _t1743 = _t1744 + if prediction915 == 4: + formatted_int920 = self.consume_terminal("INT") + _t1748 = logic_pb2.Value(int_value=formatted_int920) + _t1747 = _t1748 else: - if prediction913 == 3: - formatted_int32917 = self.consume_terminal("INT32") - _t1746 = logic_pb2.Value(int32_value=formatted_int32917) - _t1745 = _t1746 + if prediction915 == 3: + formatted_int32919 = self.consume_terminal("INT32") + _t1750 = logic_pb2.Value(int32_value=formatted_int32919) + _t1749 = _t1750 else: - if prediction913 == 2: - formatted_string916 = self.consume_terminal("STRING") - _t1748 = logic_pb2.Value(string_value=formatted_string916) - _t1747 = _t1748 + if prediction915 == 2: + formatted_string918 = self.consume_terminal("STRING") + _t1752 = logic_pb2.Value(string_value=formatted_string918) + _t1751 = _t1752 else: - if prediction913 == 1: - _t1750 = self.parse_datetime() - datetime915 = _t1750 - _t1751 = logic_pb2.Value(datetime_value=datetime915) - _t1749 = _t1751 + if prediction915 == 1: + _t1754 = self.parse_datetime() + datetime917 = _t1754 + _t1755 = logic_pb2.Value(datetime_value=datetime917) + _t1753 = _t1755 else: - if prediction913 == 0: - _t1753 = self.parse_date() - date914 = _t1753 - _t1754 = logic_pb2.Value(date_value=date914) - _t1752 = _t1754 + if prediction915 == 0: + _t1757 = self.parse_date() + date916 = _t1757 + _t1758 = logic_pb2.Value(date_value=date916) + _t1756 = _t1758 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1749 = _t1752 - _t1747 = _t1749 - _t1745 = _t1747 - _t1743 = _t1745 - _t1741 = _t1743 - _t1739 = _t1741 - _t1737 = _t1739 - _t1735 = _t1737 - _t1733 = _t1735 - _t1731 = _t1733 - _t1728 = _t1731 - _t1725 = _t1728 - result927 = _t1725 - self.record_span(span_start926, "Value") - return result927 + _t1753 = _t1756 + _t1751 = _t1753 + _t1749 = _t1751 + _t1747 = _t1749 + _t1745 = _t1747 + _t1743 = _t1745 + _t1741 = _t1743 + _t1739 = _t1741 + _t1737 = _t1739 + _t1735 = _t1737 + _t1732 = _t1735 + _t1729 = _t1732 + result929 = _t1729 + self.record_span(span_start928, "Value") + return result929 def parse_date(self) -> logic_pb2.DateValue: - span_start931 = self.span_start() + span_start933 = self.span_start() self.consume_literal("(") self.consume_literal("date") - formatted_int928 = self.consume_terminal("INT") - formatted_int_3929 = self.consume_terminal("INT") - formatted_int_4930 = self.consume_terminal("INT") + formatted_int930 = self.consume_terminal("INT") + formatted_int_3931 = self.consume_terminal("INT") + formatted_int_4932 = self.consume_terminal("INT") self.consume_literal(")") - _t1755 = logic_pb2.DateValue(year=int(formatted_int928), month=int(formatted_int_3929), day=int(formatted_int_4930)) - result932 = _t1755 - self.record_span(span_start931, "DateValue") - return result932 + _t1759 = logic_pb2.DateValue(year=int(formatted_int930), month=int(formatted_int_3931), day=int(formatted_int_4932)) + result934 = _t1759 + self.record_span(span_start933, "DateValue") + return result934 def parse_datetime(self) -> logic_pb2.DateTimeValue: - span_start940 = self.span_start() + span_start942 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - formatted_int933 = self.consume_terminal("INT") - formatted_int_3934 = self.consume_terminal("INT") - formatted_int_4935 = self.consume_terminal("INT") - formatted_int_5936 = self.consume_terminal("INT") - formatted_int_6937 = self.consume_terminal("INT") - formatted_int_7938 = self.consume_terminal("INT") + formatted_int935 = self.consume_terminal("INT") + formatted_int_3936 = self.consume_terminal("INT") + formatted_int_4937 = self.consume_terminal("INT") + formatted_int_5938 = self.consume_terminal("INT") + formatted_int_6939 = self.consume_terminal("INT") + formatted_int_7940 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1756 = self.consume_terminal("INT") + _t1760 = self.consume_terminal("INT") else: - _t1756 = None - formatted_int_8939 = _t1756 + _t1760 = None + formatted_int_8941 = _t1760 self.consume_literal(")") - _t1757 = logic_pb2.DateTimeValue(year=int(formatted_int933), month=int(formatted_int_3934), day=int(formatted_int_4935), hour=int(formatted_int_5936), minute=int(formatted_int_6937), second=int(formatted_int_7938), microsecond=int((formatted_int_8939 if formatted_int_8939 is not None else 0))) - result941 = _t1757 - self.record_span(span_start940, "DateTimeValue") - return result941 + _t1761 = logic_pb2.DateTimeValue(year=int(formatted_int935), month=int(formatted_int_3936), day=int(formatted_int_4937), hour=int(formatted_int_5938), minute=int(formatted_int_6939), second=int(formatted_int_7940), microsecond=int((formatted_int_8941 if formatted_int_8941 is not None else 0))) + result943 = _t1761 + self.record_span(span_start942, "DateTimeValue") + return result943 def parse_conjunction(self) -> logic_pb2.Conjunction: - span_start946 = self.span_start() + span_start948 = self.span_start() self.consume_literal("(") self.consume_literal("and") - xs942 = [] - cond943 = self.match_lookahead_literal("(", 0) - while cond943: - _t1758 = self.parse_formula() - item944 = _t1758 - xs942.append(item944) - cond943 = self.match_lookahead_literal("(", 0) - formulas945 = xs942 + xs944 = [] + cond945 = self.match_lookahead_literal("(", 0) + while cond945: + _t1762 = self.parse_formula() + item946 = _t1762 + xs944.append(item946) + cond945 = self.match_lookahead_literal("(", 0) + formulas947 = xs944 self.consume_literal(")") - _t1759 = logic_pb2.Conjunction(args=formulas945) - result947 = _t1759 - self.record_span(span_start946, "Conjunction") - return result947 + _t1763 = logic_pb2.Conjunction(args=formulas947) + result949 = _t1763 + self.record_span(span_start948, "Conjunction") + return result949 def parse_disjunction(self) -> logic_pb2.Disjunction: - span_start952 = self.span_start() + span_start954 = self.span_start() self.consume_literal("(") self.consume_literal("or") - xs948 = [] - cond949 = self.match_lookahead_literal("(", 0) - while cond949: - _t1760 = self.parse_formula() - item950 = _t1760 - xs948.append(item950) - cond949 = self.match_lookahead_literal("(", 0) - formulas951 = xs948 + xs950 = [] + cond951 = self.match_lookahead_literal("(", 0) + while cond951: + _t1764 = self.parse_formula() + item952 = _t1764 + xs950.append(item952) + cond951 = self.match_lookahead_literal("(", 0) + formulas953 = xs950 self.consume_literal(")") - _t1761 = logic_pb2.Disjunction(args=formulas951) - result953 = _t1761 - self.record_span(span_start952, "Disjunction") - return result953 + _t1765 = logic_pb2.Disjunction(args=formulas953) + result955 = _t1765 + self.record_span(span_start954, "Disjunction") + return result955 def parse_not(self) -> logic_pb2.Not: - span_start955 = self.span_start() + span_start957 = self.span_start() self.consume_literal("(") self.consume_literal("not") - _t1762 = self.parse_formula() - formula954 = _t1762 + _t1766 = self.parse_formula() + formula956 = _t1766 self.consume_literal(")") - _t1763 = logic_pb2.Not(arg=formula954) - result956 = _t1763 - self.record_span(span_start955, "Not") - return result956 + _t1767 = logic_pb2.Not(arg=formula956) + result958 = _t1767 + self.record_span(span_start957, "Not") + return result958 def parse_ffi(self) -> logic_pb2.FFI: - span_start960 = self.span_start() + span_start962 = self.span_start() self.consume_literal("(") self.consume_literal("ffi") - _t1764 = self.parse_name() - name957 = _t1764 - _t1765 = self.parse_ffi_args() - ffi_args958 = _t1765 - _t1766 = self.parse_terms() - terms959 = _t1766 + _t1768 = self.parse_name() + name959 = _t1768 + _t1769 = self.parse_ffi_args() + ffi_args960 = _t1769 + _t1770 = self.parse_terms() + terms961 = _t1770 self.consume_literal(")") - _t1767 = logic_pb2.FFI(name=name957, args=ffi_args958, terms=terms959) - result961 = _t1767 - self.record_span(span_start960, "FFI") - return result961 + _t1771 = logic_pb2.FFI(name=name959, args=ffi_args960, terms=terms961) + result963 = _t1771 + self.record_span(span_start962, "FFI") + return result963 def parse_name(self) -> str: self.consume_literal(":") - symbol962 = self.consume_terminal("SYMBOL") - return symbol962 + symbol964 = self.consume_terminal("SYMBOL") + return symbol964 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs963 = [] - cond964 = self.match_lookahead_literal("(", 0) - while cond964: - _t1768 = self.parse_abstraction() - item965 = _t1768 - xs963.append(item965) - cond964 = self.match_lookahead_literal("(", 0) - abstractions966 = xs963 + xs965 = [] + cond966 = self.match_lookahead_literal("(", 0) + while cond966: + _t1772 = self.parse_abstraction() + item967 = _t1772 + xs965.append(item967) + cond966 = self.match_lookahead_literal("(", 0) + abstractions968 = xs965 self.consume_literal(")") - return abstractions966 + return abstractions968 def parse_atom(self) -> logic_pb2.Atom: - span_start972 = self.span_start() + span_start974 = self.span_start() self.consume_literal("(") self.consume_literal("atom") - _t1769 = self.parse_relation_id() - relation_id967 = _t1769 - xs968 = [] - cond969 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond969: - _t1770 = self.parse_term() - item970 = _t1770 - xs968.append(item970) - cond969 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - terms971 = xs968 + _t1773 = self.parse_relation_id() + relation_id969 = _t1773 + xs970 = [] + cond971 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond971: + _t1774 = self.parse_term() + item972 = _t1774 + xs970.append(item972) + cond971 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + terms973 = xs970 self.consume_literal(")") - _t1771 = logic_pb2.Atom(name=relation_id967, terms=terms971) - result973 = _t1771 - self.record_span(span_start972, "Atom") - return result973 + _t1775 = logic_pb2.Atom(name=relation_id969, terms=terms973) + result975 = _t1775 + self.record_span(span_start974, "Atom") + return result975 def parse_pragma(self) -> logic_pb2.Pragma: - span_start979 = self.span_start() + span_start981 = self.span_start() self.consume_literal("(") self.consume_literal("pragma") - _t1772 = self.parse_name() - name974 = _t1772 - xs975 = [] - cond976 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond976: - _t1773 = self.parse_term() - item977 = _t1773 - xs975.append(item977) - cond976 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - terms978 = xs975 + _t1776 = self.parse_name() + name976 = _t1776 + xs977 = [] + cond978 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond978: + _t1777 = self.parse_term() + item979 = _t1777 + xs977.append(item979) + cond978 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + terms980 = xs977 self.consume_literal(")") - _t1774 = logic_pb2.Pragma(name=name974, terms=terms978) - result980 = _t1774 - self.record_span(span_start979, "Pragma") - return result980 + _t1778 = logic_pb2.Pragma(name=name976, terms=terms980) + result982 = _t1778 + self.record_span(span_start981, "Pragma") + return result982 def parse_primitive(self) -> logic_pb2.Primitive: - span_start996 = self.span_start() + span_start998 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1776 = 9 + _t1780 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1777 = 4 + _t1781 = 4 else: if self.match_lookahead_literal(">", 1): - _t1778 = 3 + _t1782 = 3 else: if self.match_lookahead_literal("=", 1): - _t1779 = 0 + _t1783 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1780 = 2 + _t1784 = 2 else: if self.match_lookahead_literal("<", 1): - _t1781 = 1 + _t1785 = 1 else: if self.match_lookahead_literal("/", 1): - _t1782 = 8 + _t1786 = 8 else: if self.match_lookahead_literal("-", 1): - _t1783 = 6 + _t1787 = 6 else: if self.match_lookahead_literal("+", 1): - _t1784 = 5 + _t1788 = 5 else: if self.match_lookahead_literal("*", 1): - _t1785 = 7 + _t1789 = 7 else: - _t1785 = -1 - _t1784 = _t1785 - _t1783 = _t1784 - _t1782 = _t1783 - _t1781 = _t1782 - _t1780 = _t1781 - _t1779 = _t1780 - _t1778 = _t1779 - _t1777 = _t1778 - _t1776 = _t1777 - _t1775 = _t1776 + _t1789 = -1 + _t1788 = _t1789 + _t1787 = _t1788 + _t1786 = _t1787 + _t1785 = _t1786 + _t1784 = _t1785 + _t1783 = _t1784 + _t1782 = _t1783 + _t1781 = _t1782 + _t1780 = _t1781 + _t1779 = _t1780 else: - _t1775 = -1 - prediction981 = _t1775 - if prediction981 == 9: + _t1779 = -1 + prediction983 = _t1779 + if prediction983 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1787 = self.parse_name() - name991 = _t1787 - xs992 = [] - cond993 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond993: - _t1788 = self.parse_rel_term() - item994 = _t1788 - xs992.append(item994) - cond993 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - rel_terms995 = xs992 + _t1791 = self.parse_name() + name993 = _t1791 + xs994 = [] + cond995 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond995: + _t1792 = self.parse_rel_term() + item996 = _t1792 + xs994.append(item996) + cond995 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + rel_terms997 = xs994 self.consume_literal(")") - _t1789 = logic_pb2.Primitive(name=name991, terms=rel_terms995) - _t1786 = _t1789 + _t1793 = logic_pb2.Primitive(name=name993, terms=rel_terms997) + _t1790 = _t1793 else: - if prediction981 == 8: - _t1791 = self.parse_divide() - divide990 = _t1791 - _t1790 = divide990 + if prediction983 == 8: + _t1795 = self.parse_divide() + divide992 = _t1795 + _t1794 = divide992 else: - if prediction981 == 7: - _t1793 = self.parse_multiply() - multiply989 = _t1793 - _t1792 = multiply989 + if prediction983 == 7: + _t1797 = self.parse_multiply() + multiply991 = _t1797 + _t1796 = multiply991 else: - if prediction981 == 6: - _t1795 = self.parse_minus() - minus988 = _t1795 - _t1794 = minus988 + if prediction983 == 6: + _t1799 = self.parse_minus() + minus990 = _t1799 + _t1798 = minus990 else: - if prediction981 == 5: - _t1797 = self.parse_add() - add987 = _t1797 - _t1796 = add987 + if prediction983 == 5: + _t1801 = self.parse_add() + add989 = _t1801 + _t1800 = add989 else: - if prediction981 == 4: - _t1799 = self.parse_gt_eq() - gt_eq986 = _t1799 - _t1798 = gt_eq986 + if prediction983 == 4: + _t1803 = self.parse_gt_eq() + gt_eq988 = _t1803 + _t1802 = gt_eq988 else: - if prediction981 == 3: - _t1801 = self.parse_gt() - gt985 = _t1801 - _t1800 = gt985 + if prediction983 == 3: + _t1805 = self.parse_gt() + gt987 = _t1805 + _t1804 = gt987 else: - if prediction981 == 2: - _t1803 = self.parse_lt_eq() - lt_eq984 = _t1803 - _t1802 = lt_eq984 + if prediction983 == 2: + _t1807 = self.parse_lt_eq() + lt_eq986 = _t1807 + _t1806 = lt_eq986 else: - if prediction981 == 1: - _t1805 = self.parse_lt() - lt983 = _t1805 - _t1804 = lt983 + if prediction983 == 1: + _t1809 = self.parse_lt() + lt985 = _t1809 + _t1808 = lt985 else: - if prediction981 == 0: - _t1807 = self.parse_eq() - eq982 = _t1807 - _t1806 = eq982 + if prediction983 == 0: + _t1811 = self.parse_eq() + eq984 = _t1811 + _t1810 = eq984 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1804 = _t1806 - _t1802 = _t1804 - _t1800 = _t1802 - _t1798 = _t1800 - _t1796 = _t1798 - _t1794 = _t1796 - _t1792 = _t1794 - _t1790 = _t1792 - _t1786 = _t1790 - result997 = _t1786 - self.record_span(span_start996, "Primitive") - return result997 + _t1808 = _t1810 + _t1806 = _t1808 + _t1804 = _t1806 + _t1802 = _t1804 + _t1800 = _t1802 + _t1798 = _t1800 + _t1796 = _t1798 + _t1794 = _t1796 + _t1790 = _t1794 + result999 = _t1790 + self.record_span(span_start998, "Primitive") + return result999 def parse_eq(self) -> logic_pb2.Primitive: - span_start1000 = self.span_start() + span_start1002 = self.span_start() self.consume_literal("(") self.consume_literal("=") - _t1808 = self.parse_term() - term998 = _t1808 - _t1809 = self.parse_term() - term_3999 = _t1809 + _t1812 = self.parse_term() + term1000 = _t1812 + _t1813 = self.parse_term() + term_31001 = _t1813 self.consume_literal(")") - _t1810 = logic_pb2.RelTerm(term=term998) - _t1811 = logic_pb2.RelTerm(term=term_3999) - _t1812 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1810, _t1811]) - result1001 = _t1812 - self.record_span(span_start1000, "Primitive") - return result1001 + _t1814 = logic_pb2.RelTerm(term=term1000) + _t1815 = logic_pb2.RelTerm(term=term_31001) + _t1816 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1814, _t1815]) + result1003 = _t1816 + self.record_span(span_start1002, "Primitive") + return result1003 def parse_lt(self) -> logic_pb2.Primitive: - span_start1004 = self.span_start() + span_start1006 = self.span_start() self.consume_literal("(") self.consume_literal("<") - _t1813 = self.parse_term() - term1002 = _t1813 - _t1814 = self.parse_term() - term_31003 = _t1814 + _t1817 = self.parse_term() + term1004 = _t1817 + _t1818 = self.parse_term() + term_31005 = _t1818 self.consume_literal(")") - _t1815 = logic_pb2.RelTerm(term=term1002) - _t1816 = logic_pb2.RelTerm(term=term_31003) - _t1817 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1815, _t1816]) - result1005 = _t1817 - self.record_span(span_start1004, "Primitive") - return result1005 + _t1819 = logic_pb2.RelTerm(term=term1004) + _t1820 = logic_pb2.RelTerm(term=term_31005) + _t1821 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1819, _t1820]) + result1007 = _t1821 + self.record_span(span_start1006, "Primitive") + return result1007 def parse_lt_eq(self) -> logic_pb2.Primitive: - span_start1008 = self.span_start() + span_start1010 = self.span_start() self.consume_literal("(") self.consume_literal("<=") - _t1818 = self.parse_term() - term1006 = _t1818 - _t1819 = self.parse_term() - term_31007 = _t1819 + _t1822 = self.parse_term() + term1008 = _t1822 + _t1823 = self.parse_term() + term_31009 = _t1823 self.consume_literal(")") - _t1820 = logic_pb2.RelTerm(term=term1006) - _t1821 = logic_pb2.RelTerm(term=term_31007) - _t1822 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1820, _t1821]) - result1009 = _t1822 - self.record_span(span_start1008, "Primitive") - return result1009 + _t1824 = logic_pb2.RelTerm(term=term1008) + _t1825 = logic_pb2.RelTerm(term=term_31009) + _t1826 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1824, _t1825]) + result1011 = _t1826 + self.record_span(span_start1010, "Primitive") + return result1011 def parse_gt(self) -> logic_pb2.Primitive: - span_start1012 = self.span_start() + span_start1014 = self.span_start() self.consume_literal("(") self.consume_literal(">") - _t1823 = self.parse_term() - term1010 = _t1823 - _t1824 = self.parse_term() - term_31011 = _t1824 + _t1827 = self.parse_term() + term1012 = _t1827 + _t1828 = self.parse_term() + term_31013 = _t1828 self.consume_literal(")") - _t1825 = logic_pb2.RelTerm(term=term1010) - _t1826 = logic_pb2.RelTerm(term=term_31011) - _t1827 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1825, _t1826]) - result1013 = _t1827 - self.record_span(span_start1012, "Primitive") - return result1013 + _t1829 = logic_pb2.RelTerm(term=term1012) + _t1830 = logic_pb2.RelTerm(term=term_31013) + _t1831 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1829, _t1830]) + result1015 = _t1831 + self.record_span(span_start1014, "Primitive") + return result1015 def parse_gt_eq(self) -> logic_pb2.Primitive: - span_start1016 = self.span_start() + span_start1018 = self.span_start() self.consume_literal("(") self.consume_literal(">=") - _t1828 = self.parse_term() - term1014 = _t1828 - _t1829 = self.parse_term() - term_31015 = _t1829 + _t1832 = self.parse_term() + term1016 = _t1832 + _t1833 = self.parse_term() + term_31017 = _t1833 self.consume_literal(")") - _t1830 = logic_pb2.RelTerm(term=term1014) - _t1831 = logic_pb2.RelTerm(term=term_31015) - _t1832 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1830, _t1831]) - result1017 = _t1832 - self.record_span(span_start1016, "Primitive") - return result1017 + _t1834 = logic_pb2.RelTerm(term=term1016) + _t1835 = logic_pb2.RelTerm(term=term_31017) + _t1836 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1834, _t1835]) + result1019 = _t1836 + self.record_span(span_start1018, "Primitive") + return result1019 def parse_add(self) -> logic_pb2.Primitive: - span_start1021 = self.span_start() + span_start1023 = self.span_start() self.consume_literal("(") self.consume_literal("+") - _t1833 = self.parse_term() - term1018 = _t1833 - _t1834 = self.parse_term() - term_31019 = _t1834 - _t1835 = self.parse_term() - term_41020 = _t1835 + _t1837 = self.parse_term() + term1020 = _t1837 + _t1838 = self.parse_term() + term_31021 = _t1838 + _t1839 = self.parse_term() + term_41022 = _t1839 self.consume_literal(")") - _t1836 = logic_pb2.RelTerm(term=term1018) - _t1837 = logic_pb2.RelTerm(term=term_31019) - _t1838 = logic_pb2.RelTerm(term=term_41020) - _t1839 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1836, _t1837, _t1838]) - result1022 = _t1839 - self.record_span(span_start1021, "Primitive") - return result1022 + _t1840 = logic_pb2.RelTerm(term=term1020) + _t1841 = logic_pb2.RelTerm(term=term_31021) + _t1842 = logic_pb2.RelTerm(term=term_41022) + _t1843 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1840, _t1841, _t1842]) + result1024 = _t1843 + self.record_span(span_start1023, "Primitive") + return result1024 def parse_minus(self) -> logic_pb2.Primitive: - span_start1026 = self.span_start() + span_start1028 = self.span_start() self.consume_literal("(") self.consume_literal("-") - _t1840 = self.parse_term() - term1023 = _t1840 - _t1841 = self.parse_term() - term_31024 = _t1841 - _t1842 = self.parse_term() - term_41025 = _t1842 + _t1844 = self.parse_term() + term1025 = _t1844 + _t1845 = self.parse_term() + term_31026 = _t1845 + _t1846 = self.parse_term() + term_41027 = _t1846 self.consume_literal(")") - _t1843 = logic_pb2.RelTerm(term=term1023) - _t1844 = logic_pb2.RelTerm(term=term_31024) - _t1845 = logic_pb2.RelTerm(term=term_41025) - _t1846 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1843, _t1844, _t1845]) - result1027 = _t1846 - self.record_span(span_start1026, "Primitive") - return result1027 + _t1847 = logic_pb2.RelTerm(term=term1025) + _t1848 = logic_pb2.RelTerm(term=term_31026) + _t1849 = logic_pb2.RelTerm(term=term_41027) + _t1850 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1847, _t1848, _t1849]) + result1029 = _t1850 + self.record_span(span_start1028, "Primitive") + return result1029 def parse_multiply(self) -> logic_pb2.Primitive: - span_start1031 = self.span_start() + span_start1033 = self.span_start() self.consume_literal("(") self.consume_literal("*") - _t1847 = self.parse_term() - term1028 = _t1847 - _t1848 = self.parse_term() - term_31029 = _t1848 - _t1849 = self.parse_term() - term_41030 = _t1849 + _t1851 = self.parse_term() + term1030 = _t1851 + _t1852 = self.parse_term() + term_31031 = _t1852 + _t1853 = self.parse_term() + term_41032 = _t1853 self.consume_literal(")") - _t1850 = logic_pb2.RelTerm(term=term1028) - _t1851 = logic_pb2.RelTerm(term=term_31029) - _t1852 = logic_pb2.RelTerm(term=term_41030) - _t1853 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1850, _t1851, _t1852]) - result1032 = _t1853 - self.record_span(span_start1031, "Primitive") - return result1032 + _t1854 = logic_pb2.RelTerm(term=term1030) + _t1855 = logic_pb2.RelTerm(term=term_31031) + _t1856 = logic_pb2.RelTerm(term=term_41032) + _t1857 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1854, _t1855, _t1856]) + result1034 = _t1857 + self.record_span(span_start1033, "Primitive") + return result1034 def parse_divide(self) -> logic_pb2.Primitive: - span_start1036 = self.span_start() + span_start1038 = self.span_start() self.consume_literal("(") self.consume_literal("/") - _t1854 = self.parse_term() - term1033 = _t1854 - _t1855 = self.parse_term() - term_31034 = _t1855 - _t1856 = self.parse_term() - term_41035 = _t1856 + _t1858 = self.parse_term() + term1035 = _t1858 + _t1859 = self.parse_term() + term_31036 = _t1859 + _t1860 = self.parse_term() + term_41037 = _t1860 self.consume_literal(")") - _t1857 = logic_pb2.RelTerm(term=term1033) - _t1858 = logic_pb2.RelTerm(term=term_31034) - _t1859 = logic_pb2.RelTerm(term=term_41035) - _t1860 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1857, _t1858, _t1859]) - result1037 = _t1860 - self.record_span(span_start1036, "Primitive") - return result1037 + _t1861 = logic_pb2.RelTerm(term=term1035) + _t1862 = logic_pb2.RelTerm(term=term_31036) + _t1863 = logic_pb2.RelTerm(term=term_41037) + _t1864 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1861, _t1862, _t1863]) + result1039 = _t1864 + self.record_span(span_start1038, "Primitive") + return result1039 def parse_rel_term(self) -> logic_pb2.RelTerm: - span_start1041 = self.span_start() + span_start1043 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1861 = 1 + _t1865 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1862 = 1 + _t1866 = 1 else: if self.match_lookahead_literal("false", 0): - _t1863 = 1 + _t1867 = 1 else: if self.match_lookahead_literal("(", 0): - _t1864 = 1 + _t1868 = 1 else: if self.match_lookahead_literal("#", 0): - _t1865 = 0 + _t1869 = 0 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1866 = 1 + _t1870 = 1 else: if self.match_lookahead_terminal("UINT32", 0): - _t1867 = 1 + _t1871 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1868 = 1 + _t1872 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1869 = 1 + _t1873 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1870 = 1 + _t1874 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1871 = 1 + _t1875 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1872 = 1 + _t1876 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1873 = 1 + _t1877 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1874 = 1 + _t1878 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1875 = 1 + _t1879 = 1 else: - _t1875 = -1 - _t1874 = _t1875 - _t1873 = _t1874 - _t1872 = _t1873 - _t1871 = _t1872 - _t1870 = _t1871 - _t1869 = _t1870 - _t1868 = _t1869 - _t1867 = _t1868 - _t1866 = _t1867 - _t1865 = _t1866 - _t1864 = _t1865 - _t1863 = _t1864 - _t1862 = _t1863 - _t1861 = _t1862 - prediction1038 = _t1861 - if prediction1038 == 1: - _t1877 = self.parse_term() - term1040 = _t1877 - _t1878 = logic_pb2.RelTerm(term=term1040) - _t1876 = _t1878 + _t1879 = -1 + _t1878 = _t1879 + _t1877 = _t1878 + _t1876 = _t1877 + _t1875 = _t1876 + _t1874 = _t1875 + _t1873 = _t1874 + _t1872 = _t1873 + _t1871 = _t1872 + _t1870 = _t1871 + _t1869 = _t1870 + _t1868 = _t1869 + _t1867 = _t1868 + _t1866 = _t1867 + _t1865 = _t1866 + prediction1040 = _t1865 + if prediction1040 == 1: + _t1881 = self.parse_term() + term1042 = _t1881 + _t1882 = logic_pb2.RelTerm(term=term1042) + _t1880 = _t1882 else: - if prediction1038 == 0: - _t1880 = self.parse_specialized_value() - specialized_value1039 = _t1880 - _t1881 = logic_pb2.RelTerm(specialized_value=specialized_value1039) - _t1879 = _t1881 + if prediction1040 == 0: + _t1884 = self.parse_specialized_value() + specialized_value1041 = _t1884 + _t1885 = logic_pb2.RelTerm(specialized_value=specialized_value1041) + _t1883 = _t1885 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1876 = _t1879 - result1042 = _t1876 - self.record_span(span_start1041, "RelTerm") - return result1042 + _t1880 = _t1883 + result1044 = _t1880 + self.record_span(span_start1043, "RelTerm") + return result1044 def parse_specialized_value(self) -> logic_pb2.Value: - span_start1044 = self.span_start() + span_start1046 = self.span_start() self.consume_literal("#") - _t1882 = self.parse_raw_value() - raw_value1043 = _t1882 - result1045 = raw_value1043 - self.record_span(span_start1044, "Value") - return result1045 + _t1886 = self.parse_raw_value() + raw_value1045 = _t1886 + result1047 = raw_value1045 + self.record_span(span_start1046, "Value") + return result1047 def parse_rel_atom(self) -> logic_pb2.RelAtom: - span_start1051 = self.span_start() + span_start1053 = self.span_start() self.consume_literal("(") self.consume_literal("relatom") - _t1883 = self.parse_name() - name1046 = _t1883 - xs1047 = [] - cond1048 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond1048: - _t1884 = self.parse_rel_term() - item1049 = _t1884 - xs1047.append(item1049) - cond1048 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - rel_terms1050 = xs1047 + _t1887 = self.parse_name() + name1048 = _t1887 + xs1049 = [] + cond1050 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond1050: + _t1888 = self.parse_rel_term() + item1051 = _t1888 + xs1049.append(item1051) + cond1050 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + rel_terms1052 = xs1049 self.consume_literal(")") - _t1885 = logic_pb2.RelAtom(name=name1046, terms=rel_terms1050) - result1052 = _t1885 - self.record_span(span_start1051, "RelAtom") - return result1052 + _t1889 = logic_pb2.RelAtom(name=name1048, terms=rel_terms1052) + result1054 = _t1889 + self.record_span(span_start1053, "RelAtom") + return result1054 def parse_cast(self) -> logic_pb2.Cast: - span_start1055 = self.span_start() + span_start1057 = self.span_start() self.consume_literal("(") self.consume_literal("cast") - _t1886 = self.parse_term() - term1053 = _t1886 - _t1887 = self.parse_term() - term_31054 = _t1887 + _t1890 = self.parse_term() + term1055 = _t1890 + _t1891 = self.parse_term() + term_31056 = _t1891 self.consume_literal(")") - _t1888 = logic_pb2.Cast(input=term1053, result=term_31054) - result1056 = _t1888 - self.record_span(span_start1055, "Cast") - return result1056 + _t1892 = logic_pb2.Cast(input=term1055, result=term_31056) + result1058 = _t1892 + self.record_span(span_start1057, "Cast") + return result1058 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs1057 = [] - cond1058 = self.match_lookahead_literal("(", 0) - while cond1058: - _t1889 = self.parse_attribute() - item1059 = _t1889 - xs1057.append(item1059) - cond1058 = self.match_lookahead_literal("(", 0) - attributes1060 = xs1057 + xs1059 = [] + cond1060 = self.match_lookahead_literal("(", 0) + while cond1060: + _t1893 = self.parse_attribute() + item1061 = _t1893 + xs1059.append(item1061) + cond1060 = self.match_lookahead_literal("(", 0) + attributes1062 = xs1059 self.consume_literal(")") - return attributes1060 + return attributes1062 def parse_attribute(self) -> logic_pb2.Attribute: - span_start1066 = self.span_start() + span_start1068 = self.span_start() self.consume_literal("(") self.consume_literal("attribute") - _t1890 = self.parse_name() - name1061 = _t1890 - xs1062 = [] - cond1063 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) - while cond1063: - _t1891 = self.parse_raw_value() - item1064 = _t1891 - xs1062.append(item1064) - cond1063 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) - raw_values1065 = xs1062 + _t1894 = self.parse_name() + name1063 = _t1894 + xs1064 = [] + cond1065 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) + while cond1065: + _t1895 = self.parse_raw_value() + item1066 = _t1895 + xs1064.append(item1066) + cond1065 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) + raw_values1067 = xs1064 self.consume_literal(")") - _t1892 = logic_pb2.Attribute(name=name1061, args=raw_values1065) - result1067 = _t1892 - self.record_span(span_start1066, "Attribute") - return result1067 + _t1896 = logic_pb2.Attribute(name=name1063, args=raw_values1067) + result1069 = _t1896 + self.record_span(span_start1068, "Attribute") + return result1069 def parse_algorithm(self) -> logic_pb2.Algorithm: - span_start1074 = self.span_start() + span_start1076 = self.span_start() self.consume_literal("(") self.consume_literal("algorithm") - xs1068 = [] - cond1069 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1069: - _t1893 = self.parse_relation_id() - item1070 = _t1893 - xs1068.append(item1070) - cond1069 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1071 = xs1068 - _t1894 = self.parse_script() - script1072 = _t1894 + xs1070 = [] + cond1071 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1071: + _t1897 = self.parse_relation_id() + item1072 = _t1897 + xs1070.append(item1072) + cond1071 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1073 = xs1070 + _t1898 = self.parse_script() + script1074 = _t1898 if self.match_lookahead_literal("(", 0): - _t1896 = self.parse_attrs() - _t1895 = _t1896 + _t1900 = self.parse_attrs() + _t1899 = _t1900 else: - _t1895 = None - attrs1073 = _t1895 + _t1899 = None + attrs1075 = _t1899 self.consume_literal(")") - _t1897 = logic_pb2.Algorithm(body=script1072, attrs=(attrs1073 if attrs1073 is not None else [])) - getattr(_t1897, 'global').extend(relation_ids1071) - result1075 = _t1897 - self.record_span(span_start1074, "Algorithm") - return result1075 + _t1901 = logic_pb2.Algorithm(body=script1074, attrs=(attrs1075 if attrs1075 is not None else [])) + getattr(_t1901, 'global').extend(relation_ids1073) + result1077 = _t1901 + self.record_span(span_start1076, "Algorithm") + return result1077 def parse_script(self) -> logic_pb2.Script: - span_start1080 = self.span_start() + span_start1082 = self.span_start() self.consume_literal("(") self.consume_literal("script") - xs1076 = [] - cond1077 = self.match_lookahead_literal("(", 0) - while cond1077: - _t1898 = self.parse_construct() - item1078 = _t1898 - xs1076.append(item1078) - cond1077 = self.match_lookahead_literal("(", 0) - constructs1079 = xs1076 + xs1078 = [] + cond1079 = self.match_lookahead_literal("(", 0) + while cond1079: + _t1902 = self.parse_construct() + item1080 = _t1902 + xs1078.append(item1080) + cond1079 = self.match_lookahead_literal("(", 0) + constructs1081 = xs1078 self.consume_literal(")") - _t1899 = logic_pb2.Script(constructs=constructs1079) - result1081 = _t1899 - self.record_span(span_start1080, "Script") - return result1081 + _t1903 = logic_pb2.Script(constructs=constructs1081) + result1083 = _t1903 + self.record_span(span_start1082, "Script") + return result1083 def parse_construct(self) -> logic_pb2.Construct: - span_start1085 = self.span_start() + span_start1087 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1901 = 1 + _t1905 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1902 = 1 + _t1906 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1903 = 1 + _t1907 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1904 = 0 + _t1908 = 0 else: if self.match_lookahead_literal("break", 1): - _t1905 = 1 + _t1909 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1906 = 1 + _t1910 = 1 else: - _t1906 = -1 - _t1905 = _t1906 - _t1904 = _t1905 - _t1903 = _t1904 - _t1902 = _t1903 - _t1901 = _t1902 - _t1900 = _t1901 + _t1910 = -1 + _t1909 = _t1910 + _t1908 = _t1909 + _t1907 = _t1908 + _t1906 = _t1907 + _t1905 = _t1906 + _t1904 = _t1905 else: - _t1900 = -1 - prediction1082 = _t1900 - if prediction1082 == 1: - _t1908 = self.parse_instruction() - instruction1084 = _t1908 - _t1909 = logic_pb2.Construct(instruction=instruction1084) - _t1907 = _t1909 + _t1904 = -1 + prediction1084 = _t1904 + if prediction1084 == 1: + _t1912 = self.parse_instruction() + instruction1086 = _t1912 + _t1913 = logic_pb2.Construct(instruction=instruction1086) + _t1911 = _t1913 else: - if prediction1082 == 0: - _t1911 = self.parse_loop() - loop1083 = _t1911 - _t1912 = logic_pb2.Construct(loop=loop1083) - _t1910 = _t1912 + if prediction1084 == 0: + _t1915 = self.parse_loop() + loop1085 = _t1915 + _t1916 = logic_pb2.Construct(loop=loop1085) + _t1914 = _t1916 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1907 = _t1910 - result1086 = _t1907 - self.record_span(span_start1085, "Construct") - return result1086 + _t1911 = _t1914 + result1088 = _t1911 + self.record_span(span_start1087, "Construct") + return result1088 def parse_loop(self) -> logic_pb2.Loop: - span_start1090 = self.span_start() + span_start1092 = self.span_start() self.consume_literal("(") self.consume_literal("loop") - _t1913 = self.parse_init() - init1087 = _t1913 - _t1914 = self.parse_script() - script1088 = _t1914 + _t1917 = self.parse_init() + init1089 = _t1917 + _t1918 = self.parse_script() + script1090 = _t1918 if self.match_lookahead_literal("(", 0): - _t1916 = self.parse_attrs() - _t1915 = _t1916 + _t1920 = self.parse_attrs() + _t1919 = _t1920 else: - _t1915 = None - attrs1089 = _t1915 + _t1919 = None + attrs1091 = _t1919 self.consume_literal(")") - _t1917 = logic_pb2.Loop(init=init1087, body=script1088, attrs=(attrs1089 if attrs1089 is not None else [])) - result1091 = _t1917 - self.record_span(span_start1090, "Loop") - return result1091 + _t1921 = logic_pb2.Loop(init=init1089, body=script1090, attrs=(attrs1091 if attrs1091 is not None else [])) + result1093 = _t1921 + self.record_span(span_start1092, "Loop") + return result1093 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs1092 = [] - cond1093 = self.match_lookahead_literal("(", 0) - while cond1093: - _t1918 = self.parse_instruction() - item1094 = _t1918 - xs1092.append(item1094) - cond1093 = self.match_lookahead_literal("(", 0) - instructions1095 = xs1092 + xs1094 = [] + cond1095 = self.match_lookahead_literal("(", 0) + while cond1095: + _t1922 = self.parse_instruction() + item1096 = _t1922 + xs1094.append(item1096) + cond1095 = self.match_lookahead_literal("(", 0) + instructions1097 = xs1094 self.consume_literal(")") - return instructions1095 + return instructions1097 def parse_instruction(self) -> logic_pb2.Instruction: - span_start1102 = self.span_start() + span_start1104 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1920 = 1 + _t1924 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1921 = 4 + _t1925 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1922 = 3 + _t1926 = 3 else: if self.match_lookahead_literal("break", 1): - _t1923 = 2 + _t1927 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1924 = 0 + _t1928 = 0 else: - _t1924 = -1 - _t1923 = _t1924 - _t1922 = _t1923 - _t1921 = _t1922 - _t1920 = _t1921 - _t1919 = _t1920 + _t1928 = -1 + _t1927 = _t1928 + _t1926 = _t1927 + _t1925 = _t1926 + _t1924 = _t1925 + _t1923 = _t1924 else: - _t1919 = -1 - prediction1096 = _t1919 - if prediction1096 == 4: - _t1926 = self.parse_monus_def() - monus_def1101 = _t1926 - _t1927 = logic_pb2.Instruction(monus_def=monus_def1101) - _t1925 = _t1927 + _t1923 = -1 + prediction1098 = _t1923 + if prediction1098 == 4: + _t1930 = self.parse_monus_def() + monus_def1103 = _t1930 + _t1931 = logic_pb2.Instruction(monus_def=monus_def1103) + _t1929 = _t1931 else: - if prediction1096 == 3: - _t1929 = self.parse_monoid_def() - monoid_def1100 = _t1929 - _t1930 = logic_pb2.Instruction(monoid_def=monoid_def1100) - _t1928 = _t1930 + if prediction1098 == 3: + _t1933 = self.parse_monoid_def() + monoid_def1102 = _t1933 + _t1934 = logic_pb2.Instruction(monoid_def=monoid_def1102) + _t1932 = _t1934 else: - if prediction1096 == 2: - _t1932 = self.parse_break() - break1099 = _t1932 - _t1933 = logic_pb2.Instruction() - getattr(_t1933, 'break').CopyFrom(break1099) - _t1931 = _t1933 + if prediction1098 == 2: + _t1936 = self.parse_break() + break1101 = _t1936 + _t1937 = logic_pb2.Instruction() + getattr(_t1937, 'break').CopyFrom(break1101) + _t1935 = _t1937 else: - if prediction1096 == 1: - _t1935 = self.parse_upsert() - upsert1098 = _t1935 - _t1936 = logic_pb2.Instruction(upsert=upsert1098) - _t1934 = _t1936 + if prediction1098 == 1: + _t1939 = self.parse_upsert() + upsert1100 = _t1939 + _t1940 = logic_pb2.Instruction(upsert=upsert1100) + _t1938 = _t1940 else: - if prediction1096 == 0: - _t1938 = self.parse_assign() - assign1097 = _t1938 - _t1939 = logic_pb2.Instruction(assign=assign1097) - _t1937 = _t1939 + if prediction1098 == 0: + _t1942 = self.parse_assign() + assign1099 = _t1942 + _t1943 = logic_pb2.Instruction(assign=assign1099) + _t1941 = _t1943 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1934 = _t1937 - _t1931 = _t1934 - _t1928 = _t1931 - _t1925 = _t1928 - result1103 = _t1925 - self.record_span(span_start1102, "Instruction") - return result1103 + _t1938 = _t1941 + _t1935 = _t1938 + _t1932 = _t1935 + _t1929 = _t1932 + result1105 = _t1929 + self.record_span(span_start1104, "Instruction") + return result1105 def parse_assign(self) -> logic_pb2.Assign: - span_start1107 = self.span_start() + span_start1109 = self.span_start() self.consume_literal("(") self.consume_literal("assign") - _t1940 = self.parse_relation_id() - relation_id1104 = _t1940 - _t1941 = self.parse_abstraction() - abstraction1105 = _t1941 + _t1944 = self.parse_relation_id() + relation_id1106 = _t1944 + _t1945 = self.parse_abstraction() + abstraction1107 = _t1945 if self.match_lookahead_literal("(", 0): - _t1943 = self.parse_attrs() - _t1942 = _t1943 + _t1947 = self.parse_attrs() + _t1946 = _t1947 else: - _t1942 = None - attrs1106 = _t1942 + _t1946 = None + attrs1108 = _t1946 self.consume_literal(")") - _t1944 = logic_pb2.Assign(name=relation_id1104, body=abstraction1105, attrs=(attrs1106 if attrs1106 is not None else [])) - result1108 = _t1944 - self.record_span(span_start1107, "Assign") - return result1108 + _t1948 = logic_pb2.Assign(name=relation_id1106, body=abstraction1107, attrs=(attrs1108 if attrs1108 is not None else [])) + result1110 = _t1948 + self.record_span(span_start1109, "Assign") + return result1110 def parse_upsert(self) -> logic_pb2.Upsert: - span_start1112 = self.span_start() + span_start1114 = self.span_start() self.consume_literal("(") self.consume_literal("upsert") - _t1945 = self.parse_relation_id() - relation_id1109 = _t1945 - _t1946 = self.parse_abstraction_with_arity() - abstraction_with_arity1110 = _t1946 + _t1949 = self.parse_relation_id() + relation_id1111 = _t1949 + _t1950 = self.parse_abstraction_with_arity() + abstraction_with_arity1112 = _t1950 if self.match_lookahead_literal("(", 0): - _t1948 = self.parse_attrs() - _t1947 = _t1948 + _t1952 = self.parse_attrs() + _t1951 = _t1952 else: - _t1947 = None - attrs1111 = _t1947 + _t1951 = None + attrs1113 = _t1951 self.consume_literal(")") - _t1949 = logic_pb2.Upsert(name=relation_id1109, body=abstraction_with_arity1110[0], attrs=(attrs1111 if attrs1111 is not None else []), value_arity=abstraction_with_arity1110[1]) - result1113 = _t1949 - self.record_span(span_start1112, "Upsert") - return result1113 + _t1953 = logic_pb2.Upsert(name=relation_id1111, body=abstraction_with_arity1112[0], attrs=(attrs1113 if attrs1113 is not None else []), value_arity=abstraction_with_arity1112[1]) + result1115 = _t1953 + self.record_span(span_start1114, "Upsert") + return result1115 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1950 = self.parse_bindings() - bindings1114 = _t1950 - _t1951 = self.parse_formula() - formula1115 = _t1951 + _t1954 = self.parse_bindings() + bindings1116 = _t1954 + _t1955 = self.parse_formula() + formula1117 = _t1955 self.consume_literal(")") - _t1952 = logic_pb2.Abstraction(vars=(list(bindings1114[0]) + list(bindings1114[1] if bindings1114[1] is not None else [])), value=formula1115) - return (_t1952, len(bindings1114[1]),) + _t1956 = logic_pb2.Abstraction(vars=(list(bindings1116[0]) + list(bindings1116[1] if bindings1116[1] is not None else [])), value=formula1117) + return (_t1956, len(bindings1116[1]),) def parse_break(self) -> logic_pb2.Break: - span_start1119 = self.span_start() + span_start1121 = self.span_start() self.consume_literal("(") self.consume_literal("break") - _t1953 = self.parse_relation_id() - relation_id1116 = _t1953 - _t1954 = self.parse_abstraction() - abstraction1117 = _t1954 + _t1957 = self.parse_relation_id() + relation_id1118 = _t1957 + _t1958 = self.parse_abstraction() + abstraction1119 = _t1958 if self.match_lookahead_literal("(", 0): - _t1956 = self.parse_attrs() - _t1955 = _t1956 + _t1960 = self.parse_attrs() + _t1959 = _t1960 else: - _t1955 = None - attrs1118 = _t1955 + _t1959 = None + attrs1120 = _t1959 self.consume_literal(")") - _t1957 = logic_pb2.Break(name=relation_id1116, body=abstraction1117, attrs=(attrs1118 if attrs1118 is not None else [])) - result1120 = _t1957 - self.record_span(span_start1119, "Break") - return result1120 + _t1961 = logic_pb2.Break(name=relation_id1118, body=abstraction1119, attrs=(attrs1120 if attrs1120 is not None else [])) + result1122 = _t1961 + self.record_span(span_start1121, "Break") + return result1122 def parse_monoid_def(self) -> logic_pb2.MonoidDef: - span_start1125 = self.span_start() + span_start1127 = self.span_start() self.consume_literal("(") self.consume_literal("monoid") - _t1958 = self.parse_monoid() - monoid1121 = _t1958 - _t1959 = self.parse_relation_id() - relation_id1122 = _t1959 - _t1960 = self.parse_abstraction_with_arity() - abstraction_with_arity1123 = _t1960 + _t1962 = self.parse_monoid() + monoid1123 = _t1962 + _t1963 = self.parse_relation_id() + relation_id1124 = _t1963 + _t1964 = self.parse_abstraction_with_arity() + abstraction_with_arity1125 = _t1964 if self.match_lookahead_literal("(", 0): - _t1962 = self.parse_attrs() - _t1961 = _t1962 + _t1966 = self.parse_attrs() + _t1965 = _t1966 else: - _t1961 = None - attrs1124 = _t1961 + _t1965 = None + attrs1126 = _t1965 self.consume_literal(")") - _t1963 = logic_pb2.MonoidDef(monoid=monoid1121, name=relation_id1122, body=abstraction_with_arity1123[0], attrs=(attrs1124 if attrs1124 is not None else []), value_arity=abstraction_with_arity1123[1]) - result1126 = _t1963 - self.record_span(span_start1125, "MonoidDef") - return result1126 + _t1967 = logic_pb2.MonoidDef(monoid=monoid1123, name=relation_id1124, body=abstraction_with_arity1125[0], attrs=(attrs1126 if attrs1126 is not None else []), value_arity=abstraction_with_arity1125[1]) + result1128 = _t1967 + self.record_span(span_start1127, "MonoidDef") + return result1128 def parse_monoid(self) -> logic_pb2.Monoid: - span_start1132 = self.span_start() + span_start1134 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1965 = 3 + _t1969 = 3 else: if self.match_lookahead_literal("or", 1): - _t1966 = 0 + _t1970 = 0 else: if self.match_lookahead_literal("min", 1): - _t1967 = 1 + _t1971 = 1 else: if self.match_lookahead_literal("max", 1): - _t1968 = 2 + _t1972 = 2 else: - _t1968 = -1 - _t1967 = _t1968 - _t1966 = _t1967 - _t1965 = _t1966 - _t1964 = _t1965 + _t1972 = -1 + _t1971 = _t1972 + _t1970 = _t1971 + _t1969 = _t1970 + _t1968 = _t1969 else: - _t1964 = -1 - prediction1127 = _t1964 - if prediction1127 == 3: - _t1970 = self.parse_sum_monoid() - sum_monoid1131 = _t1970 - _t1971 = logic_pb2.Monoid(sum_monoid=sum_monoid1131) - _t1969 = _t1971 + _t1968 = -1 + prediction1129 = _t1968 + if prediction1129 == 3: + _t1974 = self.parse_sum_monoid() + sum_monoid1133 = _t1974 + _t1975 = logic_pb2.Monoid(sum_monoid=sum_monoid1133) + _t1973 = _t1975 else: - if prediction1127 == 2: - _t1973 = self.parse_max_monoid() - max_monoid1130 = _t1973 - _t1974 = logic_pb2.Monoid(max_monoid=max_monoid1130) - _t1972 = _t1974 + if prediction1129 == 2: + _t1977 = self.parse_max_monoid() + max_monoid1132 = _t1977 + _t1978 = logic_pb2.Monoid(max_monoid=max_monoid1132) + _t1976 = _t1978 else: - if prediction1127 == 1: - _t1976 = self.parse_min_monoid() - min_monoid1129 = _t1976 - _t1977 = logic_pb2.Monoid(min_monoid=min_monoid1129) - _t1975 = _t1977 + if prediction1129 == 1: + _t1980 = self.parse_min_monoid() + min_monoid1131 = _t1980 + _t1981 = logic_pb2.Monoid(min_monoid=min_monoid1131) + _t1979 = _t1981 else: - if prediction1127 == 0: - _t1979 = self.parse_or_monoid() - or_monoid1128 = _t1979 - _t1980 = logic_pb2.Monoid(or_monoid=or_monoid1128) - _t1978 = _t1980 + if prediction1129 == 0: + _t1983 = self.parse_or_monoid() + or_monoid1130 = _t1983 + _t1984 = logic_pb2.Monoid(or_monoid=or_monoid1130) + _t1982 = _t1984 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1975 = _t1978 - _t1972 = _t1975 - _t1969 = _t1972 - result1133 = _t1969 - self.record_span(span_start1132, "Monoid") - return result1133 + _t1979 = _t1982 + _t1976 = _t1979 + _t1973 = _t1976 + result1135 = _t1973 + self.record_span(span_start1134, "Monoid") + return result1135 def parse_or_monoid(self) -> logic_pb2.OrMonoid: - span_start1134 = self.span_start() + span_start1136 = self.span_start() self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1981 = logic_pb2.OrMonoid() - result1135 = _t1981 - self.record_span(span_start1134, "OrMonoid") - return result1135 + _t1985 = logic_pb2.OrMonoid() + result1137 = _t1985 + self.record_span(span_start1136, "OrMonoid") + return result1137 def parse_min_monoid(self) -> logic_pb2.MinMonoid: - span_start1137 = self.span_start() + span_start1139 = self.span_start() self.consume_literal("(") self.consume_literal("min") - _t1982 = self.parse_type() - type1136 = _t1982 + _t1986 = self.parse_type() + type1138 = _t1986 self.consume_literal(")") - _t1983 = logic_pb2.MinMonoid(type=type1136) - result1138 = _t1983 - self.record_span(span_start1137, "MinMonoid") - return result1138 + _t1987 = logic_pb2.MinMonoid(type=type1138) + result1140 = _t1987 + self.record_span(span_start1139, "MinMonoid") + return result1140 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: - span_start1140 = self.span_start() + span_start1142 = self.span_start() self.consume_literal("(") self.consume_literal("max") - _t1984 = self.parse_type() - type1139 = _t1984 + _t1988 = self.parse_type() + type1141 = _t1988 self.consume_literal(")") - _t1985 = logic_pb2.MaxMonoid(type=type1139) - result1141 = _t1985 - self.record_span(span_start1140, "MaxMonoid") - return result1141 + _t1989 = logic_pb2.MaxMonoid(type=type1141) + result1143 = _t1989 + self.record_span(span_start1142, "MaxMonoid") + return result1143 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: - span_start1143 = self.span_start() + span_start1145 = self.span_start() self.consume_literal("(") self.consume_literal("sum") - _t1986 = self.parse_type() - type1142 = _t1986 + _t1990 = self.parse_type() + type1144 = _t1990 self.consume_literal(")") - _t1987 = logic_pb2.SumMonoid(type=type1142) - result1144 = _t1987 - self.record_span(span_start1143, "SumMonoid") - return result1144 + _t1991 = logic_pb2.SumMonoid(type=type1144) + result1146 = _t1991 + self.record_span(span_start1145, "SumMonoid") + return result1146 def parse_monus_def(self) -> logic_pb2.MonusDef: - span_start1149 = self.span_start() + span_start1151 = self.span_start() self.consume_literal("(") self.consume_literal("monus") - _t1988 = self.parse_monoid() - monoid1145 = _t1988 - _t1989 = self.parse_relation_id() - relation_id1146 = _t1989 - _t1990 = self.parse_abstraction_with_arity() - abstraction_with_arity1147 = _t1990 + _t1992 = self.parse_monoid() + monoid1147 = _t1992 + _t1993 = self.parse_relation_id() + relation_id1148 = _t1993 + _t1994 = self.parse_abstraction_with_arity() + abstraction_with_arity1149 = _t1994 if self.match_lookahead_literal("(", 0): - _t1992 = self.parse_attrs() - _t1991 = _t1992 + _t1996 = self.parse_attrs() + _t1995 = _t1996 else: - _t1991 = None - attrs1148 = _t1991 + _t1995 = None + attrs1150 = _t1995 self.consume_literal(")") - _t1993 = logic_pb2.MonusDef(monoid=monoid1145, name=relation_id1146, body=abstraction_with_arity1147[0], attrs=(attrs1148 if attrs1148 is not None else []), value_arity=abstraction_with_arity1147[1]) - result1150 = _t1993 - self.record_span(span_start1149, "MonusDef") - return result1150 + _t1997 = logic_pb2.MonusDef(monoid=monoid1147, name=relation_id1148, body=abstraction_with_arity1149[0], attrs=(attrs1150 if attrs1150 is not None else []), value_arity=abstraction_with_arity1149[1]) + result1152 = _t1997 + self.record_span(span_start1151, "MonusDef") + return result1152 def parse_constraint(self) -> logic_pb2.Constraint: - span_start1155 = self.span_start() + span_start1157 = self.span_start() self.consume_literal("(") self.consume_literal("functional_dependency") - _t1994 = self.parse_relation_id() - relation_id1151 = _t1994 - _t1995 = self.parse_abstraction() - abstraction1152 = _t1995 - _t1996 = self.parse_functional_dependency_keys() - functional_dependency_keys1153 = _t1996 - _t1997 = self.parse_functional_dependency_values() - functional_dependency_values1154 = _t1997 + _t1998 = self.parse_relation_id() + relation_id1153 = _t1998 + _t1999 = self.parse_abstraction() + abstraction1154 = _t1999 + _t2000 = self.parse_functional_dependency_keys() + functional_dependency_keys1155 = _t2000 + _t2001 = self.parse_functional_dependency_values() + functional_dependency_values1156 = _t2001 self.consume_literal(")") - _t1998 = logic_pb2.FunctionalDependency(guard=abstraction1152, keys=functional_dependency_keys1153, values=functional_dependency_values1154) - _t1999 = logic_pb2.Constraint(name=relation_id1151, functional_dependency=_t1998) - result1156 = _t1999 - self.record_span(span_start1155, "Constraint") - return result1156 + _t2002 = logic_pb2.FunctionalDependency(guard=abstraction1154, keys=functional_dependency_keys1155, values=functional_dependency_values1156) + _t2003 = logic_pb2.Constraint(name=relation_id1153, functional_dependency=_t2002) + result1158 = _t2003 + self.record_span(span_start1157, "Constraint") + return result1158 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs1157 = [] - cond1158 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1158: - _t2000 = self.parse_var() - item1159 = _t2000 - xs1157.append(item1159) - cond1158 = self.match_lookahead_terminal("SYMBOL", 0) - vars1160 = xs1157 + xs1159 = [] + cond1160 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1160: + _t2004 = self.parse_var() + item1161 = _t2004 + xs1159.append(item1161) + cond1160 = self.match_lookahead_terminal("SYMBOL", 0) + vars1162 = xs1159 self.consume_literal(")") - return vars1160 + return vars1162 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - xs1161 = [] - cond1162 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1162: - _t2001 = self.parse_var() - item1163 = _t2001 - xs1161.append(item1163) - cond1162 = self.match_lookahead_terminal("SYMBOL", 0) - vars1164 = xs1161 + xs1163 = [] + cond1164 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1164: + _t2005 = self.parse_var() + item1165 = _t2005 + xs1163.append(item1165) + cond1164 = self.match_lookahead_terminal("SYMBOL", 0) + vars1166 = xs1163 self.consume_literal(")") - return vars1164 + return vars1166 def parse_data(self) -> logic_pb2.Data: - span_start1170 = self.span_start() + span_start1172 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t2003 = 3 + _t2007 = 3 else: if self.match_lookahead_literal("edb", 1): - _t2004 = 0 + _t2008 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t2005 = 2 + _t2009 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t2006 = 1 + _t2010 = 1 else: - _t2006 = -1 - _t2005 = _t2006 - _t2004 = _t2005 - _t2003 = _t2004 - _t2002 = _t2003 + _t2010 = -1 + _t2009 = _t2010 + _t2008 = _t2009 + _t2007 = _t2008 + _t2006 = _t2007 else: - _t2002 = -1 - prediction1165 = _t2002 - if prediction1165 == 3: - _t2008 = self.parse_iceberg_data() - iceberg_data1169 = _t2008 - _t2009 = logic_pb2.Data(iceberg_data=iceberg_data1169) - _t2007 = _t2009 + _t2006 = -1 + prediction1167 = _t2006 + if prediction1167 == 3: + _t2012 = self.parse_iceberg_data() + iceberg_data1171 = _t2012 + _t2013 = logic_pb2.Data(iceberg_data=iceberg_data1171) + _t2011 = _t2013 else: - if prediction1165 == 2: - _t2011 = self.parse_csv_data() - csv_data1168 = _t2011 - _t2012 = logic_pb2.Data(csv_data=csv_data1168) - _t2010 = _t2012 + if prediction1167 == 2: + _t2015 = self.parse_csv_data() + csv_data1170 = _t2015 + _t2016 = logic_pb2.Data(csv_data=csv_data1170) + _t2014 = _t2016 else: - if prediction1165 == 1: - _t2014 = self.parse_betree_relation() - betree_relation1167 = _t2014 - _t2015 = logic_pb2.Data(betree_relation=betree_relation1167) - _t2013 = _t2015 + if prediction1167 == 1: + _t2018 = self.parse_betree_relation() + betree_relation1169 = _t2018 + _t2019 = logic_pb2.Data(betree_relation=betree_relation1169) + _t2017 = _t2019 else: - if prediction1165 == 0: - _t2017 = self.parse_edb() - edb1166 = _t2017 - _t2018 = logic_pb2.Data(edb=edb1166) - _t2016 = _t2018 + if prediction1167 == 0: + _t2021 = self.parse_edb() + edb1168 = _t2021 + _t2022 = logic_pb2.Data(edb=edb1168) + _t2020 = _t2022 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2013 = _t2016 - _t2010 = _t2013 - _t2007 = _t2010 - result1171 = _t2007 - self.record_span(span_start1170, "Data") - return result1171 + _t2017 = _t2020 + _t2014 = _t2017 + _t2011 = _t2014 + result1173 = _t2011 + self.record_span(span_start1172, "Data") + return result1173 def parse_edb(self) -> logic_pb2.EDB: - span_start1175 = self.span_start() + span_start1177 = self.span_start() self.consume_literal("(") self.consume_literal("edb") - _t2019 = self.parse_relation_id() - relation_id1172 = _t2019 - _t2020 = self.parse_edb_path() - edb_path1173 = _t2020 - _t2021 = self.parse_edb_types() - edb_types1174 = _t2021 + _t2023 = self.parse_relation_id() + relation_id1174 = _t2023 + _t2024 = self.parse_edb_path() + edb_path1175 = _t2024 + _t2025 = self.parse_edb_types() + edb_types1176 = _t2025 self.consume_literal(")") - _t2022 = logic_pb2.EDB(target_id=relation_id1172, path=edb_path1173, types=edb_types1174) - result1176 = _t2022 - self.record_span(span_start1175, "EDB") - return result1176 + _t2026 = logic_pb2.EDB(target_id=relation_id1174, path=edb_path1175, types=edb_types1176) + result1178 = _t2026 + self.record_span(span_start1177, "EDB") + return result1178 def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs1177 = [] - cond1178 = self.match_lookahead_terminal("STRING", 0) - while cond1178: - item1179 = self.consume_terminal("STRING") - xs1177.append(item1179) - cond1178 = self.match_lookahead_terminal("STRING", 0) - strings1180 = xs1177 + xs1179 = [] + cond1180 = self.match_lookahead_terminal("STRING", 0) + while cond1180: + item1181 = self.consume_terminal("STRING") + xs1179.append(item1181) + cond1180 = self.match_lookahead_terminal("STRING", 0) + strings1182 = xs1179 self.consume_literal("]") - return strings1180 + return strings1182 def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs1181 = [] - cond1182 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1182: - _t2023 = self.parse_type() - item1183 = _t2023 - xs1181.append(item1183) - cond1182 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1184 = xs1181 + xs1183 = [] + cond1184 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1184: + _t2027 = self.parse_type() + item1185 = _t2027 + xs1183.append(item1185) + cond1184 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1186 = xs1183 self.consume_literal("]") - return types1184 + return types1186 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: - span_start1187 = self.span_start() + span_start1189 = self.span_start() self.consume_literal("(") self.consume_literal("betree_relation") - _t2024 = self.parse_relation_id() - relation_id1185 = _t2024 - _t2025 = self.parse_betree_info() - betree_info1186 = _t2025 + _t2028 = self.parse_relation_id() + relation_id1187 = _t2028 + _t2029 = self.parse_betree_info() + betree_info1188 = _t2029 self.consume_literal(")") - _t2026 = logic_pb2.BeTreeRelation(name=relation_id1185, relation_info=betree_info1186) - result1188 = _t2026 - self.record_span(span_start1187, "BeTreeRelation") - return result1188 + _t2030 = logic_pb2.BeTreeRelation(name=relation_id1187, relation_info=betree_info1188) + result1190 = _t2030 + self.record_span(span_start1189, "BeTreeRelation") + return result1190 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1192 = self.span_start() + span_start1194 = self.span_start() self.consume_literal("(") self.consume_literal("betree_info") - _t2027 = self.parse_betree_info_key_types() - betree_info_key_types1189 = _t2027 - _t2028 = self.parse_betree_info_value_types() - betree_info_value_types1190 = _t2028 - _t2029 = self.parse_config_dict() - config_dict1191 = _t2029 + _t2031 = self.parse_betree_info_key_types() + betree_info_key_types1191 = _t2031 + _t2032 = self.parse_betree_info_value_types() + betree_info_value_types1192 = _t2032 + _t2033 = self.parse_config_dict() + config_dict1193 = _t2033 self.consume_literal(")") - _t2030 = self.construct_betree_info(betree_info_key_types1189, betree_info_value_types1190, config_dict1191) - result1193 = _t2030 - self.record_span(span_start1192, "BeTreeInfo") - return result1193 + _t2034 = self.construct_betree_info(betree_info_key_types1191, betree_info_value_types1192, config_dict1193) + result1195 = _t2034 + self.record_span(span_start1194, "BeTreeInfo") + return result1195 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs1194 = [] - cond1195 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1195: - _t2031 = self.parse_type() - item1196 = _t2031 - xs1194.append(item1196) - cond1195 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1197 = xs1194 + xs1196 = [] + cond1197 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1197: + _t2035 = self.parse_type() + item1198 = _t2035 + xs1196.append(item1198) + cond1197 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1199 = xs1196 self.consume_literal(")") - return types1197 + return types1199 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - xs1198 = [] - cond1199 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1199: - _t2032 = self.parse_type() - item1200 = _t2032 - xs1198.append(item1200) - cond1199 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1201 = xs1198 + xs1200 = [] + cond1201 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1201: + _t2036 = self.parse_type() + item1202 = _t2036 + xs1200.append(item1202) + cond1201 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1203 = xs1200 self.consume_literal(")") - return types1201 + return types1203 def parse_csv_data(self) -> logic_pb2.CSVData: - span_start1207 = self.span_start() + span_start1209 = self.span_start() self.consume_literal("(") self.consume_literal("csv_data") - _t2033 = self.parse_csvlocator() - csvlocator1202 = _t2033 - _t2034 = self.parse_csv_config() - csv_config1203 = _t2034 + _t2037 = self.parse_csvlocator() + csvlocator1204 = _t2037 + _t2038 = self.parse_csv_config() + csv_config1205 = _t2038 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("columns", 1)): - _t2036 = self.parse_gnf_columns() - _t2035 = _t2036 + _t2040 = self.parse_gnf_columns() + _t2039 = _t2040 else: - _t2035 = None - gnf_columns1204 = _t2035 + _t2039 = None + gnf_columns1206 = _t2039 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("relations", 1)): - _t2038 = self.parse_target_relations() - _t2037 = _t2038 + _t2042 = self.parse_target_relations() + _t2041 = _t2042 else: - _t2037 = None - target_relations1205 = _t2037 - _t2039 = self.parse_csv_asof() - csv_asof1206 = _t2039 + _t2041 = None + target_relations1207 = _t2041 + _t2043 = self.parse_csv_asof() + csv_asof1208 = _t2043 self.consume_literal(")") - _t2040 = self.construct_csv_data(csvlocator1202, csv_config1203, gnf_columns1204, target_relations1205, csv_asof1206) - result1208 = _t2040 - self.record_span(span_start1207, "CSVData") - return result1208 + _t2044 = self.construct_csv_data(csvlocator1204, csv_config1205, gnf_columns1206, target_relations1207, csv_asof1208) + result1210 = _t2044 + self.record_span(span_start1209, "CSVData") + return result1210 def parse_csvlocator(self) -> logic_pb2.CSVLocator: - span_start1211 = self.span_start() + span_start1213 = self.span_start() self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t2042 = self.parse_csv_locator_paths() - _t2041 = _t2042 + _t2046 = self.parse_csv_locator_paths() + _t2045 = _t2046 else: - _t2041 = None - csv_locator_paths1209 = _t2041 + _t2045 = None + csv_locator_paths1211 = _t2045 if self.match_lookahead_literal("(", 0): - _t2044 = self.parse_csv_locator_inline_data() - _t2043 = _t2044 + _t2048 = self.parse_csv_locator_inline_data() + _t2047 = _t2048 else: - _t2043 = None - csv_locator_inline_data1210 = _t2043 + _t2047 = None + csv_locator_inline_data1212 = _t2047 self.consume_literal(")") - _t2045 = logic_pb2.CSVLocator(paths=(csv_locator_paths1209 if csv_locator_paths1209 is not None else []), inline_data=(csv_locator_inline_data1210 if csv_locator_inline_data1210 is not None else "").encode()) - result1212 = _t2045 - self.record_span(span_start1211, "CSVLocator") - return result1212 + _t2049 = logic_pb2.CSVLocator(paths=(csv_locator_paths1211 if csv_locator_paths1211 is not None else []), inline_data=(csv_locator_inline_data1212 if csv_locator_inline_data1212 is not None else "").encode()) + result1214 = _t2049 + self.record_span(span_start1213, "CSVLocator") + return result1214 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs1213 = [] - cond1214 = self.match_lookahead_terminal("STRING", 0) - while cond1214: - item1215 = self.consume_terminal("STRING") - xs1213.append(item1215) - cond1214 = self.match_lookahead_terminal("STRING", 0) - strings1216 = xs1213 + xs1215 = [] + cond1216 = self.match_lookahead_terminal("STRING", 0) + while cond1216: + item1217 = self.consume_terminal("STRING") + xs1215.append(item1217) + cond1216 = self.match_lookahead_terminal("STRING", 0) + strings1218 = xs1215 self.consume_literal(")") - return strings1216 + return strings1218 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - formatted_string1217 = self.consume_terminal("STRING") + formatted_string1219 = self.consume_terminal("STRING") self.consume_literal(")") - return formatted_string1217 + return formatted_string1219 def parse_csv_config(self) -> logic_pb2.CSVConfig: - span_start1220 = self.span_start() + span_start1222 = self.span_start() self.consume_literal("(") self.consume_literal("csv_config") - _t2046 = self.parse_config_dict() - config_dict1218 = _t2046 + _t2050 = self.parse_config_dict() + config_dict1220 = _t2050 if self.match_lookahead_literal("(", 0): - _t2048 = self.parse__storage_integration() - _t2047 = _t2048 + _t2052 = self.parse__storage_integration() + _t2051 = _t2052 else: - _t2047 = None - _storage_integration1219 = _t2047 + _t2051 = None + _storage_integration1221 = _t2051 self.consume_literal(")") - _t2049 = self.construct_csv_config(config_dict1218, _storage_integration1219) - result1221 = _t2049 - self.record_span(span_start1220, "CSVConfig") - return result1221 + _t2053 = self.construct_csv_config(config_dict1220, _storage_integration1221) + result1223 = _t2053 + self.record_span(span_start1222, "CSVConfig") + return result1223 def parse__storage_integration(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("(") self.consume_literal("storage_integration") - _t2050 = self.parse_config_dict() - config_dict1222 = _t2050 + _t2054 = self.parse_config_dict() + config_dict1224 = _t2054 self.consume_literal(")") - return config_dict1222 + return config_dict1224 def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1223 = [] - cond1224 = self.match_lookahead_literal("(", 0) - while cond1224: - _t2051 = self.parse_gnf_column() - item1225 = _t2051 - xs1223.append(item1225) - cond1224 = self.match_lookahead_literal("(", 0) - gnf_columns1226 = xs1223 + xs1225 = [] + cond1226 = self.match_lookahead_literal("(", 0) + while cond1226: + _t2055 = self.parse_gnf_column() + item1227 = _t2055 + xs1225.append(item1227) + cond1226 = self.match_lookahead_literal("(", 0) + gnf_columns1228 = xs1225 self.consume_literal(")") - return gnf_columns1226 + return gnf_columns1228 def parse_gnf_column(self) -> logic_pb2.GNFColumn: - span_start1233 = self.span_start() + span_start1235 = self.span_start() self.consume_literal("(") self.consume_literal("column") - _t2052 = self.parse_gnf_column_path() - gnf_column_path1227 = _t2052 + _t2056 = self.parse_gnf_column_path() + gnf_column_path1229 = _t2056 if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t2054 = self.parse_relation_id() - _t2053 = _t2054 + _t2058 = self.parse_relation_id() + _t2057 = _t2058 else: - _t2053 = None - relation_id1228 = _t2053 + _t2057 = None + relation_id1230 = _t2057 self.consume_literal("[") - xs1229 = [] - cond1230 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1230: - _t2055 = self.parse_type() - item1231 = _t2055 - xs1229.append(item1231) - cond1230 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1232 = xs1229 + xs1231 = [] + cond1232 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1232: + _t2059 = self.parse_type() + item1233 = _t2059 + xs1231.append(item1233) + cond1232 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1234 = xs1231 self.consume_literal("]") self.consume_literal(")") - _t2056 = logic_pb2.GNFColumn(column_path=gnf_column_path1227, target_id=relation_id1228, types=types1232) - result1234 = _t2056 - self.record_span(span_start1233, "GNFColumn") - return result1234 + _t2060 = logic_pb2.GNFColumn(column_path=gnf_column_path1229, target_id=relation_id1230, types=types1234) + result1236 = _t2060 + self.record_span(span_start1235, "GNFColumn") + return result1236 def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t2057 = 1 + _t2061 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t2058 = 0 + _t2062 = 0 else: - _t2058 = -1 - _t2057 = _t2058 - prediction1235 = _t2057 - if prediction1235 == 1: + _t2062 = -1 + _t2061 = _t2062 + prediction1237 = _t2061 + if prediction1237 == 1: self.consume_literal("[") - xs1237 = [] - cond1238 = self.match_lookahead_terminal("STRING", 0) - while cond1238: - item1239 = self.consume_terminal("STRING") - xs1237.append(item1239) - cond1238 = self.match_lookahead_terminal("STRING", 0) - strings1240 = xs1237 + xs1239 = [] + cond1240 = self.match_lookahead_terminal("STRING", 0) + while cond1240: + item1241 = self.consume_terminal("STRING") + xs1239.append(item1241) + cond1240 = self.match_lookahead_terminal("STRING", 0) + strings1242 = xs1239 self.consume_literal("]") - _t2059 = strings1240 + _t2063 = strings1242 else: - if prediction1235 == 0: - string1236 = self.consume_terminal("STRING") - _t2060 = [string1236] + if prediction1237 == 0: + string1238 = self.consume_terminal("STRING") + _t2064 = [string1238] else: raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2059 = _t2060 - return _t2059 + _t2063 = _t2064 + return _t2063 def parse_target_relations(self) -> logic_pb2.TargetRelations: - span_start1243 = self.span_start() + span_start1245 = self.span_start() self.consume_literal("(") self.consume_literal("relations") - _t2061 = self.parse_relation_keys() - relation_keys1241 = _t2061 - _t2062 = self.parse_relation_body() - relation_body1242 = _t2062 + _t2065 = self.parse_relation_keys() + relation_keys1243 = _t2065 + _t2066 = self.parse_relation_body() + relation_body1244 = _t2066 self.consume_literal(")") - _t2063 = self.construct_relations(relation_keys1241, relation_body1242) - result1244 = _t2063 - self.record_span(span_start1243, "TargetRelations") - return result1244 + _t2067 = self.construct_relations(relation_keys1243, relation_body1244) + result1246 = _t2067 + self.record_span(span_start1245, "TargetRelations") + return result1246 - def parse_relation_keys(self) -> Sequence[logic_pb2.NamedColumn]: - self.consume_literal("(") - self.consume_literal("keys") - xs1245 = [] - cond1246 = self.match_lookahead_literal("(", 0) - while cond1246: - _t2064 = self.parse_named_column() - item1247 = _t2064 - xs1245.append(item1247) - cond1246 = self.match_lookahead_literal("(", 0) - named_columns1248 = xs1245 - self.consume_literal(")") - return named_columns1248 + def parse_relation_keys(self) -> tuple[Sequence[logic_pb2.NamedColumn], bool]: + if self.match_lookahead_literal("(", 0): + if self.match_lookahead_literal("keys", 1): + if self.match_lookahead_literal(":", 2): + _t2070 = 1 + else: + if self.match_lookahead_literal(")", 2): + _t2071 = 0 + else: + if self.match_lookahead_literal("(", 2): + _t2072 = 0 + else: + _t2072 = -1 + _t2071 = _t2072 + _t2070 = _t2071 + _t2069 = _t2070 + else: + _t2069 = -1 + _t2068 = _t2069 + else: + _t2068 = -1 + prediction1247 = _t2068 + if prediction1247 == 1: + self.consume_literal("(") + self.consume_literal("keys") + self.consume_literal(":") + symbol1252 = self.consume_terminal("SYMBOL") + self.consume_literal(")") + _t2074 = self.construct_synthetic_keys(symbol1252) + _t2073 = _t2074 + else: + if prediction1247 == 0: + self.consume_literal("(") + self.consume_literal("keys") + xs1248 = [] + cond1249 = self.match_lookahead_literal("(", 0) + while cond1249: + _t2076 = self.parse_named_column() + item1250 = _t2076 + xs1248.append(item1250) + cond1249 = self.match_lookahead_literal("(", 0) + named_columns1251 = xs1248 + self.consume_literal(")") + _t2075 = (named_columns1251, False,) + else: + raise ParseError("Unexpected token in relation_keys" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") + _t2073 = _t2075 + return _t2073 def parse_named_column(self) -> logic_pb2.NamedColumn: - span_start1251 = self.span_start() + span_start1255 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1249 = self.consume_terminal("STRING") - _t2065 = self.parse_type() - type1250 = _t2065 + string1253 = self.consume_terminal("STRING") + _t2077 = self.parse_type() + type1254 = _t2077 self.consume_literal(")") - _t2066 = logic_pb2.NamedColumn(name=string1249, type=type1250) - result1252 = _t2066 - self.record_span(span_start1251, "NamedColumn") - return result1252 + _t2078 = logic_pb2.NamedColumn(name=string1253, type=type1254) + result1256 = _t2078 + self.record_span(span_start1255, "NamedColumn") + return result1256 def parse_relation_body(self) -> logic_pb2.TargetRelations: - span_start1257 = self.span_start() + span_start1261 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("relation", 1): - _t2068 = 0 + _t2080 = 0 else: if self.match_lookahead_literal("inserts", 1): - _t2069 = 1 + _t2081 = 1 else: - _t2069 = 0 - _t2068 = _t2069 - _t2067 = _t2068 + _t2081 = 0 + _t2080 = _t2081 + _t2079 = _t2080 else: - _t2067 = 0 - prediction1253 = _t2067 - if prediction1253 == 1: - _t2071 = self.parse_cdc_inserts() - cdc_inserts1255 = _t2071 - _t2072 = self.parse_cdc_deletes() - cdc_deletes1256 = _t2072 - _t2073 = self.construct_cdc_relations(cdc_inserts1255, cdc_deletes1256) - _t2070 = _t2073 + _t2079 = 0 + prediction1257 = _t2079 + if prediction1257 == 1: + _t2083 = self.parse_cdc_inserts() + cdc_inserts1259 = _t2083 + _t2084 = self.parse_cdc_deletes() + cdc_deletes1260 = _t2084 + _t2085 = self.construct_cdc_relations(cdc_inserts1259, cdc_deletes1260) + _t2082 = _t2085 else: - if prediction1253 == 0: - _t2075 = self.parse_non_cdc_relations() - non_cdc_relations1254 = _t2075 - _t2076 = self.construct_non_cdc_relations(non_cdc_relations1254) - _t2074 = _t2076 + if prediction1257 == 0: + _t2087 = self.parse_non_cdc_relations() + non_cdc_relations1258 = _t2087 + _t2088 = self.construct_non_cdc_relations(non_cdc_relations1258) + _t2086 = _t2088 else: raise ParseError("Unexpected token in relation_body" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2070 = _t2074 - result1258 = _t2070 - self.record_span(span_start1257, "TargetRelations") - return result1258 + _t2082 = _t2086 + result1262 = _t2082 + self.record_span(span_start1261, "TargetRelations") + return result1262 def parse_non_cdc_relations(self) -> Sequence[logic_pb2.TargetRelation]: - xs1259 = [] - cond1260 = self.match_lookahead_literal("(", 0) - while cond1260: - _t2077 = self.parse_target_relation() - item1261 = _t2077 - xs1259.append(item1261) - cond1260 = self.match_lookahead_literal("(", 0) - return xs1259 - - def parse_target_relation(self) -> logic_pb2.TargetRelation: - span_start1267 = self.span_start() - self.consume_literal("(") - self.consume_literal("relation") - _t2078 = self.parse_relation_id() - relation_id1262 = _t2078 xs1263 = [] cond1264 = self.match_lookahead_literal("(", 0) while cond1264: - _t2079 = self.parse_named_column() - item1265 = _t2079 + _t2089 = self.parse_target_relation() + item1265 = _t2089 xs1263.append(item1265) cond1264 = self.match_lookahead_literal("(", 0) - named_columns1266 = xs1263 - self.consume_literal(")") - _t2080 = logic_pb2.TargetRelation(target_id=relation_id1262, values=named_columns1266) - result1268 = _t2080 - self.record_span(span_start1267, "TargetRelation") - return result1268 + return xs1263 - def parse_cdc_inserts(self) -> Sequence[logic_pb2.TargetRelation]: + def parse_target_relation(self) -> logic_pb2.TargetRelation: + span_start1271 = self.span_start() self.consume_literal("(") - self.consume_literal("inserts") - xs1269 = [] - cond1270 = self.match_lookahead_literal("(", 0) - while cond1270: - _t2081 = self.parse_target_relation() - item1271 = _t2081 - xs1269.append(item1271) - cond1270 = self.match_lookahead_literal("(", 0) - target_relations1272 = xs1269 + self.consume_literal("relation") + _t2090 = self.parse_relation_id() + relation_id1266 = _t2090 + xs1267 = [] + cond1268 = self.match_lookahead_literal("(", 0) + while cond1268: + _t2091 = self.parse_named_column() + item1269 = _t2091 + xs1267.append(item1269) + cond1268 = self.match_lookahead_literal("(", 0) + named_columns1270 = xs1267 self.consume_literal(")") - return target_relations1272 + _t2092 = logic_pb2.TargetRelation(target_id=relation_id1266, values=named_columns1270) + result1272 = _t2092 + self.record_span(span_start1271, "TargetRelation") + return result1272 - def parse_cdc_deletes(self) -> Sequence[logic_pb2.TargetRelation]: + def parse_cdc_inserts(self) -> Sequence[logic_pb2.TargetRelation]: self.consume_literal("(") - self.consume_literal("deletes") + self.consume_literal("inserts") xs1273 = [] cond1274 = self.match_lookahead_literal("(", 0) while cond1274: - _t2082 = self.parse_target_relation() - item1275 = _t2082 + _t2093 = self.parse_target_relation() + item1275 = _t2093 xs1273.append(item1275) cond1274 = self.match_lookahead_literal("(", 0) target_relations1276 = xs1273 self.consume_literal(")") return target_relations1276 + def parse_cdc_deletes(self) -> Sequence[logic_pb2.TargetRelation]: + self.consume_literal("(") + self.consume_literal("deletes") + xs1277 = [] + cond1278 = self.match_lookahead_literal("(", 0) + while cond1278: + _t2094 = self.parse_target_relation() + item1279 = _t2094 + xs1277.append(item1279) + cond1278 = self.match_lookahead_literal("(", 0) + target_relations1280 = xs1277 + self.consume_literal(")") + return target_relations1280 + def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string1277 = self.consume_terminal("STRING") + string1281 = self.consume_terminal("STRING") self.consume_literal(")") - return string1277 + return string1281 def parse_iceberg_data(self) -> logic_pb2.IcebergData: - span_start1284 = self.span_start() + span_start1288 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_data") - _t2083 = self.parse_iceberg_locator() - iceberg_locator1278 = _t2083 - _t2084 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1279 = _t2084 - _t2085 = self.parse_gnf_columns() - gnf_columns1280 = _t2085 + _t2095 = self.parse_iceberg_locator() + iceberg_locator1282 = _t2095 + _t2096 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1283 = _t2096 + _t2097 = self.parse_gnf_columns() + gnf_columns1284 = _t2097 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("from_snapshot", 1)): - _t2087 = self.parse_iceberg_from_snapshot() - _t2086 = _t2087 + _t2099 = self.parse_iceberg_from_snapshot() + _t2098 = _t2099 else: - _t2086 = None - iceberg_from_snapshot1281 = _t2086 + _t2098 = None + iceberg_from_snapshot1285 = _t2098 if self.match_lookahead_literal("(", 0): - _t2089 = self.parse_iceberg_to_snapshot() - _t2088 = _t2089 + _t2101 = self.parse_iceberg_to_snapshot() + _t2100 = _t2101 else: - _t2088 = None - iceberg_to_snapshot1282 = _t2088 - _t2090 = self.parse_boolean_value() - boolean_value1283 = _t2090 + _t2100 = None + iceberg_to_snapshot1286 = _t2100 + _t2102 = self.parse_boolean_value() + boolean_value1287 = _t2102 self.consume_literal(")") - _t2091 = self.construct_iceberg_data(iceberg_locator1278, iceberg_catalog_config1279, gnf_columns1280, iceberg_from_snapshot1281, iceberg_to_snapshot1282, boolean_value1283) - result1285 = _t2091 - self.record_span(span_start1284, "IcebergData") - return result1285 + _t2103 = self.construct_iceberg_data(iceberg_locator1282, iceberg_catalog_config1283, gnf_columns1284, iceberg_from_snapshot1285, iceberg_to_snapshot1286, boolean_value1287) + result1289 = _t2103 + self.record_span(span_start1288, "IcebergData") + return result1289 def parse_iceberg_locator(self) -> logic_pb2.IcebergLocator: - span_start1289 = self.span_start() + span_start1293 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_locator") - _t2092 = self.parse_iceberg_locator_table_name() - iceberg_locator_table_name1286 = _t2092 - _t2093 = self.parse_iceberg_locator_namespace() - iceberg_locator_namespace1287 = _t2093 - _t2094 = self.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1288 = _t2094 + _t2104 = self.parse_iceberg_locator_table_name() + iceberg_locator_table_name1290 = _t2104 + _t2105 = self.parse_iceberg_locator_namespace() + iceberg_locator_namespace1291 = _t2105 + _t2106 = self.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1292 = _t2106 self.consume_literal(")") - _t2095 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1286, namespace=iceberg_locator_namespace1287, warehouse=iceberg_locator_warehouse1288) - result1290 = _t2095 - self.record_span(span_start1289, "IcebergLocator") - return result1290 + _t2107 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1290, namespace=iceberg_locator_namespace1291, warehouse=iceberg_locator_warehouse1292) + result1294 = _t2107 + self.record_span(span_start1293, "IcebergLocator") + return result1294 def parse_iceberg_locator_table_name(self) -> str: self.consume_literal("(") self.consume_literal("table_name") - string1291 = self.consume_terminal("STRING") + string1295 = self.consume_terminal("STRING") self.consume_literal(")") - return string1291 + return string1295 def parse_iceberg_locator_namespace(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("namespace") - xs1292 = [] - cond1293 = self.match_lookahead_terminal("STRING", 0) - while cond1293: - item1294 = self.consume_terminal("STRING") - xs1292.append(item1294) - cond1293 = self.match_lookahead_terminal("STRING", 0) - strings1295 = xs1292 + xs1296 = [] + cond1297 = self.match_lookahead_terminal("STRING", 0) + while cond1297: + item1298 = self.consume_terminal("STRING") + xs1296.append(item1298) + cond1297 = self.match_lookahead_terminal("STRING", 0) + strings1299 = xs1296 self.consume_literal(")") - return strings1295 + return strings1299 def parse_iceberg_locator_warehouse(self) -> str: self.consume_literal("(") self.consume_literal("warehouse") - string1296 = self.consume_terminal("STRING") + string1300 = self.consume_terminal("STRING") self.consume_literal(")") - return string1296 + return string1300 def parse_iceberg_catalog_config(self) -> logic_pb2.IcebergCatalogConfig: - span_start1301 = self.span_start() + span_start1305 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_catalog_config") - _t2096 = self.parse_iceberg_catalog_uri() - iceberg_catalog_uri1297 = _t2096 + _t2108 = self.parse_iceberg_catalog_uri() + iceberg_catalog_uri1301 = _t2108 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("scope", 1)): - _t2098 = self.parse_iceberg_catalog_config_scope() - _t2097 = _t2098 + _t2110 = self.parse_iceberg_catalog_config_scope() + _t2109 = _t2110 else: - _t2097 = None - iceberg_catalog_config_scope1298 = _t2097 - _t2099 = self.parse_iceberg_properties() - iceberg_properties1299 = _t2099 - _t2100 = self.parse_iceberg_auth_properties() - iceberg_auth_properties1300 = _t2100 + _t2109 = None + iceberg_catalog_config_scope1302 = _t2109 + _t2111 = self.parse_iceberg_properties() + iceberg_properties1303 = _t2111 + _t2112 = self.parse_iceberg_auth_properties() + iceberg_auth_properties1304 = _t2112 self.consume_literal(")") - _t2101 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1297, iceberg_catalog_config_scope1298, iceberg_properties1299, iceberg_auth_properties1300) - result1302 = _t2101 - self.record_span(span_start1301, "IcebergCatalogConfig") - return result1302 + _t2113 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1301, iceberg_catalog_config_scope1302, iceberg_properties1303, iceberg_auth_properties1304) + result1306 = _t2113 + self.record_span(span_start1305, "IcebergCatalogConfig") + return result1306 def parse_iceberg_catalog_uri(self) -> str: self.consume_literal("(") self.consume_literal("catalog_uri") - string1303 = self.consume_terminal("STRING") + string1307 = self.consume_terminal("STRING") self.consume_literal(")") - return string1303 + return string1307 def parse_iceberg_catalog_config_scope(self) -> str: self.consume_literal("(") self.consume_literal("scope") - string1304 = self.consume_terminal("STRING") + string1308 = self.consume_terminal("STRING") self.consume_literal(")") - return string1304 + return string1308 def parse_iceberg_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("properties") - xs1305 = [] - cond1306 = self.match_lookahead_literal("(", 0) - while cond1306: - _t2102 = self.parse_iceberg_property_entry() - item1307 = _t2102 - xs1305.append(item1307) - cond1306 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1308 = xs1305 + xs1309 = [] + cond1310 = self.match_lookahead_literal("(", 0) + while cond1310: + _t2114 = self.parse_iceberg_property_entry() + item1311 = _t2114 + xs1309.append(item1311) + cond1310 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1312 = xs1309 self.consume_literal(")") - return iceberg_property_entrys1308 + return iceberg_property_entrys1312 def parse_iceberg_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1309 = self.consume_terminal("STRING") - string_31310 = self.consume_terminal("STRING") + string1313 = self.consume_terminal("STRING") + string_31314 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1309, string_31310,) + return (string1313, string_31314,) def parse_iceberg_auth_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("auth_properties") - xs1311 = [] - cond1312 = self.match_lookahead_literal("(", 0) - while cond1312: - _t2103 = self.parse_iceberg_masked_property_entry() - item1313 = _t2103 - xs1311.append(item1313) - cond1312 = self.match_lookahead_literal("(", 0) - iceberg_masked_property_entrys1314 = xs1311 + xs1315 = [] + cond1316 = self.match_lookahead_literal("(", 0) + while cond1316: + _t2115 = self.parse_iceberg_masked_property_entry() + item1317 = _t2115 + xs1315.append(item1317) + cond1316 = self.match_lookahead_literal("(", 0) + iceberg_masked_property_entrys1318 = xs1315 self.consume_literal(")") - return iceberg_masked_property_entrys1314 + return iceberg_masked_property_entrys1318 def parse_iceberg_masked_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1315 = self.consume_terminal("STRING") - string_31316 = self.consume_terminal("STRING") + string1319 = self.consume_terminal("STRING") + string_31320 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1315, string_31316,) + return (string1319, string_31320,) def parse_iceberg_from_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("from_snapshot") - string1317 = self.consume_terminal("STRING") + string1321 = self.consume_terminal("STRING") self.consume_literal(")") - return string1317 + return string1321 def parse_iceberg_to_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("to_snapshot") - string1318 = self.consume_terminal("STRING") + string1322 = self.consume_terminal("STRING") self.consume_literal(")") - return string1318 + return string1322 def parse_undefine(self) -> transactions_pb2.Undefine: - span_start1320 = self.span_start() + span_start1324 = self.span_start() self.consume_literal("(") self.consume_literal("undefine") - _t2104 = self.parse_fragment_id() - fragment_id1319 = _t2104 + _t2116 = self.parse_fragment_id() + fragment_id1323 = _t2116 self.consume_literal(")") - _t2105 = transactions_pb2.Undefine(fragment_id=fragment_id1319) - result1321 = _t2105 - self.record_span(span_start1320, "Undefine") - return result1321 + _t2117 = transactions_pb2.Undefine(fragment_id=fragment_id1323) + result1325 = _t2117 + self.record_span(span_start1324, "Undefine") + return result1325 def parse_context(self) -> transactions_pb2.Context: - span_start1326 = self.span_start() + span_start1330 = self.span_start() self.consume_literal("(") self.consume_literal("context") - xs1322 = [] - cond1323 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1323: - _t2106 = self.parse_relation_id() - item1324 = _t2106 - xs1322.append(item1324) - cond1323 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1325 = xs1322 + xs1326 = [] + cond1327 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1327: + _t2118 = self.parse_relation_id() + item1328 = _t2118 + xs1326.append(item1328) + cond1327 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1329 = xs1326 self.consume_literal(")") - _t2107 = transactions_pb2.Context(relations=relation_ids1325) - result1327 = _t2107 - self.record_span(span_start1326, "Context") - return result1327 + _t2119 = transactions_pb2.Context(relations=relation_ids1329) + result1331 = _t2119 + self.record_span(span_start1330, "Context") + return result1331 def parse_snapshot(self) -> transactions_pb2.Snapshot: - span_start1333 = self.span_start() + span_start1337 = self.span_start() self.consume_literal("(") self.consume_literal("snapshot") - _t2108 = self.parse_edb_path() - edb_path1328 = _t2108 - xs1329 = [] - cond1330 = self.match_lookahead_literal("[", 0) - while cond1330: - _t2109 = self.parse_snapshot_mapping() - item1331 = _t2109 - xs1329.append(item1331) - cond1330 = self.match_lookahead_literal("[", 0) - snapshot_mappings1332 = xs1329 + _t2120 = self.parse_edb_path() + edb_path1332 = _t2120 + xs1333 = [] + cond1334 = self.match_lookahead_literal("[", 0) + while cond1334: + _t2121 = self.parse_snapshot_mapping() + item1335 = _t2121 + xs1333.append(item1335) + cond1334 = self.match_lookahead_literal("[", 0) + snapshot_mappings1336 = xs1333 self.consume_literal(")") - _t2110 = transactions_pb2.Snapshot(prefix=edb_path1328, mappings=snapshot_mappings1332) - result1334 = _t2110 - self.record_span(span_start1333, "Snapshot") - return result1334 + _t2122 = transactions_pb2.Snapshot(prefix=edb_path1332, mappings=snapshot_mappings1336) + result1338 = _t2122 + self.record_span(span_start1337, "Snapshot") + return result1338 def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: - span_start1337 = self.span_start() - _t2111 = self.parse_edb_path() - edb_path1335 = _t2111 - _t2112 = self.parse_relation_id() - relation_id1336 = _t2112 - _t2113 = transactions_pb2.SnapshotMapping(destination_path=edb_path1335, source_relation=relation_id1336) - result1338 = _t2113 - self.record_span(span_start1337, "SnapshotMapping") - return result1338 + span_start1341 = self.span_start() + _t2123 = self.parse_edb_path() + edb_path1339 = _t2123 + _t2124 = self.parse_relation_id() + relation_id1340 = _t2124 + _t2125 = transactions_pb2.SnapshotMapping(destination_path=edb_path1339, source_relation=relation_id1340) + result1342 = _t2125 + self.record_span(span_start1341, "SnapshotMapping") + return result1342 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs1339 = [] - cond1340 = self.match_lookahead_literal("(", 0) - while cond1340: - _t2114 = self.parse_read() - item1341 = _t2114 - xs1339.append(item1341) - cond1340 = self.match_lookahead_literal("(", 0) - reads1342 = xs1339 + xs1343 = [] + cond1344 = self.match_lookahead_literal("(", 0) + while cond1344: + _t2126 = self.parse_read() + item1345 = _t2126 + xs1343.append(item1345) + cond1344 = self.match_lookahead_literal("(", 0) + reads1346 = xs1343 self.consume_literal(")") - return reads1342 + return reads1346 def parse_read(self) -> transactions_pb2.Read: - span_start1349 = self.span_start() + span_start1353 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t2116 = 2 + _t2128 = 2 else: if self.match_lookahead_literal("output", 1): - _t2117 = 1 + _t2129 = 1 else: if self.match_lookahead_literal("export_iceberg", 1): - _t2118 = 4 + _t2130 = 4 else: if self.match_lookahead_literal("export", 1): - _t2119 = 4 + _t2131 = 4 else: if self.match_lookahead_literal("demand", 1): - _t2120 = 0 + _t2132 = 0 else: if self.match_lookahead_literal("abort", 1): - _t2121 = 3 + _t2133 = 3 else: - _t2121 = -1 - _t2120 = _t2121 - _t2119 = _t2120 - _t2118 = _t2119 - _t2117 = _t2118 - _t2116 = _t2117 - _t2115 = _t2116 + _t2133 = -1 + _t2132 = _t2133 + _t2131 = _t2132 + _t2130 = _t2131 + _t2129 = _t2130 + _t2128 = _t2129 + _t2127 = _t2128 else: - _t2115 = -1 - prediction1343 = _t2115 - if prediction1343 == 4: - _t2123 = self.parse_export() - export1348 = _t2123 - _t2124 = transactions_pb2.Read(export=export1348) - _t2122 = _t2124 + _t2127 = -1 + prediction1347 = _t2127 + if prediction1347 == 4: + _t2135 = self.parse_export() + export1352 = _t2135 + _t2136 = transactions_pb2.Read(export=export1352) + _t2134 = _t2136 else: - if prediction1343 == 3: - _t2126 = self.parse_abort() - abort1347 = _t2126 - _t2127 = transactions_pb2.Read(abort=abort1347) - _t2125 = _t2127 + if prediction1347 == 3: + _t2138 = self.parse_abort() + abort1351 = _t2138 + _t2139 = transactions_pb2.Read(abort=abort1351) + _t2137 = _t2139 else: - if prediction1343 == 2: - _t2129 = self.parse_what_if() - what_if1346 = _t2129 - _t2130 = transactions_pb2.Read(what_if=what_if1346) - _t2128 = _t2130 + if prediction1347 == 2: + _t2141 = self.parse_what_if() + what_if1350 = _t2141 + _t2142 = transactions_pb2.Read(what_if=what_if1350) + _t2140 = _t2142 else: - if prediction1343 == 1: - _t2132 = self.parse_output() - output1345 = _t2132 - _t2133 = transactions_pb2.Read(output=output1345) - _t2131 = _t2133 + if prediction1347 == 1: + _t2144 = self.parse_output() + output1349 = _t2144 + _t2145 = transactions_pb2.Read(output=output1349) + _t2143 = _t2145 else: - if prediction1343 == 0: - _t2135 = self.parse_demand() - demand1344 = _t2135 - _t2136 = transactions_pb2.Read(demand=demand1344) - _t2134 = _t2136 + if prediction1347 == 0: + _t2147 = self.parse_demand() + demand1348 = _t2147 + _t2148 = transactions_pb2.Read(demand=demand1348) + _t2146 = _t2148 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2131 = _t2134 - _t2128 = _t2131 - _t2125 = _t2128 - _t2122 = _t2125 - result1350 = _t2122 - self.record_span(span_start1349, "Read") - return result1350 + _t2143 = _t2146 + _t2140 = _t2143 + _t2137 = _t2140 + _t2134 = _t2137 + result1354 = _t2134 + self.record_span(span_start1353, "Read") + return result1354 def parse_demand(self) -> transactions_pb2.Demand: - span_start1352 = self.span_start() + span_start1356 = self.span_start() self.consume_literal("(") self.consume_literal("demand") - _t2137 = self.parse_relation_id() - relation_id1351 = _t2137 + _t2149 = self.parse_relation_id() + relation_id1355 = _t2149 self.consume_literal(")") - _t2138 = transactions_pb2.Demand(relation_id=relation_id1351) - result1353 = _t2138 - self.record_span(span_start1352, "Demand") - return result1353 + _t2150 = transactions_pb2.Demand(relation_id=relation_id1355) + result1357 = _t2150 + self.record_span(span_start1356, "Demand") + return result1357 def parse_output(self) -> transactions_pb2.Output: - span_start1356 = self.span_start() + span_start1360 = self.span_start() self.consume_literal("(") self.consume_literal("output") - _t2139 = self.parse_name() - name1354 = _t2139 - _t2140 = self.parse_relation_id() - relation_id1355 = _t2140 + _t2151 = self.parse_name() + name1358 = _t2151 + _t2152 = self.parse_relation_id() + relation_id1359 = _t2152 self.consume_literal(")") - _t2141 = transactions_pb2.Output(name=name1354, relation_id=relation_id1355) - result1357 = _t2141 - self.record_span(span_start1356, "Output") - return result1357 + _t2153 = transactions_pb2.Output(name=name1358, relation_id=relation_id1359) + result1361 = _t2153 + self.record_span(span_start1360, "Output") + return result1361 def parse_what_if(self) -> transactions_pb2.WhatIf: - span_start1360 = self.span_start() + span_start1364 = self.span_start() self.consume_literal("(") self.consume_literal("what_if") - _t2142 = self.parse_name() - name1358 = _t2142 - _t2143 = self.parse_epoch() - epoch1359 = _t2143 + _t2154 = self.parse_name() + name1362 = _t2154 + _t2155 = self.parse_epoch() + epoch1363 = _t2155 self.consume_literal(")") - _t2144 = transactions_pb2.WhatIf(branch=name1358, epoch=epoch1359) - result1361 = _t2144 - self.record_span(span_start1360, "WhatIf") - return result1361 + _t2156 = transactions_pb2.WhatIf(branch=name1362, epoch=epoch1363) + result1365 = _t2156 + self.record_span(span_start1364, "WhatIf") + return result1365 def parse_abort(self) -> transactions_pb2.Abort: - span_start1364 = self.span_start() + span_start1368 = self.span_start() self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t2146 = self.parse_name() - _t2145 = _t2146 + _t2158 = self.parse_name() + _t2157 = _t2158 else: - _t2145 = None - name1362 = _t2145 - _t2147 = self.parse_relation_id() - relation_id1363 = _t2147 + _t2157 = None + name1366 = _t2157 + _t2159 = self.parse_relation_id() + relation_id1367 = _t2159 self.consume_literal(")") - _t2148 = transactions_pb2.Abort(name=(name1362 if name1362 is not None else "abort"), relation_id=relation_id1363) - result1365 = _t2148 - self.record_span(span_start1364, "Abort") - return result1365 + _t2160 = transactions_pb2.Abort(name=(name1366 if name1366 is not None else "abort"), relation_id=relation_id1367) + result1369 = _t2160 + self.record_span(span_start1368, "Abort") + return result1369 def parse_export(self) -> transactions_pb2.Export: - span_start1369 = self.span_start() + span_start1373 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_iceberg", 1): - _t2150 = 1 + _t2162 = 1 else: if self.match_lookahead_literal("export", 1): - _t2151 = 0 + _t2163 = 0 else: - _t2151 = -1 - _t2150 = _t2151 - _t2149 = _t2150 + _t2163 = -1 + _t2162 = _t2163 + _t2161 = _t2162 else: - _t2149 = -1 - prediction1366 = _t2149 - if prediction1366 == 1: + _t2161 = -1 + prediction1370 = _t2161 + if prediction1370 == 1: self.consume_literal("(") self.consume_literal("export_iceberg") - _t2153 = self.parse_export_iceberg_config() - export_iceberg_config1368 = _t2153 + _t2165 = self.parse_export_iceberg_config() + export_iceberg_config1372 = _t2165 self.consume_literal(")") - _t2154 = transactions_pb2.Export(iceberg_config=export_iceberg_config1368) - _t2152 = _t2154 + _t2166 = transactions_pb2.Export(iceberg_config=export_iceberg_config1372) + _t2164 = _t2166 else: - if prediction1366 == 0: + if prediction1370 == 0: self.consume_literal("(") self.consume_literal("export") - _t2156 = self.parse_export_csv_config() - export_csv_config1367 = _t2156 + _t2168 = self.parse_export_csv_config() + export_csv_config1371 = _t2168 self.consume_literal(")") - _t2157 = transactions_pb2.Export(csv_config=export_csv_config1367) - _t2155 = _t2157 + _t2169 = transactions_pb2.Export(csv_config=export_csv_config1371) + _t2167 = _t2169 else: raise ParseError("Unexpected token in export" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2152 = _t2155 - result1370 = _t2152 - self.record_span(span_start1369, "Export") - return result1370 + _t2164 = _t2167 + result1374 = _t2164 + self.record_span(span_start1373, "Export") + return result1374 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1378 = self.span_start() + span_start1382 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2159 = 0 + _t2171 = 0 else: if self.match_lookahead_literal("export_csv_config", 1): - _t2160 = 1 + _t2172 = 1 else: - _t2160 = -1 - _t2159 = _t2160 - _t2158 = _t2159 + _t2172 = -1 + _t2171 = _t2172 + _t2170 = _t2171 else: - _t2158 = -1 - prediction1371 = _t2158 - if prediction1371 == 1: + _t2170 = -1 + prediction1375 = _t2170 + if prediction1375 == 1: self.consume_literal("(") self.consume_literal("export_csv_config") - _t2162 = self.parse_export_csv_path() - export_csv_path1375 = _t2162 - _t2163 = self.parse_export_csv_columns_list() - export_csv_columns_list1376 = _t2163 - _t2164 = self.parse_config_dict() - config_dict1377 = _t2164 + _t2174 = self.parse_export_csv_path() + export_csv_path1379 = _t2174 + _t2175 = self.parse_export_csv_columns_list() + export_csv_columns_list1380 = _t2175 + _t2176 = self.parse_config_dict() + config_dict1381 = _t2176 self.consume_literal(")") - _t2165 = self.construct_export_csv_config(export_csv_path1375, export_csv_columns_list1376, config_dict1377) - _t2161 = _t2165 + _t2177 = self.construct_export_csv_config(export_csv_path1379, export_csv_columns_list1380, config_dict1381) + _t2173 = _t2177 else: - if prediction1371 == 0: + if prediction1375 == 0: self.consume_literal("(") self.consume_literal("export_csv_config_v2") - _t2167 = self.parse_export_csv_output_location() - export_csv_output_location1372 = _t2167 - _t2168 = self.parse_export_csv_source() - export_csv_source1373 = _t2168 - _t2169 = self.parse_csv_config() - csv_config1374 = _t2169 + _t2179 = self.parse_export_csv_output_location() + export_csv_output_location1376 = _t2179 + _t2180 = self.parse_export_csv_source() + export_csv_source1377 = _t2180 + _t2181 = self.parse_csv_config() + csv_config1378 = _t2181 self.consume_literal(")") - _t2170 = self.construct_export_csv_config_with_location(export_csv_output_location1372, export_csv_source1373, csv_config1374) - _t2166 = _t2170 + _t2182 = self.construct_export_csv_config_with_location(export_csv_output_location1376, export_csv_source1377, csv_config1378) + _t2178 = _t2182 else: raise ParseError("Unexpected token in export_csv_config" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2161 = _t2166 - result1379 = _t2161 - self.record_span(span_start1378, "ExportCSVConfig") - return result1379 + _t2173 = _t2178 + result1383 = _t2173 + self.record_span(span_start1382, "ExportCSVConfig") + return result1383 def parse_export_csv_output_location(self) -> tuple[str, str]: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("transaction_output_name", 1): - _t2172 = 1 + _t2184 = 1 else: if self.match_lookahead_literal("path", 1): - _t2173 = 0 + _t2185 = 0 else: - _t2173 = -1 - _t2172 = _t2173 - _t2171 = _t2172 + _t2185 = -1 + _t2184 = _t2185 + _t2183 = _t2184 else: - _t2171 = -1 - prediction1380 = _t2171 - if prediction1380 == 1: + _t2183 = -1 + prediction1384 = _t2183 + if prediction1384 == 1: self.consume_literal("(") self.consume_literal("transaction_output_name") - _t2175 = self.parse_name() - name1382 = _t2175 + _t2187 = self.parse_name() + name1386 = _t2187 self.consume_literal(")") - _t2174 = ("", name1382,) + _t2186 = ("", name1386,) else: - if prediction1380 == 0: + if prediction1384 == 0: self.consume_literal("(") self.consume_literal("path") - string1381 = self.consume_terminal("STRING") + string1385 = self.consume_terminal("STRING") self.consume_literal(")") - _t2176 = (string1381, "",) + _t2188 = (string1385, "",) else: raise ParseError("Unexpected token in export_csv_output_location" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2174 = _t2176 - return _t2174 + _t2186 = _t2188 + return _t2186 def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1389 = self.span_start() + span_start1393 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("table_def", 1): - _t2178 = 1 + _t2190 = 1 else: if self.match_lookahead_literal("gnf_columns", 1): - _t2179 = 0 + _t2191 = 0 else: - _t2179 = -1 - _t2178 = _t2179 - _t2177 = _t2178 + _t2191 = -1 + _t2190 = _t2191 + _t2189 = _t2190 else: - _t2177 = -1 - prediction1383 = _t2177 - if prediction1383 == 1: + _t2189 = -1 + prediction1387 = _t2189 + if prediction1387 == 1: self.consume_literal("(") self.consume_literal("table_def") - _t2181 = self.parse_relation_id() - relation_id1388 = _t2181 + _t2193 = self.parse_relation_id() + relation_id1392 = _t2193 self.consume_literal(")") - _t2182 = transactions_pb2.ExportCSVSource(table_def=relation_id1388) - _t2180 = _t2182 + _t2194 = transactions_pb2.ExportCSVSource(table_def=relation_id1392) + _t2192 = _t2194 else: - if prediction1383 == 0: + if prediction1387 == 0: self.consume_literal("(") self.consume_literal("gnf_columns") - xs1384 = [] - cond1385 = self.match_lookahead_literal("(", 0) - while cond1385: - _t2184 = self.parse_export_csv_column() - item1386 = _t2184 - xs1384.append(item1386) - cond1385 = self.match_lookahead_literal("(", 0) - export_csv_columns1387 = xs1384 + xs1388 = [] + cond1389 = self.match_lookahead_literal("(", 0) + while cond1389: + _t2196 = self.parse_export_csv_column() + item1390 = _t2196 + xs1388.append(item1390) + cond1389 = self.match_lookahead_literal("(", 0) + export_csv_columns1391 = xs1388 self.consume_literal(")") - _t2185 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1387) - _t2186 = transactions_pb2.ExportCSVSource(gnf_columns=_t2185) - _t2183 = _t2186 + _t2197 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1391) + _t2198 = transactions_pb2.ExportCSVSource(gnf_columns=_t2197) + _t2195 = _t2198 else: raise ParseError("Unexpected token in export_csv_source" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2180 = _t2183 - result1390 = _t2180 - self.record_span(span_start1389, "ExportCSVSource") - return result1390 + _t2192 = _t2195 + result1394 = _t2192 + self.record_span(span_start1393, "ExportCSVSource") + return result1394 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1393 = self.span_start() + span_start1397 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1391 = self.consume_terminal("STRING") - _t2187 = self.parse_relation_id() - relation_id1392 = _t2187 + string1395 = self.consume_terminal("STRING") + _t2199 = self.parse_relation_id() + relation_id1396 = _t2199 self.consume_literal(")") - _t2188 = transactions_pb2.ExportCSVColumn(column_name=string1391, column_data=relation_id1392) - result1394 = _t2188 - self.record_span(span_start1393, "ExportCSVColumn") - return result1394 + _t2200 = transactions_pb2.ExportCSVColumn(column_name=string1395, column_data=relation_id1396) + result1398 = _t2200 + self.record_span(span_start1397, "ExportCSVColumn") + return result1398 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") - string1395 = self.consume_terminal("STRING") + string1399 = self.consume_terminal("STRING") self.consume_literal(")") - return string1395 + return string1399 def parse_export_csv_columns_list(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1396 = [] - cond1397 = self.match_lookahead_literal("(", 0) - while cond1397: - _t2189 = self.parse_export_csv_column() - item1398 = _t2189 - xs1396.append(item1398) - cond1397 = self.match_lookahead_literal("(", 0) - export_csv_columns1399 = xs1396 + xs1400 = [] + cond1401 = self.match_lookahead_literal("(", 0) + while cond1401: + _t2201 = self.parse_export_csv_column() + item1402 = _t2201 + xs1400.append(item1402) + cond1401 = self.match_lookahead_literal("(", 0) + export_csv_columns1403 = xs1400 self.consume_literal(")") - return export_csv_columns1399 + return export_csv_columns1403 def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1405 = self.span_start() + span_start1409 = self.span_start() self.consume_literal("(") self.consume_literal("export_iceberg_config") - _t2190 = self.parse_iceberg_locator() - iceberg_locator1400 = _t2190 - _t2191 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1401 = _t2191 - _t2192 = self.parse_export_iceberg_table_def() - export_iceberg_table_def1402 = _t2192 - _t2193 = self.parse_iceberg_table_properties() - iceberg_table_properties1403 = _t2193 + _t2202 = self.parse_iceberg_locator() + iceberg_locator1404 = _t2202 + _t2203 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1405 = _t2203 + _t2204 = self.parse_export_iceberg_table_def() + export_iceberg_table_def1406 = _t2204 + _t2205 = self.parse_iceberg_table_properties() + iceberg_table_properties1407 = _t2205 if self.match_lookahead_literal("{", 0): - _t2195 = self.parse_config_dict() - _t2194 = _t2195 + _t2207 = self.parse_config_dict() + _t2206 = _t2207 else: - _t2194 = None - config_dict1404 = _t2194 + _t2206 = None + config_dict1408 = _t2206 self.consume_literal(")") - _t2196 = self.construct_export_iceberg_config_full(iceberg_locator1400, iceberg_catalog_config1401, export_iceberg_table_def1402, iceberg_table_properties1403, config_dict1404) - result1406 = _t2196 - self.record_span(span_start1405, "ExportIcebergConfig") - return result1406 + _t2208 = self.construct_export_iceberg_config_full(iceberg_locator1404, iceberg_catalog_config1405, export_iceberg_table_def1406, iceberg_table_properties1407, config_dict1408) + result1410 = _t2208 + self.record_span(span_start1409, "ExportIcebergConfig") + return result1410 def parse_export_iceberg_table_def(self) -> logic_pb2.RelationId: - span_start1408 = self.span_start() + span_start1412 = self.span_start() self.consume_literal("(") self.consume_literal("table_def") - _t2197 = self.parse_relation_id() - relation_id1407 = _t2197 + _t2209 = self.parse_relation_id() + relation_id1411 = _t2209 self.consume_literal(")") - result1409 = relation_id1407 - self.record_span(span_start1408, "RelationId") - return result1409 + result1413 = relation_id1411 + self.record_span(span_start1412, "RelationId") + return result1413 def parse_iceberg_table_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("table_properties") - xs1410 = [] - cond1411 = self.match_lookahead_literal("(", 0) - while cond1411: - _t2198 = self.parse_iceberg_property_entry() - item1412 = _t2198 - xs1410.append(item1412) - cond1411 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1413 = xs1410 + xs1414 = [] + cond1415 = self.match_lookahead_literal("(", 0) + while cond1415: + _t2210 = self.parse_iceberg_property_entry() + item1416 = _t2210 + xs1414.append(item1416) + cond1415 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1417 = xs1414 self.consume_literal(")") - return iceberg_property_entrys1413 + return iceberg_property_entrys1417 def parse_transaction(input_str: str) -> tuple[Any, dict[int, Span]]: diff --git a/sdks/python/src/lqp/gen/pretty.py b/sdks/python/src/lqp/gen/pretty.py index a0863d46..975345bc 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -216,11 +216,14 @@ def write_debug_info(self) -> None: # --- Helper functions --- + def deconstruct_relation_keys(self, msg: logic_pb2.TargetRelations) -> tuple[Sequence[logic_pb2.NamedColumn], bool]: + return (msg.keys, msg.synthetic_key,) + def deconstruct_csv_data_columns_optional(self, msg: logic_pb2.CSVData) -> Sequence[logic_pb2.GNFColumn] | None: if msg.HasField("relations"): return None else: - _t1845 = None + _t1854 = None return msg.columns def deconstruct_csv_data_relations_optional(self, msg: logic_pb2.CSVData) -> logic_pb2.TargetRelations | None: @@ -228,166 +231,166 @@ def deconstruct_csv_data_relations_optional(self, msg: logic_pb2.CSVData) -> log assert msg.relations is not None return msg.relations else: - _t1846 = None + _t1855 = None return None def deconstruct_export_csv_output_location(self, msg: transactions_pb2.ExportCSVConfig) -> tuple[str, str]: return (msg.path, msg.transaction_output_name,) def _make_value_int32(self, v: int) -> logic_pb2.Value: - _t1847 = logic_pb2.Value(int32_value=v) - return _t1847 + _t1856 = logic_pb2.Value(int32_value=v) + return _t1856 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1848 = logic_pb2.Value(int_value=v) - return _t1848 + _t1857 = logic_pb2.Value(int_value=v) + return _t1857 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1849 = logic_pb2.Value(float_value=v) - return _t1849 + _t1858 = logic_pb2.Value(float_value=v) + return _t1858 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1850 = logic_pb2.Value(string_value=v) - return _t1850 + _t1859 = logic_pb2.Value(string_value=v) + return _t1859 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1851 = logic_pb2.Value(boolean_value=v) - return _t1851 + _t1860 = logic_pb2.Value(boolean_value=v) + return _t1860 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1852 = logic_pb2.Value(uint128_value=v) - return _t1852 + _t1861 = logic_pb2.Value(uint128_value=v) + return _t1861 def deconstruct_configure(self, msg: transactions_pb2.Configure) -> list[tuple[str, logic_pb2.Value]]: result = [] if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_AUTO: - _t1853 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1853,)) + _t1862 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1862,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1854 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1854,)) + _t1863 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1863,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1855 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1855,)) - _t1856 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1856,)) + _t1864 = self._make_value_string("off") + result.append(("ivm.maintenance_level", _t1864,)) + _t1865 = self._make_value_int64(msg.semantics_version) + result.append(("semantics_version", _t1865,)) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1857 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1857,)) - _t1858 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1858,)) + _t1866 = self._make_value_int32(msg.header_row) + result.append(("csv_header_row", _t1866,)) + _t1867 = self._make_value_int64(msg.skip) + result.append(("csv_skip", _t1867,)) if msg.new_line != "": - _t1859 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1859,)) - _t1860 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1860,)) - _t1861 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1861,)) - _t1862 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1862,)) + _t1868 = self._make_value_string(msg.new_line) + result.append(("csv_new_line", _t1868,)) + _t1869 = self._make_value_string(msg.delimiter) + result.append(("csv_delimiter", _t1869,)) + _t1870 = self._make_value_string(msg.quotechar) + result.append(("csv_quotechar", _t1870,)) + _t1871 = self._make_value_string(msg.escapechar) + result.append(("csv_escapechar", _t1871,)) if msg.comment != "": - _t1863 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1863,)) + _t1872 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1872,)) for missing_string in msg.missing_strings: - _t1864 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1864,)) - _t1865 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1865,)) - _t1866 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1866,)) - _t1867 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1867,)) + _t1873 = self._make_value_string(missing_string) + result.append(("csv_missing_strings", _t1873,)) + _t1874 = self._make_value_string(msg.decimal_separator) + result.append(("csv_decimal_separator", _t1874,)) + _t1875 = self._make_value_string(msg.encoding) + result.append(("csv_encoding", _t1875,)) + _t1876 = self._make_value_string(msg.compression) + result.append(("csv_compression", _t1876,)) if msg.partition_size_mb != 0: - _t1868 = self._make_value_int64(msg.partition_size_mb) - result.append(("csv_partition_size_mb", _t1868,)) + _t1877 = self._make_value_int64(msg.partition_size_mb) + result.append(("csv_partition_size_mb", _t1877,)) return sorted(result) def deconstruct_csv_storage_integration_optional(self, msg: logic_pb2.CSVConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: if not msg.HasField("storage_integration"): return None else: - _t1869 = None + _t1878 = None assert msg.storage_integration is not None si = msg.storage_integration result = [] if si.provider != "": - _t1870 = self._make_value_string(si.provider) - result.append(("provider", _t1870,)) + _t1879 = self._make_value_string(si.provider) + result.append(("provider", _t1879,)) if si.azure_sas_token != "": - _t1871 = self._make_value_string("***") - result.append(("azure_sas_token", _t1871,)) + _t1880 = self._make_value_string("***") + result.append(("azure_sas_token", _t1880,)) if si.s3_region != "": - _t1872 = self._make_value_string(si.s3_region) - result.append(("s3_region", _t1872,)) + _t1881 = self._make_value_string(si.s3_region) + result.append(("s3_region", _t1881,)) if si.s3_access_key_id != "": - _t1873 = self._make_value_string("***") - result.append(("s3_access_key_id", _t1873,)) + _t1882 = self._make_value_string("***") + result.append(("s3_access_key_id", _t1882,)) if si.s3_secret_access_key != "": - _t1874 = self._make_value_string("***") - result.append(("s3_secret_access_key", _t1874,)) + _t1883 = self._make_value_string("***") + result.append(("s3_secret_access_key", _t1883,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1875 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1875,)) - _t1876 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1876,)) - _t1877 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1877,)) - _t1878 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1878,)) + _t1884 = self._make_value_float64(msg.storage_config.epsilon) + result.append(("betree_config_epsilon", _t1884,)) + _t1885 = self._make_value_int64(msg.storage_config.max_pivots) + result.append(("betree_config_max_pivots", _t1885,)) + _t1886 = self._make_value_int64(msg.storage_config.max_deltas) + result.append(("betree_config_max_deltas", _t1886,)) + _t1887 = self._make_value_int64(msg.storage_config.max_leaf) + result.append(("betree_config_max_leaf", _t1887,)) if msg.relation_locator.HasField("root_pageid"): if msg.relation_locator.root_pageid is not None: assert msg.relation_locator.root_pageid is not None - _t1879 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1879,)) + _t1888 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1888,)) if msg.relation_locator.HasField("inline_data"): if msg.relation_locator.inline_data is not None: assert msg.relation_locator.inline_data is not None - _t1880 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1880,)) - _t1881 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1881,)) - _t1882 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1882,)) + _t1889 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) + result.append(("betree_locator_inline_data", _t1889,)) + _t1890 = self._make_value_int64(msg.relation_locator.element_count) + result.append(("betree_locator_element_count", _t1890,)) + _t1891 = self._make_value_int64(msg.relation_locator.tree_height) + result.append(("betree_locator_tree_height", _t1891,)) return sorted(result) def deconstruct_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] if msg.partition_size is not None: assert msg.partition_size is not None - _t1883 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1883,)) + _t1892 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1892,)) if msg.compression is not None: assert msg.compression is not None - _t1884 = self._make_value_string(msg.compression) - result.append(("compression", _t1884,)) + _t1893 = self._make_value_string(msg.compression) + result.append(("compression", _t1893,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1885 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1885,)) + _t1894 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1894,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1886 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1886,)) + _t1895 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1895,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1887 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1887,)) + _t1896 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1896,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1888 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1888,)) + _t1897 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1897,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1889 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1889,)) + _t1898 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1898,)) return sorted(result) def mask_secret_value(self, pair: tuple[str, str]) -> str: @@ -399,7 +402,7 @@ def deconstruct_iceberg_catalog_config_scope_optional(self, msg: logic_pb2.Icebe assert msg.scope is not None return msg.scope else: - _t1890 = None + _t1899 = None return None def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -408,7 +411,7 @@ def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.Iceberg assert msg.from_snapshot is not None return msg.from_snapshot else: - _t1891 = None + _t1900 = None return None def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -417,7 +420,7 @@ def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergDa assert msg.to_snapshot is not None return msg.to_snapshot else: - _t1892 = None + _t1901 = None return None def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.ExportIcebergConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: @@ -425,20 +428,20 @@ def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.Expor assert msg.prefix is not None if msg.prefix != "": assert msg.prefix is not None - _t1893 = self._make_value_string(msg.prefix) - result.append(("prefix", _t1893,)) + _t1902 = self._make_value_string(msg.prefix) + result.append(("prefix", _t1902,)) assert msg.target_file_size_bytes is not None if msg.target_file_size_bytes != 0: assert msg.target_file_size_bytes is not None - _t1894 = self._make_value_int64(msg.target_file_size_bytes) - result.append(("target_file_size_bytes", _t1894,)) + _t1903 = self._make_value_int64(msg.target_file_size_bytes) + result.append(("target_file_size_bytes", _t1903,)) if msg.compression != "": - _t1895 = self._make_value_string(msg.compression) - result.append(("compression", _t1895,)) + _t1904 = self._make_value_string(msg.compression) + result.append(("compression", _t1904,)) if len(result) == 0: return None else: - _t1896 = None + _t1905 = None return sorted(result) def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: @@ -451,7 +454,7 @@ def deconstruct_relation_id_uint128(self, msg: logic_pb2.RelationId) -> logic_pb if name is None: return self.relation_id_to_uint128(msg) else: - _t1897 = None + _t1906 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -466,2542 +469,2524 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat856 = self._try_flat(msg, self.pretty_transaction) - if flat856 is not None: - assert flat856 is not None - self.write(flat856) + flat859 = self._try_flat(msg, self.pretty_transaction) + if flat859 is not None: + assert flat859 is not None + self.write(flat859) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("configure"): - _t1694 = _dollar_dollar.configure + _t1700 = _dollar_dollar.configure else: - _t1694 = None + _t1700 = None if _dollar_dollar.HasField("sync"): - _t1695 = _dollar_dollar.sync + _t1701 = _dollar_dollar.sync else: - _t1695 = None - fields847 = (_t1694, _t1695, _dollar_dollar.epochs,) - assert fields847 is not None - unwrapped_fields848 = fields847 + _t1701 = None + fields850 = (_t1700, _t1701, _dollar_dollar.epochs,) + assert fields850 is not None + unwrapped_fields851 = fields850 self.write("(transaction") self.indent_sexp() - field849 = unwrapped_fields848[0] - if field849 is not None: + field852 = unwrapped_fields851[0] + if field852 is not None: self.newline() - assert field849 is not None - opt_val850 = field849 - self.pretty_configure(opt_val850) - field851 = unwrapped_fields848[1] - if field851 is not None: + assert field852 is not None + opt_val853 = field852 + self.pretty_configure(opt_val853) + field854 = unwrapped_fields851[1] + if field854 is not None: self.newline() - assert field851 is not None - opt_val852 = field851 - self.pretty_sync(opt_val852) - field853 = unwrapped_fields848[2] - if not len(field853) == 0: + assert field854 is not None + opt_val855 = field854 + self.pretty_sync(opt_val855) + field856 = unwrapped_fields851[2] + if not len(field856) == 0: self.newline() - for i855, elem854 in enumerate(field853): - if (i855 > 0): + for i858, elem857 in enumerate(field856): + if (i858 > 0): self.newline() - self.pretty_epoch(elem854) + self.pretty_epoch(elem857) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - flat859 = self._try_flat(msg, self.pretty_configure) - if flat859 is not None: - assert flat859 is not None - self.write(flat859) + flat862 = self._try_flat(msg, self.pretty_configure) + if flat862 is not None: + assert flat862 is not None + self.write(flat862) return None else: _dollar_dollar = msg - _t1696 = self.deconstruct_configure(_dollar_dollar) - fields857 = _t1696 - assert fields857 is not None - unwrapped_fields858 = fields857 + _t1702 = self.deconstruct_configure(_dollar_dollar) + fields860 = _t1702 + assert fields860 is not None + unwrapped_fields861 = fields860 self.write("(configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields858) + self.pretty_config_dict(unwrapped_fields861) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat863 = self._try_flat(msg, self.pretty_config_dict) - if flat863 is not None: - assert flat863 is not None - self.write(flat863) + flat866 = self._try_flat(msg, self.pretty_config_dict) + if flat866 is not None: + assert flat866 is not None + self.write(flat866) return None else: - fields860 = msg + fields863 = msg self.write("{") self.indent() - if not len(fields860) == 0: + if not len(fields863) == 0: self.newline() - for i862, elem861 in enumerate(fields860): - if (i862 > 0): + for i865, elem864 in enumerate(fields863): + if (i865 > 0): self.newline() - self.pretty_config_key_value(elem861) + self.pretty_config_key_value(elem864) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat868 = self._try_flat(msg, self.pretty_config_key_value) - if flat868 is not None: - assert flat868 is not None - self.write(flat868) + flat871 = self._try_flat(msg, self.pretty_config_key_value) + if flat871 is not None: + assert flat871 is not None + self.write(flat871) return None else: _dollar_dollar = msg - fields864 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields864 is not None - unwrapped_fields865 = fields864 + fields867 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields867 is not None + unwrapped_fields868 = fields867 self.write(":") - field866 = unwrapped_fields865[0] - self.write(field866) + field869 = unwrapped_fields868[0] + self.write(field869) self.write(" ") - field867 = unwrapped_fields865[1] - self.pretty_raw_value(field867) + field870 = unwrapped_fields868[1] + self.pretty_raw_value(field870) def pretty_raw_value(self, msg: logic_pb2.Value): - flat894 = self._try_flat(msg, self.pretty_raw_value) - if flat894 is not None: - assert flat894 is not None - self.write(flat894) + flat897 = self._try_flat(msg, self.pretty_raw_value) + if flat897 is not None: + assert flat897 is not None + self.write(flat897) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1697 = _dollar_dollar.date_value + _t1703 = _dollar_dollar.date_value else: - _t1697 = None - deconstruct_result892 = _t1697 - if deconstruct_result892 is not None: - assert deconstruct_result892 is not None - unwrapped893 = deconstruct_result892 - self.pretty_raw_date(unwrapped893) + _t1703 = None + deconstruct_result895 = _t1703 + if deconstruct_result895 is not None: + assert deconstruct_result895 is not None + unwrapped896 = deconstruct_result895 + self.pretty_raw_date(unwrapped896) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1698 = _dollar_dollar.datetime_value + _t1704 = _dollar_dollar.datetime_value else: - _t1698 = None - deconstruct_result890 = _t1698 - if deconstruct_result890 is not None: - assert deconstruct_result890 is not None - unwrapped891 = deconstruct_result890 - self.pretty_raw_datetime(unwrapped891) + _t1704 = None + deconstruct_result893 = _t1704 + if deconstruct_result893 is not None: + assert deconstruct_result893 is not None + unwrapped894 = deconstruct_result893 + self.pretty_raw_datetime(unwrapped894) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1699 = _dollar_dollar.string_value + _t1705 = _dollar_dollar.string_value else: - _t1699 = None - deconstruct_result888 = _t1699 - if deconstruct_result888 is not None: - assert deconstruct_result888 is not None - unwrapped889 = deconstruct_result888 - self.write(self.format_string_value(unwrapped889)) + _t1705 = None + deconstruct_result891 = _t1705 + if deconstruct_result891 is not None: + assert deconstruct_result891 is not None + unwrapped892 = deconstruct_result891 + self.write(self.format_string_value(unwrapped892)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1700 = _dollar_dollar.int32_value + _t1706 = _dollar_dollar.int32_value else: - _t1700 = None - deconstruct_result886 = _t1700 - if deconstruct_result886 is not None: - assert deconstruct_result886 is not None - unwrapped887 = deconstruct_result886 - self.write((str(unwrapped887) + 'i32')) + _t1706 = None + deconstruct_result889 = _t1706 + if deconstruct_result889 is not None: + assert deconstruct_result889 is not None + unwrapped890 = deconstruct_result889 + self.write((str(unwrapped890) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1701 = _dollar_dollar.int_value + _t1707 = _dollar_dollar.int_value else: - _t1701 = None - deconstruct_result884 = _t1701 - if deconstruct_result884 is not None: - assert deconstruct_result884 is not None - unwrapped885 = deconstruct_result884 - self.write(str(unwrapped885)) + _t1707 = None + deconstruct_result887 = _t1707 + if deconstruct_result887 is not None: + assert deconstruct_result887 is not None + unwrapped888 = deconstruct_result887 + self.write(str(unwrapped888)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1702 = _dollar_dollar.float32_value + _t1708 = _dollar_dollar.float32_value else: - _t1702 = None - deconstruct_result882 = _t1702 - if deconstruct_result882 is not None: - assert deconstruct_result882 is not None - unwrapped883 = deconstruct_result882 - self.write(self.format_float32_literal(unwrapped883)) + _t1708 = None + deconstruct_result885 = _t1708 + if deconstruct_result885 is not None: + assert deconstruct_result885 is not None + unwrapped886 = deconstruct_result885 + self.write(self.format_float32_literal(unwrapped886)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1703 = _dollar_dollar.float_value + _t1709 = _dollar_dollar.float_value else: - _t1703 = None - deconstruct_result880 = _t1703 - if deconstruct_result880 is not None: - assert deconstruct_result880 is not None - unwrapped881 = deconstruct_result880 - self.write(str(unwrapped881)) + _t1709 = None + deconstruct_result883 = _t1709 + if deconstruct_result883 is not None: + assert deconstruct_result883 is not None + unwrapped884 = deconstruct_result883 + self.write(str(unwrapped884)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1704 = _dollar_dollar.uint32_value + _t1710 = _dollar_dollar.uint32_value else: - _t1704 = None - deconstruct_result878 = _t1704 - if deconstruct_result878 is not None: - assert deconstruct_result878 is not None - unwrapped879 = deconstruct_result878 - self.write((str(unwrapped879) + 'u32')) + _t1710 = None + deconstruct_result881 = _t1710 + if deconstruct_result881 is not None: + assert deconstruct_result881 is not None + unwrapped882 = deconstruct_result881 + self.write((str(unwrapped882) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1705 = _dollar_dollar.uint128_value + _t1711 = _dollar_dollar.uint128_value else: - _t1705 = None - deconstruct_result876 = _t1705 - if deconstruct_result876 is not None: - assert deconstruct_result876 is not None - unwrapped877 = deconstruct_result876 - self.write(self.format_uint128(unwrapped877)) + _t1711 = None + deconstruct_result879 = _t1711 + if deconstruct_result879 is not None: + assert deconstruct_result879 is not None + unwrapped880 = deconstruct_result879 + self.write(self.format_uint128(unwrapped880)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1706 = _dollar_dollar.int128_value + _t1712 = _dollar_dollar.int128_value else: - _t1706 = None - deconstruct_result874 = _t1706 - if deconstruct_result874 is not None: - assert deconstruct_result874 is not None - unwrapped875 = deconstruct_result874 - self.write(self.format_int128(unwrapped875)) + _t1712 = None + deconstruct_result877 = _t1712 + if deconstruct_result877 is not None: + assert deconstruct_result877 is not None + unwrapped878 = deconstruct_result877 + self.write(self.format_int128(unwrapped878)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1707 = _dollar_dollar.decimal_value + _t1713 = _dollar_dollar.decimal_value else: - _t1707 = None - deconstruct_result872 = _t1707 - if deconstruct_result872 is not None: - assert deconstruct_result872 is not None - unwrapped873 = deconstruct_result872 - self.write(self.format_decimal(unwrapped873)) + _t1713 = None + deconstruct_result875 = _t1713 + if deconstruct_result875 is not None: + assert deconstruct_result875 is not None + unwrapped876 = deconstruct_result875 + self.write(self.format_decimal(unwrapped876)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1708 = _dollar_dollar.boolean_value + _t1714 = _dollar_dollar.boolean_value else: - _t1708 = None - deconstruct_result870 = _t1708 - if deconstruct_result870 is not None: - assert deconstruct_result870 is not None - unwrapped871 = deconstruct_result870 - self.pretty_boolean_value(unwrapped871) + _t1714 = None + deconstruct_result873 = _t1714 + if deconstruct_result873 is not None: + assert deconstruct_result873 is not None + unwrapped874 = deconstruct_result873 + self.pretty_boolean_value(unwrapped874) else: - fields869 = msg + fields872 = msg self.write("missing") def pretty_raw_date(self, msg: logic_pb2.DateValue): - flat900 = self._try_flat(msg, self.pretty_raw_date) - if flat900 is not None: - assert flat900 is not None - self.write(flat900) + flat903 = self._try_flat(msg, self.pretty_raw_date) + if flat903 is not None: + assert flat903 is not None + self.write(flat903) return None else: _dollar_dollar = msg - fields895 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields895 is not None - unwrapped_fields896 = fields895 + fields898 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields898 is not None + unwrapped_fields899 = fields898 self.write("(date") self.indent_sexp() self.newline() - field897 = unwrapped_fields896[0] - self.write(str(field897)) + field900 = unwrapped_fields899[0] + self.write(str(field900)) self.newline() - field898 = unwrapped_fields896[1] - self.write(str(field898)) + field901 = unwrapped_fields899[1] + self.write(str(field901)) self.newline() - field899 = unwrapped_fields896[2] - self.write(str(field899)) + field902 = unwrapped_fields899[2] + self.write(str(field902)) self.dedent() self.write(")") def pretty_raw_datetime(self, msg: logic_pb2.DateTimeValue): - flat911 = self._try_flat(msg, self.pretty_raw_datetime) - if flat911 is not None: - assert flat911 is not None - self.write(flat911) + flat914 = self._try_flat(msg, self.pretty_raw_datetime) + if flat914 is not None: + assert flat914 is not None + self.write(flat914) return None else: _dollar_dollar = msg - fields901 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day), int(_dollar_dollar.hour), int(_dollar_dollar.minute), int(_dollar_dollar.second), int(_dollar_dollar.microsecond),) - assert fields901 is not None - unwrapped_fields902 = fields901 + fields904 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day), int(_dollar_dollar.hour), int(_dollar_dollar.minute), int(_dollar_dollar.second), int(_dollar_dollar.microsecond),) + assert fields904 is not None + unwrapped_fields905 = fields904 self.write("(datetime") self.indent_sexp() self.newline() - field903 = unwrapped_fields902[0] - self.write(str(field903)) - self.newline() - field904 = unwrapped_fields902[1] - self.write(str(field904)) - self.newline() - field905 = unwrapped_fields902[2] - self.write(str(field905)) - self.newline() - field906 = unwrapped_fields902[3] + field906 = unwrapped_fields905[0] self.write(str(field906)) self.newline() - field907 = unwrapped_fields902[4] + field907 = unwrapped_fields905[1] self.write(str(field907)) self.newline() - field908 = unwrapped_fields902[5] + field908 = unwrapped_fields905[2] self.write(str(field908)) - field909 = unwrapped_fields902[6] - if field909 is not None: + self.newline() + field909 = unwrapped_fields905[3] + self.write(str(field909)) + self.newline() + field910 = unwrapped_fields905[4] + self.write(str(field910)) + self.newline() + field911 = unwrapped_fields905[5] + self.write(str(field911)) + field912 = unwrapped_fields905[6] + if field912 is not None: self.newline() - assert field909 is not None - opt_val910 = field909 - self.write(str(opt_val910)) + assert field912 is not None + opt_val913 = field912 + self.write(str(opt_val913)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): _dollar_dollar = msg if _dollar_dollar: - _t1709 = () + _t1715 = () else: - _t1709 = None - deconstruct_result914 = _t1709 - if deconstruct_result914 is not None: - assert deconstruct_result914 is not None - unwrapped915 = deconstruct_result914 + _t1715 = None + deconstruct_result917 = _t1715 + if deconstruct_result917 is not None: + assert deconstruct_result917 is not None + unwrapped918 = deconstruct_result917 self.write("true") else: _dollar_dollar = msg if not _dollar_dollar: - _t1710 = () + _t1716 = () else: - _t1710 = None - deconstruct_result912 = _t1710 - if deconstruct_result912 is not None: - assert deconstruct_result912 is not None - unwrapped913 = deconstruct_result912 + _t1716 = None + deconstruct_result915 = _t1716 + if deconstruct_result915 is not None: + assert deconstruct_result915 is not None + unwrapped916 = deconstruct_result915 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat920 = self._try_flat(msg, self.pretty_sync) - if flat920 is not None: - assert flat920 is not None - self.write(flat920) + flat923 = self._try_flat(msg, self.pretty_sync) + if flat923 is not None: + assert flat923 is not None + self.write(flat923) return None else: _dollar_dollar = msg - fields916 = _dollar_dollar.fragments - assert fields916 is not None - unwrapped_fields917 = fields916 + fields919 = _dollar_dollar.fragments + assert fields919 is not None + unwrapped_fields920 = fields919 self.write("(sync") self.indent_sexp() - if not len(unwrapped_fields917) == 0: + if not len(unwrapped_fields920) == 0: self.newline() - for i919, elem918 in enumerate(unwrapped_fields917): - if (i919 > 0): + for i922, elem921 in enumerate(unwrapped_fields920): + if (i922 > 0): self.newline() - self.pretty_fragment_id(elem918) + self.pretty_fragment_id(elem921) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat923 = self._try_flat(msg, self.pretty_fragment_id) - if flat923 is not None: - assert flat923 is not None - self.write(flat923) + flat926 = self._try_flat(msg, self.pretty_fragment_id) + if flat926 is not None: + assert flat926 is not None + self.write(flat926) return None else: _dollar_dollar = msg - fields921 = self.fragment_id_to_string(_dollar_dollar) - assert fields921 is not None - unwrapped_fields922 = fields921 + fields924 = self.fragment_id_to_string(_dollar_dollar) + assert fields924 is not None + unwrapped_fields925 = fields924 self.write(":") - self.write(unwrapped_fields922) + self.write(unwrapped_fields925) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat930 = self._try_flat(msg, self.pretty_epoch) - if flat930 is not None: - assert flat930 is not None - self.write(flat930) + flat933 = self._try_flat(msg, self.pretty_epoch) + if flat933 is not None: + assert flat933 is not None + self.write(flat933) return None else: _dollar_dollar = msg if not len(_dollar_dollar.writes) == 0: - _t1711 = _dollar_dollar.writes + _t1717 = _dollar_dollar.writes else: - _t1711 = None + _t1717 = None if not len(_dollar_dollar.reads) == 0: - _t1712 = _dollar_dollar.reads + _t1718 = _dollar_dollar.reads else: - _t1712 = None - fields924 = (_t1711, _t1712,) - assert fields924 is not None - unwrapped_fields925 = fields924 + _t1718 = None + fields927 = (_t1717, _t1718,) + assert fields927 is not None + unwrapped_fields928 = fields927 self.write("(epoch") self.indent_sexp() - field926 = unwrapped_fields925[0] - if field926 is not None: + field929 = unwrapped_fields928[0] + if field929 is not None: self.newline() - assert field926 is not None - opt_val927 = field926 - self.pretty_epoch_writes(opt_val927) - field928 = unwrapped_fields925[1] - if field928 is not None: + assert field929 is not None + opt_val930 = field929 + self.pretty_epoch_writes(opt_val930) + field931 = unwrapped_fields928[1] + if field931 is not None: self.newline() - assert field928 is not None - opt_val929 = field928 - self.pretty_epoch_reads(opt_val929) + assert field931 is not None + opt_val932 = field931 + self.pretty_epoch_reads(opt_val932) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat934 = self._try_flat(msg, self.pretty_epoch_writes) - if flat934 is not None: - assert flat934 is not None - self.write(flat934) + flat937 = self._try_flat(msg, self.pretty_epoch_writes) + if flat937 is not None: + assert flat937 is not None + self.write(flat937) return None else: - fields931 = msg + fields934 = msg self.write("(writes") self.indent_sexp() - if not len(fields931) == 0: + if not len(fields934) == 0: self.newline() - for i933, elem932 in enumerate(fields931): - if (i933 > 0): + for i936, elem935 in enumerate(fields934): + if (i936 > 0): self.newline() - self.pretty_write(elem932) + self.pretty_write(elem935) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat943 = self._try_flat(msg, self.pretty_write) - if flat943 is not None: - assert flat943 is not None - self.write(flat943) + flat946 = self._try_flat(msg, self.pretty_write) + if flat946 is not None: + assert flat946 is not None + self.write(flat946) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("define"): - _t1713 = _dollar_dollar.define + _t1719 = _dollar_dollar.define else: - _t1713 = None - deconstruct_result941 = _t1713 - if deconstruct_result941 is not None: - assert deconstruct_result941 is not None - unwrapped942 = deconstruct_result941 - self.pretty_define(unwrapped942) + _t1719 = None + deconstruct_result944 = _t1719 + if deconstruct_result944 is not None: + assert deconstruct_result944 is not None + unwrapped945 = deconstruct_result944 + self.pretty_define(unwrapped945) else: _dollar_dollar = msg if _dollar_dollar.HasField("undefine"): - _t1714 = _dollar_dollar.undefine + _t1720 = _dollar_dollar.undefine else: - _t1714 = None - deconstruct_result939 = _t1714 - if deconstruct_result939 is not None: - assert deconstruct_result939 is not None - unwrapped940 = deconstruct_result939 - self.pretty_undefine(unwrapped940) + _t1720 = None + deconstruct_result942 = _t1720 + if deconstruct_result942 is not None: + assert deconstruct_result942 is not None + unwrapped943 = deconstruct_result942 + self.pretty_undefine(unwrapped943) else: _dollar_dollar = msg if _dollar_dollar.HasField("context"): - _t1715 = _dollar_dollar.context + _t1721 = _dollar_dollar.context else: - _t1715 = None - deconstruct_result937 = _t1715 - if deconstruct_result937 is not None: - assert deconstruct_result937 is not None - unwrapped938 = deconstruct_result937 - self.pretty_context(unwrapped938) + _t1721 = None + deconstruct_result940 = _t1721 + if deconstruct_result940 is not None: + assert deconstruct_result940 is not None + unwrapped941 = deconstruct_result940 + self.pretty_context(unwrapped941) else: _dollar_dollar = msg if _dollar_dollar.HasField("snapshot"): - _t1716 = _dollar_dollar.snapshot + _t1722 = _dollar_dollar.snapshot else: - _t1716 = None - deconstruct_result935 = _t1716 - if deconstruct_result935 is not None: - assert deconstruct_result935 is not None - unwrapped936 = deconstruct_result935 - self.pretty_snapshot(unwrapped936) + _t1722 = None + deconstruct_result938 = _t1722 + if deconstruct_result938 is not None: + assert deconstruct_result938 is not None + unwrapped939 = deconstruct_result938 + self.pretty_snapshot(unwrapped939) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat946 = self._try_flat(msg, self.pretty_define) - if flat946 is not None: - assert flat946 is not None - self.write(flat946) + flat949 = self._try_flat(msg, self.pretty_define) + if flat949 is not None: + assert flat949 is not None + self.write(flat949) return None else: _dollar_dollar = msg - fields944 = _dollar_dollar.fragment - assert fields944 is not None - unwrapped_fields945 = fields944 + fields947 = _dollar_dollar.fragment + assert fields947 is not None + unwrapped_fields948 = fields947 self.write("(define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields945) + self.pretty_fragment(unwrapped_fields948) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat953 = self._try_flat(msg, self.pretty_fragment) - if flat953 is not None: - assert flat953 is not None - self.write(flat953) + flat956 = self._try_flat(msg, self.pretty_fragment) + if flat956 is not None: + assert flat956 is not None + self.write(flat956) return None else: _dollar_dollar = msg self.start_pretty_fragment(_dollar_dollar) - fields947 = (_dollar_dollar.id, _dollar_dollar.declarations,) - assert fields947 is not None - unwrapped_fields948 = fields947 + fields950 = (_dollar_dollar.id, _dollar_dollar.declarations,) + assert fields950 is not None + unwrapped_fields951 = fields950 self.write("(fragment") self.indent_sexp() self.newline() - field949 = unwrapped_fields948[0] - self.pretty_new_fragment_id(field949) - field950 = unwrapped_fields948[1] - if not len(field950) == 0: + field952 = unwrapped_fields951[0] + self.pretty_new_fragment_id(field952) + field953 = unwrapped_fields951[1] + if not len(field953) == 0: self.newline() - for i952, elem951 in enumerate(field950): - if (i952 > 0): + for i955, elem954 in enumerate(field953): + if (i955 > 0): self.newline() - self.pretty_declaration(elem951) + self.pretty_declaration(elem954) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat955 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat955 is not None: - assert flat955 is not None - self.write(flat955) + flat958 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat958 is not None: + assert flat958 is not None + self.write(flat958) return None else: - fields954 = msg - self.pretty_fragment_id(fields954) + fields957 = msg + self.pretty_fragment_id(fields957) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat964 = self._try_flat(msg, self.pretty_declaration) - if flat964 is not None: - assert flat964 is not None - self.write(flat964) + flat967 = self._try_flat(msg, self.pretty_declaration) + if flat967 is not None: + assert flat967 is not None + self.write(flat967) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("def"): - _t1717 = getattr(_dollar_dollar, 'def') + _t1723 = getattr(_dollar_dollar, 'def') else: - _t1717 = None - deconstruct_result962 = _t1717 - if deconstruct_result962 is not None: - assert deconstruct_result962 is not None - unwrapped963 = deconstruct_result962 - self.pretty_def(unwrapped963) + _t1723 = None + deconstruct_result965 = _t1723 + if deconstruct_result965 is not None: + assert deconstruct_result965 is not None + unwrapped966 = deconstruct_result965 + self.pretty_def(unwrapped966) else: _dollar_dollar = msg if _dollar_dollar.HasField("algorithm"): - _t1718 = _dollar_dollar.algorithm + _t1724 = _dollar_dollar.algorithm else: - _t1718 = None - deconstruct_result960 = _t1718 - if deconstruct_result960 is not None: - assert deconstruct_result960 is not None - unwrapped961 = deconstruct_result960 - self.pretty_algorithm(unwrapped961) + _t1724 = None + deconstruct_result963 = _t1724 + if deconstruct_result963 is not None: + assert deconstruct_result963 is not None + unwrapped964 = deconstruct_result963 + self.pretty_algorithm(unwrapped964) else: _dollar_dollar = msg if _dollar_dollar.HasField("constraint"): - _t1719 = _dollar_dollar.constraint + _t1725 = _dollar_dollar.constraint else: - _t1719 = None - deconstruct_result958 = _t1719 - if deconstruct_result958 is not None: - assert deconstruct_result958 is not None - unwrapped959 = deconstruct_result958 - self.pretty_constraint(unwrapped959) + _t1725 = None + deconstruct_result961 = _t1725 + if deconstruct_result961 is not None: + assert deconstruct_result961 is not None + unwrapped962 = deconstruct_result961 + self.pretty_constraint(unwrapped962) else: _dollar_dollar = msg if _dollar_dollar.HasField("data"): - _t1720 = _dollar_dollar.data + _t1726 = _dollar_dollar.data else: - _t1720 = None - deconstruct_result956 = _t1720 - if deconstruct_result956 is not None: - assert deconstruct_result956 is not None - unwrapped957 = deconstruct_result956 - self.pretty_data(unwrapped957) + _t1726 = None + deconstruct_result959 = _t1726 + if deconstruct_result959 is not None: + assert deconstruct_result959 is not None + unwrapped960 = deconstruct_result959 + self.pretty_data(unwrapped960) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat971 = self._try_flat(msg, self.pretty_def) - if flat971 is not None: - assert flat971 is not None - self.write(flat971) + flat974 = self._try_flat(msg, self.pretty_def) + if flat974 is not None: + assert flat974 is not None + self.write(flat974) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1721 = _dollar_dollar.attrs + _t1727 = _dollar_dollar.attrs else: - _t1721 = None - fields965 = (_dollar_dollar.name, _dollar_dollar.body, _t1721,) - assert fields965 is not None - unwrapped_fields966 = fields965 + _t1727 = None + fields968 = (_dollar_dollar.name, _dollar_dollar.body, _t1727,) + assert fields968 is not None + unwrapped_fields969 = fields968 self.write("(def") self.indent_sexp() self.newline() - field967 = unwrapped_fields966[0] - self.pretty_relation_id(field967) + field970 = unwrapped_fields969[0] + self.pretty_relation_id(field970) self.newline() - field968 = unwrapped_fields966[1] - self.pretty_abstraction(field968) - field969 = unwrapped_fields966[2] - if field969 is not None: + field971 = unwrapped_fields969[1] + self.pretty_abstraction(field971) + field972 = unwrapped_fields969[2] + if field972 is not None: self.newline() - assert field969 is not None - opt_val970 = field969 - self.pretty_attrs(opt_val970) + assert field972 is not None + opt_val973 = field972 + self.pretty_attrs(opt_val973) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat976 = self._try_flat(msg, self.pretty_relation_id) - if flat976 is not None: - assert flat976 is not None - self.write(flat976) + flat979 = self._try_flat(msg, self.pretty_relation_id) + if flat979 is not None: + assert flat979 is not None + self.write(flat979) return None else: _dollar_dollar = msg if self.relation_id_to_string(_dollar_dollar) is not None: - _t1723 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1722 = _t1723 + _t1729 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1728 = _t1729 else: - _t1722 = None - deconstruct_result974 = _t1722 - if deconstruct_result974 is not None: - assert deconstruct_result974 is not None - unwrapped975 = deconstruct_result974 + _t1728 = None + deconstruct_result977 = _t1728 + if deconstruct_result977 is not None: + assert deconstruct_result977 is not None + unwrapped978 = deconstruct_result977 self.write(":") - self.write(unwrapped975) + self.write(unwrapped978) else: _dollar_dollar = msg - _t1724 = self.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result972 = _t1724 - if deconstruct_result972 is not None: - assert deconstruct_result972 is not None - unwrapped973 = deconstruct_result972 - self.write(self.format_uint128(unwrapped973)) + _t1730 = self.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result975 = _t1730 + if deconstruct_result975 is not None: + assert deconstruct_result975 is not None + unwrapped976 = deconstruct_result975 + self.write(self.format_uint128(unwrapped976)) else: raise ParseError("No matching rule for relation_id") def pretty_abstraction(self, msg: logic_pb2.Abstraction): - flat981 = self._try_flat(msg, self.pretty_abstraction) - if flat981 is not None: - assert flat981 is not None - self.write(flat981) + flat984 = self._try_flat(msg, self.pretty_abstraction) + if flat984 is not None: + assert flat984 is not None + self.write(flat984) return None else: _dollar_dollar = msg - _t1725 = self.deconstruct_bindings(_dollar_dollar) - fields977 = (_t1725, _dollar_dollar.value,) - assert fields977 is not None - unwrapped_fields978 = fields977 + _t1731 = self.deconstruct_bindings(_dollar_dollar) + fields980 = (_t1731, _dollar_dollar.value,) + assert fields980 is not None + unwrapped_fields981 = fields980 self.write("(") self.indent() - field979 = unwrapped_fields978[0] - self.pretty_bindings(field979) + field982 = unwrapped_fields981[0] + self.pretty_bindings(field982) self.newline() - field980 = unwrapped_fields978[1] - self.pretty_formula(field980) + field983 = unwrapped_fields981[1] + self.pretty_formula(field983) self.dedent() self.write(")") def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): - flat989 = self._try_flat(msg, self.pretty_bindings) - if flat989 is not None: - assert flat989 is not None - self.write(flat989) + flat992 = self._try_flat(msg, self.pretty_bindings) + if flat992 is not None: + assert flat992 is not None + self.write(flat992) return None else: _dollar_dollar = msg if not len(_dollar_dollar[1]) == 0: - _t1726 = _dollar_dollar[1] + _t1732 = _dollar_dollar[1] else: - _t1726 = None - fields982 = (_dollar_dollar[0], _t1726,) - assert fields982 is not None - unwrapped_fields983 = fields982 + _t1732 = None + fields985 = (_dollar_dollar[0], _t1732,) + assert fields985 is not None + unwrapped_fields986 = fields985 self.write("[") self.indent() - field984 = unwrapped_fields983[0] - for i986, elem985 in enumerate(field984): - if (i986 > 0): + field987 = unwrapped_fields986[0] + for i989, elem988 in enumerate(field987): + if (i989 > 0): self.newline() - self.pretty_binding(elem985) - field987 = unwrapped_fields983[1] - if field987 is not None: + self.pretty_binding(elem988) + field990 = unwrapped_fields986[1] + if field990 is not None: self.newline() - assert field987 is not None - opt_val988 = field987 - self.pretty_value_bindings(opt_val988) + assert field990 is not None + opt_val991 = field990 + self.pretty_value_bindings(opt_val991) self.dedent() self.write("]") def pretty_binding(self, msg: logic_pb2.Binding): - flat994 = self._try_flat(msg, self.pretty_binding) - if flat994 is not None: - assert flat994 is not None - self.write(flat994) + flat997 = self._try_flat(msg, self.pretty_binding) + if flat997 is not None: + assert flat997 is not None + self.write(flat997) return None else: _dollar_dollar = msg - fields990 = (_dollar_dollar.var.name, _dollar_dollar.type,) - assert fields990 is not None - unwrapped_fields991 = fields990 - field992 = unwrapped_fields991[0] - self.write(field992) + fields993 = (_dollar_dollar.var.name, _dollar_dollar.type,) + assert fields993 is not None + unwrapped_fields994 = fields993 + field995 = unwrapped_fields994[0] + self.write(field995) self.write("::") - field993 = unwrapped_fields991[1] - self.pretty_type(field993) + field996 = unwrapped_fields994[1] + self.pretty_type(field996) def pretty_type(self, msg: logic_pb2.Type): - flat1023 = self._try_flat(msg, self.pretty_type) - if flat1023 is not None: - assert flat1023 is not None - self.write(flat1023) + flat1026 = self._try_flat(msg, self.pretty_type) + if flat1026 is not None: + assert flat1026 is not None + self.write(flat1026) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("unspecified_type"): - _t1727 = _dollar_dollar.unspecified_type + _t1733 = _dollar_dollar.unspecified_type else: - _t1727 = None - deconstruct_result1021 = _t1727 - if deconstruct_result1021 is not None: - assert deconstruct_result1021 is not None - unwrapped1022 = deconstruct_result1021 - self.pretty_unspecified_type(unwrapped1022) + _t1733 = None + deconstruct_result1024 = _t1733 + if deconstruct_result1024 is not None: + assert deconstruct_result1024 is not None + unwrapped1025 = deconstruct_result1024 + self.pretty_unspecified_type(unwrapped1025) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_type"): - _t1728 = _dollar_dollar.string_type + _t1734 = _dollar_dollar.string_type else: - _t1728 = None - deconstruct_result1019 = _t1728 - if deconstruct_result1019 is not None: - assert deconstruct_result1019 is not None - unwrapped1020 = deconstruct_result1019 - self.pretty_string_type(unwrapped1020) + _t1734 = None + deconstruct_result1022 = _t1734 + if deconstruct_result1022 is not None: + assert deconstruct_result1022 is not None + unwrapped1023 = deconstruct_result1022 + self.pretty_string_type(unwrapped1023) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_type"): - _t1729 = _dollar_dollar.int_type + _t1735 = _dollar_dollar.int_type else: - _t1729 = None - deconstruct_result1017 = _t1729 - if deconstruct_result1017 is not None: - assert deconstruct_result1017 is not None - unwrapped1018 = deconstruct_result1017 - self.pretty_int_type(unwrapped1018) + _t1735 = None + deconstruct_result1020 = _t1735 + if deconstruct_result1020 is not None: + assert deconstruct_result1020 is not None + unwrapped1021 = deconstruct_result1020 + self.pretty_int_type(unwrapped1021) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_type"): - _t1730 = _dollar_dollar.float_type + _t1736 = _dollar_dollar.float_type else: - _t1730 = None - deconstruct_result1015 = _t1730 - if deconstruct_result1015 is not None: - assert deconstruct_result1015 is not None - unwrapped1016 = deconstruct_result1015 - self.pretty_float_type(unwrapped1016) + _t1736 = None + deconstruct_result1018 = _t1736 + if deconstruct_result1018 is not None: + assert deconstruct_result1018 is not None + unwrapped1019 = deconstruct_result1018 + self.pretty_float_type(unwrapped1019) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_type"): - _t1731 = _dollar_dollar.uint128_type + _t1737 = _dollar_dollar.uint128_type else: - _t1731 = None - deconstruct_result1013 = _t1731 - if deconstruct_result1013 is not None: - assert deconstruct_result1013 is not None - unwrapped1014 = deconstruct_result1013 - self.pretty_uint128_type(unwrapped1014) + _t1737 = None + deconstruct_result1016 = _t1737 + if deconstruct_result1016 is not None: + assert deconstruct_result1016 is not None + unwrapped1017 = deconstruct_result1016 + self.pretty_uint128_type(unwrapped1017) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_type"): - _t1732 = _dollar_dollar.int128_type + _t1738 = _dollar_dollar.int128_type else: - _t1732 = None - deconstruct_result1011 = _t1732 - if deconstruct_result1011 is not None: - assert deconstruct_result1011 is not None - unwrapped1012 = deconstruct_result1011 - self.pretty_int128_type(unwrapped1012) + _t1738 = None + deconstruct_result1014 = _t1738 + if deconstruct_result1014 is not None: + assert deconstruct_result1014 is not None + unwrapped1015 = deconstruct_result1014 + self.pretty_int128_type(unwrapped1015) else: _dollar_dollar = msg if _dollar_dollar.HasField("date_type"): - _t1733 = _dollar_dollar.date_type + _t1739 = _dollar_dollar.date_type else: - _t1733 = None - deconstruct_result1009 = _t1733 - if deconstruct_result1009 is not None: - assert deconstruct_result1009 is not None - unwrapped1010 = deconstruct_result1009 - self.pretty_date_type(unwrapped1010) + _t1739 = None + deconstruct_result1012 = _t1739 + if deconstruct_result1012 is not None: + assert deconstruct_result1012 is not None + unwrapped1013 = deconstruct_result1012 + self.pretty_date_type(unwrapped1013) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_type"): - _t1734 = _dollar_dollar.datetime_type + _t1740 = _dollar_dollar.datetime_type else: - _t1734 = None - deconstruct_result1007 = _t1734 - if deconstruct_result1007 is not None: - assert deconstruct_result1007 is not None - unwrapped1008 = deconstruct_result1007 - self.pretty_datetime_type(unwrapped1008) + _t1740 = None + deconstruct_result1010 = _t1740 + if deconstruct_result1010 is not None: + assert deconstruct_result1010 is not None + unwrapped1011 = deconstruct_result1010 + self.pretty_datetime_type(unwrapped1011) else: _dollar_dollar = msg if _dollar_dollar.HasField("missing_type"): - _t1735 = _dollar_dollar.missing_type + _t1741 = _dollar_dollar.missing_type else: - _t1735 = None - deconstruct_result1005 = _t1735 - if deconstruct_result1005 is not None: - assert deconstruct_result1005 is not None - unwrapped1006 = deconstruct_result1005 - self.pretty_missing_type(unwrapped1006) + _t1741 = None + deconstruct_result1008 = _t1741 + if deconstruct_result1008 is not None: + assert deconstruct_result1008 is not None + unwrapped1009 = deconstruct_result1008 + self.pretty_missing_type(unwrapped1009) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_type"): - _t1736 = _dollar_dollar.decimal_type + _t1742 = _dollar_dollar.decimal_type else: - _t1736 = None - deconstruct_result1003 = _t1736 - if deconstruct_result1003 is not None: - assert deconstruct_result1003 is not None - unwrapped1004 = deconstruct_result1003 - self.pretty_decimal_type(unwrapped1004) + _t1742 = None + deconstruct_result1006 = _t1742 + if deconstruct_result1006 is not None: + assert deconstruct_result1006 is not None + unwrapped1007 = deconstruct_result1006 + self.pretty_decimal_type(unwrapped1007) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_type"): - _t1737 = _dollar_dollar.boolean_type + _t1743 = _dollar_dollar.boolean_type else: - _t1737 = None - deconstruct_result1001 = _t1737 - if deconstruct_result1001 is not None: - assert deconstruct_result1001 is not None - unwrapped1002 = deconstruct_result1001 - self.pretty_boolean_type(unwrapped1002) + _t1743 = None + deconstruct_result1004 = _t1743 + if deconstruct_result1004 is not None: + assert deconstruct_result1004 is not None + unwrapped1005 = deconstruct_result1004 + self.pretty_boolean_type(unwrapped1005) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_type"): - _t1738 = _dollar_dollar.int32_type + _t1744 = _dollar_dollar.int32_type else: - _t1738 = None - deconstruct_result999 = _t1738 - if deconstruct_result999 is not None: - assert deconstruct_result999 is not None - unwrapped1000 = deconstruct_result999 - self.pretty_int32_type(unwrapped1000) + _t1744 = None + deconstruct_result1002 = _t1744 + if deconstruct_result1002 is not None: + assert deconstruct_result1002 is not None + unwrapped1003 = deconstruct_result1002 + self.pretty_int32_type(unwrapped1003) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_type"): - _t1739 = _dollar_dollar.float32_type + _t1745 = _dollar_dollar.float32_type else: - _t1739 = None - deconstruct_result997 = _t1739 - if deconstruct_result997 is not None: - assert deconstruct_result997 is not None - unwrapped998 = deconstruct_result997 - self.pretty_float32_type(unwrapped998) + _t1745 = None + deconstruct_result1000 = _t1745 + if deconstruct_result1000 is not None: + assert deconstruct_result1000 is not None + unwrapped1001 = deconstruct_result1000 + self.pretty_float32_type(unwrapped1001) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_type"): - _t1740 = _dollar_dollar.uint32_type + _t1746 = _dollar_dollar.uint32_type else: - _t1740 = None - deconstruct_result995 = _t1740 - if deconstruct_result995 is not None: - assert deconstruct_result995 is not None - unwrapped996 = deconstruct_result995 - self.pretty_uint32_type(unwrapped996) + _t1746 = None + deconstruct_result998 = _t1746 + if deconstruct_result998 is not None: + assert deconstruct_result998 is not None + unwrapped999 = deconstruct_result998 + self.pretty_uint32_type(unwrapped999) else: raise ParseError("No matching rule for type") def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields1024 = msg + fields1027 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields1025 = msg + fields1028 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields1026 = msg + fields1029 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields1027 = msg + fields1030 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields1028 = msg + fields1031 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields1029 = msg + fields1032 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields1030 = msg + fields1033 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields1031 = msg + fields1034 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields1032 = msg + fields1035 = msg self.write("MISSING") def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat1037 = self._try_flat(msg, self.pretty_decimal_type) - if flat1037 is not None: - assert flat1037 is not None - self.write(flat1037) + flat1040 = self._try_flat(msg, self.pretty_decimal_type) + if flat1040 is not None: + assert flat1040 is not None + self.write(flat1040) return None else: _dollar_dollar = msg - fields1033 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - assert fields1033 is not None - unwrapped_fields1034 = fields1033 + fields1036 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) + assert fields1036 is not None + unwrapped_fields1037 = fields1036 self.write("(DECIMAL") self.indent_sexp() self.newline() - field1035 = unwrapped_fields1034[0] - self.write(str(field1035)) + field1038 = unwrapped_fields1037[0] + self.write(str(field1038)) self.newline() - field1036 = unwrapped_fields1034[1] - self.write(str(field1036)) + field1039 = unwrapped_fields1037[1] + self.write(str(field1039)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields1038 = msg + fields1041 = msg self.write("BOOLEAN") def pretty_int32_type(self, msg: logic_pb2.Int32Type): - fields1039 = msg + fields1042 = msg self.write("INT32") def pretty_float32_type(self, msg: logic_pb2.Float32Type): - fields1040 = msg + fields1043 = msg self.write("FLOAT32") def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): - fields1041 = msg + fields1044 = msg self.write("UINT32") def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat1045 = self._try_flat(msg, self.pretty_value_bindings) - if flat1045 is not None: - assert flat1045 is not None - self.write(flat1045) + flat1048 = self._try_flat(msg, self.pretty_value_bindings) + if flat1048 is not None: + assert flat1048 is not None + self.write(flat1048) return None else: - fields1042 = msg + fields1045 = msg self.write("|") - if not len(fields1042) == 0: + if not len(fields1045) == 0: self.write(" ") - for i1044, elem1043 in enumerate(fields1042): - if (i1044 > 0): + for i1047, elem1046 in enumerate(fields1045): + if (i1047 > 0): self.newline() - self.pretty_binding(elem1043) + self.pretty_binding(elem1046) def pretty_formula(self, msg: logic_pb2.Formula): - flat1072 = self._try_flat(msg, self.pretty_formula) - if flat1072 is not None: - assert flat1072 is not None - self.write(flat1072) + flat1075 = self._try_flat(msg, self.pretty_formula) + if flat1075 is not None: + assert flat1075 is not None + self.write(flat1075) return None else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1741 = _dollar_dollar.conjunction + _t1747 = _dollar_dollar.conjunction else: - _t1741 = None - deconstruct_result1070 = _t1741 - if deconstruct_result1070 is not None: - assert deconstruct_result1070 is not None - unwrapped1071 = deconstruct_result1070 - self.pretty_true(unwrapped1071) + _t1747 = None + deconstruct_result1073 = _t1747 + if deconstruct_result1073 is not None: + assert deconstruct_result1073 is not None + unwrapped1074 = deconstruct_result1073 + self.pretty_true(unwrapped1074) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1742 = _dollar_dollar.disjunction + _t1748 = _dollar_dollar.disjunction else: - _t1742 = None - deconstruct_result1068 = _t1742 - if deconstruct_result1068 is not None: - assert deconstruct_result1068 is not None - unwrapped1069 = deconstruct_result1068 - self.pretty_false(unwrapped1069) + _t1748 = None + deconstruct_result1071 = _t1748 + if deconstruct_result1071 is not None: + assert deconstruct_result1071 is not None + unwrapped1072 = deconstruct_result1071 + self.pretty_false(unwrapped1072) else: _dollar_dollar = msg if _dollar_dollar.HasField("exists"): - _t1743 = _dollar_dollar.exists + _t1749 = _dollar_dollar.exists else: - _t1743 = None - deconstruct_result1066 = _t1743 - if deconstruct_result1066 is not None: - assert deconstruct_result1066 is not None - unwrapped1067 = deconstruct_result1066 - self.pretty_exists(unwrapped1067) + _t1749 = None + deconstruct_result1069 = _t1749 + if deconstruct_result1069 is not None: + assert deconstruct_result1069 is not None + unwrapped1070 = deconstruct_result1069 + self.pretty_exists(unwrapped1070) else: _dollar_dollar = msg if _dollar_dollar.HasField("reduce"): - _t1744 = _dollar_dollar.reduce + _t1750 = _dollar_dollar.reduce else: - _t1744 = None - deconstruct_result1064 = _t1744 - if deconstruct_result1064 is not None: - assert deconstruct_result1064 is not None - unwrapped1065 = deconstruct_result1064 - self.pretty_reduce(unwrapped1065) + _t1750 = None + deconstruct_result1067 = _t1750 + if deconstruct_result1067 is not None: + assert deconstruct_result1067 is not None + unwrapped1068 = deconstruct_result1067 + self.pretty_reduce(unwrapped1068) else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1745 = _dollar_dollar.conjunction + _t1751 = _dollar_dollar.conjunction else: - _t1745 = None - deconstruct_result1062 = _t1745 - if deconstruct_result1062 is not None: - assert deconstruct_result1062 is not None - unwrapped1063 = deconstruct_result1062 - self.pretty_conjunction(unwrapped1063) + _t1751 = None + deconstruct_result1065 = _t1751 + if deconstruct_result1065 is not None: + assert deconstruct_result1065 is not None + unwrapped1066 = deconstruct_result1065 + self.pretty_conjunction(unwrapped1066) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1746 = _dollar_dollar.disjunction + _t1752 = _dollar_dollar.disjunction else: - _t1746 = None - deconstruct_result1060 = _t1746 - if deconstruct_result1060 is not None: - assert deconstruct_result1060 is not None - unwrapped1061 = deconstruct_result1060 - self.pretty_disjunction(unwrapped1061) + _t1752 = None + deconstruct_result1063 = _t1752 + if deconstruct_result1063 is not None: + assert deconstruct_result1063 is not None + unwrapped1064 = deconstruct_result1063 + self.pretty_disjunction(unwrapped1064) else: _dollar_dollar = msg if _dollar_dollar.HasField("not"): - _t1747 = getattr(_dollar_dollar, 'not') + _t1753 = getattr(_dollar_dollar, 'not') else: - _t1747 = None - deconstruct_result1058 = _t1747 - if deconstruct_result1058 is not None: - assert deconstruct_result1058 is not None - unwrapped1059 = deconstruct_result1058 - self.pretty_not(unwrapped1059) + _t1753 = None + deconstruct_result1061 = _t1753 + if deconstruct_result1061 is not None: + assert deconstruct_result1061 is not None + unwrapped1062 = deconstruct_result1061 + self.pretty_not(unwrapped1062) else: _dollar_dollar = msg if _dollar_dollar.HasField("ffi"): - _t1748 = _dollar_dollar.ffi + _t1754 = _dollar_dollar.ffi else: - _t1748 = None - deconstruct_result1056 = _t1748 - if deconstruct_result1056 is not None: - assert deconstruct_result1056 is not None - unwrapped1057 = deconstruct_result1056 - self.pretty_ffi(unwrapped1057) + _t1754 = None + deconstruct_result1059 = _t1754 + if deconstruct_result1059 is not None: + assert deconstruct_result1059 is not None + unwrapped1060 = deconstruct_result1059 + self.pretty_ffi(unwrapped1060) else: _dollar_dollar = msg if _dollar_dollar.HasField("atom"): - _t1749 = _dollar_dollar.atom + _t1755 = _dollar_dollar.atom else: - _t1749 = None - deconstruct_result1054 = _t1749 - if deconstruct_result1054 is not None: - assert deconstruct_result1054 is not None - unwrapped1055 = deconstruct_result1054 - self.pretty_atom(unwrapped1055) + _t1755 = None + deconstruct_result1057 = _t1755 + if deconstruct_result1057 is not None: + assert deconstruct_result1057 is not None + unwrapped1058 = deconstruct_result1057 + self.pretty_atom(unwrapped1058) else: _dollar_dollar = msg if _dollar_dollar.HasField("pragma"): - _t1750 = _dollar_dollar.pragma + _t1756 = _dollar_dollar.pragma else: - _t1750 = None - deconstruct_result1052 = _t1750 - if deconstruct_result1052 is not None: - assert deconstruct_result1052 is not None - unwrapped1053 = deconstruct_result1052 - self.pretty_pragma(unwrapped1053) + _t1756 = None + deconstruct_result1055 = _t1756 + if deconstruct_result1055 is not None: + assert deconstruct_result1055 is not None + unwrapped1056 = deconstruct_result1055 + self.pretty_pragma(unwrapped1056) else: _dollar_dollar = msg if _dollar_dollar.HasField("primitive"): - _t1751 = _dollar_dollar.primitive + _t1757 = _dollar_dollar.primitive else: - _t1751 = None - deconstruct_result1050 = _t1751 - if deconstruct_result1050 is not None: - assert deconstruct_result1050 is not None - unwrapped1051 = deconstruct_result1050 - self.pretty_primitive(unwrapped1051) + _t1757 = None + deconstruct_result1053 = _t1757 + if deconstruct_result1053 is not None: + assert deconstruct_result1053 is not None + unwrapped1054 = deconstruct_result1053 + self.pretty_primitive(unwrapped1054) else: _dollar_dollar = msg if _dollar_dollar.HasField("rel_atom"): - _t1752 = _dollar_dollar.rel_atom + _t1758 = _dollar_dollar.rel_atom else: - _t1752 = None - deconstruct_result1048 = _t1752 - if deconstruct_result1048 is not None: - assert deconstruct_result1048 is not None - unwrapped1049 = deconstruct_result1048 - self.pretty_rel_atom(unwrapped1049) + _t1758 = None + deconstruct_result1051 = _t1758 + if deconstruct_result1051 is not None: + assert deconstruct_result1051 is not None + unwrapped1052 = deconstruct_result1051 + self.pretty_rel_atom(unwrapped1052) else: _dollar_dollar = msg if _dollar_dollar.HasField("cast"): - _t1753 = _dollar_dollar.cast + _t1759 = _dollar_dollar.cast else: - _t1753 = None - deconstruct_result1046 = _t1753 - if deconstruct_result1046 is not None: - assert deconstruct_result1046 is not None - unwrapped1047 = deconstruct_result1046 - self.pretty_cast(unwrapped1047) + _t1759 = None + deconstruct_result1049 = _t1759 + if deconstruct_result1049 is not None: + assert deconstruct_result1049 is not None + unwrapped1050 = deconstruct_result1049 + self.pretty_cast(unwrapped1050) else: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields1073 = msg + fields1076 = msg self.write("(true)") def pretty_false(self, msg: logic_pb2.Disjunction): - fields1074 = msg + fields1077 = msg self.write("(false)") def pretty_exists(self, msg: logic_pb2.Exists): - flat1079 = self._try_flat(msg, self.pretty_exists) - if flat1079 is not None: - assert flat1079 is not None - self.write(flat1079) + flat1082 = self._try_flat(msg, self.pretty_exists) + if flat1082 is not None: + assert flat1082 is not None + self.write(flat1082) return None else: _dollar_dollar = msg - _t1754 = self.deconstruct_bindings(_dollar_dollar.body) - fields1075 = (_t1754, _dollar_dollar.body.value,) - assert fields1075 is not None - unwrapped_fields1076 = fields1075 + _t1760 = self.deconstruct_bindings(_dollar_dollar.body) + fields1078 = (_t1760, _dollar_dollar.body.value,) + assert fields1078 is not None + unwrapped_fields1079 = fields1078 self.write("(exists") self.indent_sexp() self.newline() - field1077 = unwrapped_fields1076[0] - self.pretty_bindings(field1077) + field1080 = unwrapped_fields1079[0] + self.pretty_bindings(field1080) self.newline() - field1078 = unwrapped_fields1076[1] - self.pretty_formula(field1078) + field1081 = unwrapped_fields1079[1] + self.pretty_formula(field1081) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat1085 = self._try_flat(msg, self.pretty_reduce) - if flat1085 is not None: - assert flat1085 is not None - self.write(flat1085) + flat1088 = self._try_flat(msg, self.pretty_reduce) + if flat1088 is not None: + assert flat1088 is not None + self.write(flat1088) return None else: _dollar_dollar = msg - fields1080 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - assert fields1080 is not None - unwrapped_fields1081 = fields1080 + fields1083 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + assert fields1083 is not None + unwrapped_fields1084 = fields1083 self.write("(reduce") self.indent_sexp() self.newline() - field1082 = unwrapped_fields1081[0] - self.pretty_abstraction(field1082) + field1085 = unwrapped_fields1084[0] + self.pretty_abstraction(field1085) self.newline() - field1083 = unwrapped_fields1081[1] - self.pretty_abstraction(field1083) + field1086 = unwrapped_fields1084[1] + self.pretty_abstraction(field1086) self.newline() - field1084 = unwrapped_fields1081[2] - self.pretty_terms(field1084) + field1087 = unwrapped_fields1084[2] + self.pretty_terms(field1087) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat1089 = self._try_flat(msg, self.pretty_terms) - if flat1089 is not None: - assert flat1089 is not None - self.write(flat1089) + flat1092 = self._try_flat(msg, self.pretty_terms) + if flat1092 is not None: + assert flat1092 is not None + self.write(flat1092) return None else: - fields1086 = msg + fields1089 = msg self.write("(terms") self.indent_sexp() - if not len(fields1086) == 0: + if not len(fields1089) == 0: self.newline() - for i1088, elem1087 in enumerate(fields1086): - if (i1088 > 0): + for i1091, elem1090 in enumerate(fields1089): + if (i1091 > 0): self.newline() - self.pretty_term(elem1087) + self.pretty_term(elem1090) self.dedent() self.write(")") def pretty_term(self, msg: logic_pb2.Term): - flat1094 = self._try_flat(msg, self.pretty_term) - if flat1094 is not None: - assert flat1094 is not None - self.write(flat1094) + flat1097 = self._try_flat(msg, self.pretty_term) + if flat1097 is not None: + assert flat1097 is not None + self.write(flat1097) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("var"): - _t1755 = _dollar_dollar.var + _t1761 = _dollar_dollar.var else: - _t1755 = None - deconstruct_result1092 = _t1755 - if deconstruct_result1092 is not None: - assert deconstruct_result1092 is not None - unwrapped1093 = deconstruct_result1092 - self.pretty_var(unwrapped1093) + _t1761 = None + deconstruct_result1095 = _t1761 + if deconstruct_result1095 is not None: + assert deconstruct_result1095 is not None + unwrapped1096 = deconstruct_result1095 + self.pretty_var(unwrapped1096) else: _dollar_dollar = msg if _dollar_dollar.HasField("constant"): - _t1756 = _dollar_dollar.constant + _t1762 = _dollar_dollar.constant else: - _t1756 = None - deconstruct_result1090 = _t1756 - if deconstruct_result1090 is not None: - assert deconstruct_result1090 is not None - unwrapped1091 = deconstruct_result1090 - self.pretty_value(unwrapped1091) + _t1762 = None + deconstruct_result1093 = _t1762 + if deconstruct_result1093 is not None: + assert deconstruct_result1093 is not None + unwrapped1094 = deconstruct_result1093 + self.pretty_value(unwrapped1094) else: raise ParseError("No matching rule for term") def pretty_var(self, msg: logic_pb2.Var): - flat1097 = self._try_flat(msg, self.pretty_var) - if flat1097 is not None: - assert flat1097 is not None - self.write(flat1097) + flat1100 = self._try_flat(msg, self.pretty_var) + if flat1100 is not None: + assert flat1100 is not None + self.write(flat1100) return None else: _dollar_dollar = msg - fields1095 = _dollar_dollar.name - assert fields1095 is not None - unwrapped_fields1096 = fields1095 - self.write(unwrapped_fields1096) + fields1098 = _dollar_dollar.name + assert fields1098 is not None + unwrapped_fields1099 = fields1098 + self.write(unwrapped_fields1099) def pretty_value(self, msg: logic_pb2.Value): - flat1123 = self._try_flat(msg, self.pretty_value) - if flat1123 is not None: - assert flat1123 is not None - self.write(flat1123) + flat1126 = self._try_flat(msg, self.pretty_value) + if flat1126 is not None: + assert flat1126 is not None + self.write(flat1126) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1757 = _dollar_dollar.date_value + _t1763 = _dollar_dollar.date_value else: - _t1757 = None - deconstruct_result1121 = _t1757 - if deconstruct_result1121 is not None: - assert deconstruct_result1121 is not None - unwrapped1122 = deconstruct_result1121 - self.pretty_date(unwrapped1122) + _t1763 = None + deconstruct_result1124 = _t1763 + if deconstruct_result1124 is not None: + assert deconstruct_result1124 is not None + unwrapped1125 = deconstruct_result1124 + self.pretty_date(unwrapped1125) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1758 = _dollar_dollar.datetime_value + _t1764 = _dollar_dollar.datetime_value else: - _t1758 = None - deconstruct_result1119 = _t1758 - if deconstruct_result1119 is not None: - assert deconstruct_result1119 is not None - unwrapped1120 = deconstruct_result1119 - self.pretty_datetime(unwrapped1120) + _t1764 = None + deconstruct_result1122 = _t1764 + if deconstruct_result1122 is not None: + assert deconstruct_result1122 is not None + unwrapped1123 = deconstruct_result1122 + self.pretty_datetime(unwrapped1123) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1759 = _dollar_dollar.string_value + _t1765 = _dollar_dollar.string_value else: - _t1759 = None - deconstruct_result1117 = _t1759 - if deconstruct_result1117 is not None: - assert deconstruct_result1117 is not None - unwrapped1118 = deconstruct_result1117 - self.write(self.format_string_value(unwrapped1118)) + _t1765 = None + deconstruct_result1120 = _t1765 + if deconstruct_result1120 is not None: + assert deconstruct_result1120 is not None + unwrapped1121 = deconstruct_result1120 + self.write(self.format_string_value(unwrapped1121)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1760 = _dollar_dollar.int32_value + _t1766 = _dollar_dollar.int32_value else: - _t1760 = None - deconstruct_result1115 = _t1760 - if deconstruct_result1115 is not None: - assert deconstruct_result1115 is not None - unwrapped1116 = deconstruct_result1115 - self.write((str(unwrapped1116) + 'i32')) + _t1766 = None + deconstruct_result1118 = _t1766 + if deconstruct_result1118 is not None: + assert deconstruct_result1118 is not None + unwrapped1119 = deconstruct_result1118 + self.write((str(unwrapped1119) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1761 = _dollar_dollar.int_value + _t1767 = _dollar_dollar.int_value else: - _t1761 = None - deconstruct_result1113 = _t1761 - if deconstruct_result1113 is not None: - assert deconstruct_result1113 is not None - unwrapped1114 = deconstruct_result1113 - self.write(str(unwrapped1114)) + _t1767 = None + deconstruct_result1116 = _t1767 + if deconstruct_result1116 is not None: + assert deconstruct_result1116 is not None + unwrapped1117 = deconstruct_result1116 + self.write(str(unwrapped1117)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1762 = _dollar_dollar.float32_value + _t1768 = _dollar_dollar.float32_value else: - _t1762 = None - deconstruct_result1111 = _t1762 - if deconstruct_result1111 is not None: - assert deconstruct_result1111 is not None - unwrapped1112 = deconstruct_result1111 - self.write(self.format_float32_literal(unwrapped1112)) + _t1768 = None + deconstruct_result1114 = _t1768 + if deconstruct_result1114 is not None: + assert deconstruct_result1114 is not None + unwrapped1115 = deconstruct_result1114 + self.write(self.format_float32_literal(unwrapped1115)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1763 = _dollar_dollar.float_value + _t1769 = _dollar_dollar.float_value else: - _t1763 = None - deconstruct_result1109 = _t1763 - if deconstruct_result1109 is not None: - assert deconstruct_result1109 is not None - unwrapped1110 = deconstruct_result1109 - self.write(str(unwrapped1110)) + _t1769 = None + deconstruct_result1112 = _t1769 + if deconstruct_result1112 is not None: + assert deconstruct_result1112 is not None + unwrapped1113 = deconstruct_result1112 + self.write(str(unwrapped1113)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1764 = _dollar_dollar.uint32_value + _t1770 = _dollar_dollar.uint32_value else: - _t1764 = None - deconstruct_result1107 = _t1764 - if deconstruct_result1107 is not None: - assert deconstruct_result1107 is not None - unwrapped1108 = deconstruct_result1107 - self.write((str(unwrapped1108) + 'u32')) + _t1770 = None + deconstruct_result1110 = _t1770 + if deconstruct_result1110 is not None: + assert deconstruct_result1110 is not None + unwrapped1111 = deconstruct_result1110 + self.write((str(unwrapped1111) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1765 = _dollar_dollar.uint128_value + _t1771 = _dollar_dollar.uint128_value else: - _t1765 = None - deconstruct_result1105 = _t1765 - if deconstruct_result1105 is not None: - assert deconstruct_result1105 is not None - unwrapped1106 = deconstruct_result1105 - self.write(self.format_uint128(unwrapped1106)) + _t1771 = None + deconstruct_result1108 = _t1771 + if deconstruct_result1108 is not None: + assert deconstruct_result1108 is not None + unwrapped1109 = deconstruct_result1108 + self.write(self.format_uint128(unwrapped1109)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1766 = _dollar_dollar.int128_value + _t1772 = _dollar_dollar.int128_value else: - _t1766 = None - deconstruct_result1103 = _t1766 - if deconstruct_result1103 is not None: - assert deconstruct_result1103 is not None - unwrapped1104 = deconstruct_result1103 - self.write(self.format_int128(unwrapped1104)) + _t1772 = None + deconstruct_result1106 = _t1772 + if deconstruct_result1106 is not None: + assert deconstruct_result1106 is not None + unwrapped1107 = deconstruct_result1106 + self.write(self.format_int128(unwrapped1107)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1767 = _dollar_dollar.decimal_value + _t1773 = _dollar_dollar.decimal_value else: - _t1767 = None - deconstruct_result1101 = _t1767 - if deconstruct_result1101 is not None: - assert deconstruct_result1101 is not None - unwrapped1102 = deconstruct_result1101 - self.write(self.format_decimal(unwrapped1102)) + _t1773 = None + deconstruct_result1104 = _t1773 + if deconstruct_result1104 is not None: + assert deconstruct_result1104 is not None + unwrapped1105 = deconstruct_result1104 + self.write(self.format_decimal(unwrapped1105)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1768 = _dollar_dollar.boolean_value + _t1774 = _dollar_dollar.boolean_value else: - _t1768 = None - deconstruct_result1099 = _t1768 - if deconstruct_result1099 is not None: - assert deconstruct_result1099 is not None - unwrapped1100 = deconstruct_result1099 - self.pretty_boolean_value(unwrapped1100) + _t1774 = None + deconstruct_result1102 = _t1774 + if deconstruct_result1102 is not None: + assert deconstruct_result1102 is not None + unwrapped1103 = deconstruct_result1102 + self.pretty_boolean_value(unwrapped1103) else: - fields1098 = msg + fields1101 = msg self.write("missing") def pretty_date(self, msg: logic_pb2.DateValue): - flat1129 = self._try_flat(msg, self.pretty_date) - if flat1129 is not None: - assert flat1129 is not None - self.write(flat1129) + flat1132 = self._try_flat(msg, self.pretty_date) + if flat1132 is not None: + assert flat1132 is not None + self.write(flat1132) return None else: _dollar_dollar = msg - fields1124 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields1124 is not None - unwrapped_fields1125 = fields1124 + fields1127 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields1127 is not None + unwrapped_fields1128 = fields1127 self.write("(date") self.indent_sexp() self.newline() - field1126 = unwrapped_fields1125[0] - self.write(str(field1126)) + field1129 = unwrapped_fields1128[0] + self.write(str(field1129)) self.newline() - field1127 = unwrapped_fields1125[1] - self.write(str(field1127)) + field1130 = unwrapped_fields1128[1] + self.write(str(field1130)) self.newline() - field1128 = unwrapped_fields1125[2] - self.write(str(field1128)) + field1131 = unwrapped_fields1128[2] + self.write(str(field1131)) self.dedent() self.write(")") def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat1140 = self._try_flat(msg, self.pretty_datetime) - if flat1140 is not None: - assert flat1140 is not None - self.write(flat1140) + flat1143 = self._try_flat(msg, self.pretty_datetime) + if flat1143 is not None: + assert flat1143 is not None + self.write(flat1143) return None else: _dollar_dollar = msg - fields1130 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day), int(_dollar_dollar.hour), int(_dollar_dollar.minute), int(_dollar_dollar.second), int(_dollar_dollar.microsecond),) - assert fields1130 is not None - unwrapped_fields1131 = fields1130 + fields1133 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day), int(_dollar_dollar.hour), int(_dollar_dollar.minute), int(_dollar_dollar.second), int(_dollar_dollar.microsecond),) + assert fields1133 is not None + unwrapped_fields1134 = fields1133 self.write("(datetime") self.indent_sexp() self.newline() - field1132 = unwrapped_fields1131[0] - self.write(str(field1132)) - self.newline() - field1133 = unwrapped_fields1131[1] - self.write(str(field1133)) - self.newline() - field1134 = unwrapped_fields1131[2] - self.write(str(field1134)) - self.newline() - field1135 = unwrapped_fields1131[3] + field1135 = unwrapped_fields1134[0] self.write(str(field1135)) self.newline() - field1136 = unwrapped_fields1131[4] + field1136 = unwrapped_fields1134[1] self.write(str(field1136)) self.newline() - field1137 = unwrapped_fields1131[5] + field1137 = unwrapped_fields1134[2] self.write(str(field1137)) - field1138 = unwrapped_fields1131[6] - if field1138 is not None: + self.newline() + field1138 = unwrapped_fields1134[3] + self.write(str(field1138)) + self.newline() + field1139 = unwrapped_fields1134[4] + self.write(str(field1139)) + self.newline() + field1140 = unwrapped_fields1134[5] + self.write(str(field1140)) + field1141 = unwrapped_fields1134[6] + if field1141 is not None: self.newline() - assert field1138 is not None - opt_val1139 = field1138 - self.write(str(opt_val1139)) + assert field1141 is not None + opt_val1142 = field1141 + self.write(str(opt_val1142)) self.dedent() self.write(")") def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat1145 = self._try_flat(msg, self.pretty_conjunction) - if flat1145 is not None: - assert flat1145 is not None - self.write(flat1145) + flat1148 = self._try_flat(msg, self.pretty_conjunction) + if flat1148 is not None: + assert flat1148 is not None + self.write(flat1148) return None else: _dollar_dollar = msg - fields1141 = _dollar_dollar.args - assert fields1141 is not None - unwrapped_fields1142 = fields1141 + fields1144 = _dollar_dollar.args + assert fields1144 is not None + unwrapped_fields1145 = fields1144 self.write("(and") self.indent_sexp() - if not len(unwrapped_fields1142) == 0: + if not len(unwrapped_fields1145) == 0: self.newline() - for i1144, elem1143 in enumerate(unwrapped_fields1142): - if (i1144 > 0): + for i1147, elem1146 in enumerate(unwrapped_fields1145): + if (i1147 > 0): self.newline() - self.pretty_formula(elem1143) + self.pretty_formula(elem1146) self.dedent() self.write(")") def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat1150 = self._try_flat(msg, self.pretty_disjunction) - if flat1150 is not None: - assert flat1150 is not None - self.write(flat1150) + flat1153 = self._try_flat(msg, self.pretty_disjunction) + if flat1153 is not None: + assert flat1153 is not None + self.write(flat1153) return None else: _dollar_dollar = msg - fields1146 = _dollar_dollar.args - assert fields1146 is not None - unwrapped_fields1147 = fields1146 + fields1149 = _dollar_dollar.args + assert fields1149 is not None + unwrapped_fields1150 = fields1149 self.write("(or") self.indent_sexp() - if not len(unwrapped_fields1147) == 0: + if not len(unwrapped_fields1150) == 0: self.newline() - for i1149, elem1148 in enumerate(unwrapped_fields1147): - if (i1149 > 0): + for i1152, elem1151 in enumerate(unwrapped_fields1150): + if (i1152 > 0): self.newline() - self.pretty_formula(elem1148) + self.pretty_formula(elem1151) self.dedent() self.write(")") def pretty_not(self, msg: logic_pb2.Not): - flat1153 = self._try_flat(msg, self.pretty_not) - if flat1153 is not None: - assert flat1153 is not None - self.write(flat1153) + flat1156 = self._try_flat(msg, self.pretty_not) + if flat1156 is not None: + assert flat1156 is not None + self.write(flat1156) return None else: _dollar_dollar = msg - fields1151 = _dollar_dollar.arg - assert fields1151 is not None - unwrapped_fields1152 = fields1151 + fields1154 = _dollar_dollar.arg + assert fields1154 is not None + unwrapped_fields1155 = fields1154 self.write("(not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields1152) + self.pretty_formula(unwrapped_fields1155) self.dedent() self.write(")") def pretty_ffi(self, msg: logic_pb2.FFI): - flat1159 = self._try_flat(msg, self.pretty_ffi) - if flat1159 is not None: - assert flat1159 is not None - self.write(flat1159) + flat1162 = self._try_flat(msg, self.pretty_ffi) + if flat1162 is not None: + assert flat1162 is not None + self.write(flat1162) return None else: _dollar_dollar = msg - fields1154 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - assert fields1154 is not None - unwrapped_fields1155 = fields1154 + fields1157 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + assert fields1157 is not None + unwrapped_fields1158 = fields1157 self.write("(ffi") self.indent_sexp() self.newline() - field1156 = unwrapped_fields1155[0] - self.pretty_name(field1156) + field1159 = unwrapped_fields1158[0] + self.pretty_name(field1159) self.newline() - field1157 = unwrapped_fields1155[1] - self.pretty_ffi_args(field1157) + field1160 = unwrapped_fields1158[1] + self.pretty_ffi_args(field1160) self.newline() - field1158 = unwrapped_fields1155[2] - self.pretty_terms(field1158) + field1161 = unwrapped_fields1158[2] + self.pretty_terms(field1161) self.dedent() self.write(")") def pretty_name(self, msg: str): - flat1161 = self._try_flat(msg, self.pretty_name) - if flat1161 is not None: - assert flat1161 is not None - self.write(flat1161) + flat1164 = self._try_flat(msg, self.pretty_name) + if flat1164 is not None: + assert flat1164 is not None + self.write(flat1164) return None else: - fields1160 = msg + fields1163 = msg self.write(":") - self.write(fields1160) + self.write(fields1163) def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat1165 = self._try_flat(msg, self.pretty_ffi_args) - if flat1165 is not None: - assert flat1165 is not None - self.write(flat1165) + flat1168 = self._try_flat(msg, self.pretty_ffi_args) + if flat1168 is not None: + assert flat1168 is not None + self.write(flat1168) return None else: - fields1162 = msg + fields1165 = msg self.write("(args") self.indent_sexp() - if not len(fields1162) == 0: + if not len(fields1165) == 0: self.newline() - for i1164, elem1163 in enumerate(fields1162): - if (i1164 > 0): + for i1167, elem1166 in enumerate(fields1165): + if (i1167 > 0): self.newline() - self.pretty_abstraction(elem1163) + self.pretty_abstraction(elem1166) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat1172 = self._try_flat(msg, self.pretty_atom) - if flat1172 is not None: - assert flat1172 is not None - self.write(flat1172) + flat1175 = self._try_flat(msg, self.pretty_atom) + if flat1175 is not None: + assert flat1175 is not None + self.write(flat1175) return None else: _dollar_dollar = msg - fields1166 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1166 is not None - unwrapped_fields1167 = fields1166 + fields1169 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1169 is not None + unwrapped_fields1170 = fields1169 self.write("(atom") self.indent_sexp() self.newline() - field1168 = unwrapped_fields1167[0] - self.pretty_relation_id(field1168) - field1169 = unwrapped_fields1167[1] - if not len(field1169) == 0: + field1171 = unwrapped_fields1170[0] + self.pretty_relation_id(field1171) + field1172 = unwrapped_fields1170[1] + if not len(field1172) == 0: self.newline() - for i1171, elem1170 in enumerate(field1169): - if (i1171 > 0): + for i1174, elem1173 in enumerate(field1172): + if (i1174 > 0): self.newline() - self.pretty_term(elem1170) + self.pretty_term(elem1173) self.dedent() self.write(")") def pretty_pragma(self, msg: logic_pb2.Pragma): - flat1179 = self._try_flat(msg, self.pretty_pragma) - if flat1179 is not None: - assert flat1179 is not None - self.write(flat1179) + flat1182 = self._try_flat(msg, self.pretty_pragma) + if flat1182 is not None: + assert flat1182 is not None + self.write(flat1182) return None else: _dollar_dollar = msg - fields1173 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1173 is not None - unwrapped_fields1174 = fields1173 + fields1176 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1176 is not None + unwrapped_fields1177 = fields1176 self.write("(pragma") self.indent_sexp() self.newline() - field1175 = unwrapped_fields1174[0] - self.pretty_name(field1175) - field1176 = unwrapped_fields1174[1] - if not len(field1176) == 0: + field1178 = unwrapped_fields1177[0] + self.pretty_name(field1178) + field1179 = unwrapped_fields1177[1] + if not len(field1179) == 0: self.newline() - for i1178, elem1177 in enumerate(field1176): - if (i1178 > 0): + for i1181, elem1180 in enumerate(field1179): + if (i1181 > 0): self.newline() - self.pretty_term(elem1177) + self.pretty_term(elem1180) self.dedent() self.write(")") def pretty_primitive(self, msg: logic_pb2.Primitive): - flat1195 = self._try_flat(msg, self.pretty_primitive) - if flat1195 is not None: - assert flat1195 is not None - self.write(flat1195) + flat1198 = self._try_flat(msg, self.pretty_primitive) + if flat1198 is not None: + assert flat1198 is not None + self.write(flat1198) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1769 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1775 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1769 = None - guard_result1194 = _t1769 - if guard_result1194 is not None: + _t1775 = None + guard_result1197 = _t1775 + if guard_result1197 is not None: self.pretty_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1770 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1776 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1770 = None - guard_result1193 = _t1770 - if guard_result1193 is not None: + _t1776 = None + guard_result1196 = _t1776 + if guard_result1196 is not None: self.pretty_lt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1771 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1777 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1771 = None - guard_result1192 = _t1771 - if guard_result1192 is not None: + _t1777 = None + guard_result1195 = _t1777 + if guard_result1195 is not None: self.pretty_lt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1772 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1778 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1772 = None - guard_result1191 = _t1772 - if guard_result1191 is not None: + _t1778 = None + guard_result1194 = _t1778 + if guard_result1194 is not None: self.pretty_gt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1773 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1779 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1773 = None - guard_result1190 = _t1773 - if guard_result1190 is not None: + _t1779 = None + guard_result1193 = _t1779 + if guard_result1193 is not None: self.pretty_gt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1774 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1780 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1774 = None - guard_result1189 = _t1774 - if guard_result1189 is not None: + _t1780 = None + guard_result1192 = _t1780 + if guard_result1192 is not None: self.pretty_add(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1775 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1781 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1775 = None - guard_result1188 = _t1775 - if guard_result1188 is not None: + _t1781 = None + guard_result1191 = _t1781 + if guard_result1191 is not None: self.pretty_minus(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1776 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1782 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1776 = None - guard_result1187 = _t1776 - if guard_result1187 is not None: + _t1782 = None + guard_result1190 = _t1782 + if guard_result1190 is not None: self.pretty_multiply(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1777 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1783 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1777 = None - guard_result1186 = _t1777 - if guard_result1186 is not None: + _t1783 = None + guard_result1189 = _t1783 + if guard_result1189 is not None: self.pretty_divide(msg) else: _dollar_dollar = msg - fields1180 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1180 is not None - unwrapped_fields1181 = fields1180 + fields1183 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1183 is not None + unwrapped_fields1184 = fields1183 self.write("(primitive") self.indent_sexp() self.newline() - field1182 = unwrapped_fields1181[0] - self.pretty_name(field1182) - field1183 = unwrapped_fields1181[1] - if not len(field1183) == 0: + field1185 = unwrapped_fields1184[0] + self.pretty_name(field1185) + field1186 = unwrapped_fields1184[1] + if not len(field1186) == 0: self.newline() - for i1185, elem1184 in enumerate(field1183): - if (i1185 > 0): + for i1188, elem1187 in enumerate(field1186): + if (i1188 > 0): self.newline() - self.pretty_rel_term(elem1184) + self.pretty_rel_term(elem1187) self.dedent() self.write(")") def pretty_eq(self, msg: logic_pb2.Primitive): - flat1200 = self._try_flat(msg, self.pretty_eq) - if flat1200 is not None: - assert flat1200 is not None - self.write(flat1200) + flat1203 = self._try_flat(msg, self.pretty_eq) + if flat1203 is not None: + assert flat1203 is not None + self.write(flat1203) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1778 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1784 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1778 = None - fields1196 = _t1778 - assert fields1196 is not None - unwrapped_fields1197 = fields1196 + _t1784 = None + fields1199 = _t1784 + assert fields1199 is not None + unwrapped_fields1200 = fields1199 self.write("(=") self.indent_sexp() self.newline() - field1198 = unwrapped_fields1197[0] - self.pretty_term(field1198) + field1201 = unwrapped_fields1200[0] + self.pretty_term(field1201) self.newline() - field1199 = unwrapped_fields1197[1] - self.pretty_term(field1199) + field1202 = unwrapped_fields1200[1] + self.pretty_term(field1202) self.dedent() self.write(")") def pretty_lt(self, msg: logic_pb2.Primitive): - flat1205 = self._try_flat(msg, self.pretty_lt) - if flat1205 is not None: - assert flat1205 is not None - self.write(flat1205) + flat1208 = self._try_flat(msg, self.pretty_lt) + if flat1208 is not None: + assert flat1208 is not None + self.write(flat1208) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1779 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1785 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1779 = None - fields1201 = _t1779 - assert fields1201 is not None - unwrapped_fields1202 = fields1201 + _t1785 = None + fields1204 = _t1785 + assert fields1204 is not None + unwrapped_fields1205 = fields1204 self.write("(<") self.indent_sexp() self.newline() - field1203 = unwrapped_fields1202[0] - self.pretty_term(field1203) + field1206 = unwrapped_fields1205[0] + self.pretty_term(field1206) self.newline() - field1204 = unwrapped_fields1202[1] - self.pretty_term(field1204) + field1207 = unwrapped_fields1205[1] + self.pretty_term(field1207) self.dedent() self.write(")") def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat1210 = self._try_flat(msg, self.pretty_lt_eq) - if flat1210 is not None: - assert flat1210 is not None - self.write(flat1210) + flat1213 = self._try_flat(msg, self.pretty_lt_eq) + if flat1213 is not None: + assert flat1213 is not None + self.write(flat1213) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1780 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1786 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1780 = None - fields1206 = _t1780 - assert fields1206 is not None - unwrapped_fields1207 = fields1206 + _t1786 = None + fields1209 = _t1786 + assert fields1209 is not None + unwrapped_fields1210 = fields1209 self.write("(<=") self.indent_sexp() self.newline() - field1208 = unwrapped_fields1207[0] - self.pretty_term(field1208) + field1211 = unwrapped_fields1210[0] + self.pretty_term(field1211) self.newline() - field1209 = unwrapped_fields1207[1] - self.pretty_term(field1209) + field1212 = unwrapped_fields1210[1] + self.pretty_term(field1212) self.dedent() self.write(")") def pretty_gt(self, msg: logic_pb2.Primitive): - flat1215 = self._try_flat(msg, self.pretty_gt) - if flat1215 is not None: - assert flat1215 is not None - self.write(flat1215) + flat1218 = self._try_flat(msg, self.pretty_gt) + if flat1218 is not None: + assert flat1218 is not None + self.write(flat1218) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1781 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1787 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1781 = None - fields1211 = _t1781 - assert fields1211 is not None - unwrapped_fields1212 = fields1211 + _t1787 = None + fields1214 = _t1787 + assert fields1214 is not None + unwrapped_fields1215 = fields1214 self.write("(>") self.indent_sexp() self.newline() - field1213 = unwrapped_fields1212[0] - self.pretty_term(field1213) + field1216 = unwrapped_fields1215[0] + self.pretty_term(field1216) self.newline() - field1214 = unwrapped_fields1212[1] - self.pretty_term(field1214) + field1217 = unwrapped_fields1215[1] + self.pretty_term(field1217) self.dedent() self.write(")") def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat1220 = self._try_flat(msg, self.pretty_gt_eq) - if flat1220 is not None: - assert flat1220 is not None - self.write(flat1220) + flat1223 = self._try_flat(msg, self.pretty_gt_eq) + if flat1223 is not None: + assert flat1223 is not None + self.write(flat1223) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1782 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1788 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1782 = None - fields1216 = _t1782 - assert fields1216 is not None - unwrapped_fields1217 = fields1216 + _t1788 = None + fields1219 = _t1788 + assert fields1219 is not None + unwrapped_fields1220 = fields1219 self.write("(>=") self.indent_sexp() self.newline() - field1218 = unwrapped_fields1217[0] - self.pretty_term(field1218) + field1221 = unwrapped_fields1220[0] + self.pretty_term(field1221) self.newline() - field1219 = unwrapped_fields1217[1] - self.pretty_term(field1219) + field1222 = unwrapped_fields1220[1] + self.pretty_term(field1222) self.dedent() self.write(")") def pretty_add(self, msg: logic_pb2.Primitive): - flat1226 = self._try_flat(msg, self.pretty_add) - if flat1226 is not None: - assert flat1226 is not None - self.write(flat1226) + flat1229 = self._try_flat(msg, self.pretty_add) + if flat1229 is not None: + assert flat1229 is not None + self.write(flat1229) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1783 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1789 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1783 = None - fields1221 = _t1783 - assert fields1221 is not None - unwrapped_fields1222 = fields1221 + _t1789 = None + fields1224 = _t1789 + assert fields1224 is not None + unwrapped_fields1225 = fields1224 self.write("(+") self.indent_sexp() self.newline() - field1223 = unwrapped_fields1222[0] - self.pretty_term(field1223) + field1226 = unwrapped_fields1225[0] + self.pretty_term(field1226) self.newline() - field1224 = unwrapped_fields1222[1] - self.pretty_term(field1224) + field1227 = unwrapped_fields1225[1] + self.pretty_term(field1227) self.newline() - field1225 = unwrapped_fields1222[2] - self.pretty_term(field1225) + field1228 = unwrapped_fields1225[2] + self.pretty_term(field1228) self.dedent() self.write(")") def pretty_minus(self, msg: logic_pb2.Primitive): - flat1232 = self._try_flat(msg, self.pretty_minus) - if flat1232 is not None: - assert flat1232 is not None - self.write(flat1232) + flat1235 = self._try_flat(msg, self.pretty_minus) + if flat1235 is not None: + assert flat1235 is not None + self.write(flat1235) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1784 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1790 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1784 = None - fields1227 = _t1784 - assert fields1227 is not None - unwrapped_fields1228 = fields1227 + _t1790 = None + fields1230 = _t1790 + assert fields1230 is not None + unwrapped_fields1231 = fields1230 self.write("(-") self.indent_sexp() self.newline() - field1229 = unwrapped_fields1228[0] - self.pretty_term(field1229) + field1232 = unwrapped_fields1231[0] + self.pretty_term(field1232) self.newline() - field1230 = unwrapped_fields1228[1] - self.pretty_term(field1230) + field1233 = unwrapped_fields1231[1] + self.pretty_term(field1233) self.newline() - field1231 = unwrapped_fields1228[2] - self.pretty_term(field1231) + field1234 = unwrapped_fields1231[2] + self.pretty_term(field1234) self.dedent() self.write(")") def pretty_multiply(self, msg: logic_pb2.Primitive): - flat1238 = self._try_flat(msg, self.pretty_multiply) - if flat1238 is not None: - assert flat1238 is not None - self.write(flat1238) + flat1241 = self._try_flat(msg, self.pretty_multiply) + if flat1241 is not None: + assert flat1241 is not None + self.write(flat1241) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1785 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1791 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1785 = None - fields1233 = _t1785 - assert fields1233 is not None - unwrapped_fields1234 = fields1233 + _t1791 = None + fields1236 = _t1791 + assert fields1236 is not None + unwrapped_fields1237 = fields1236 self.write("(*") self.indent_sexp() self.newline() - field1235 = unwrapped_fields1234[0] - self.pretty_term(field1235) + field1238 = unwrapped_fields1237[0] + self.pretty_term(field1238) self.newline() - field1236 = unwrapped_fields1234[1] - self.pretty_term(field1236) + field1239 = unwrapped_fields1237[1] + self.pretty_term(field1239) self.newline() - field1237 = unwrapped_fields1234[2] - self.pretty_term(field1237) + field1240 = unwrapped_fields1237[2] + self.pretty_term(field1240) self.dedent() self.write(")") def pretty_divide(self, msg: logic_pb2.Primitive): - flat1244 = self._try_flat(msg, self.pretty_divide) - if flat1244 is not None: - assert flat1244 is not None - self.write(flat1244) + flat1247 = self._try_flat(msg, self.pretty_divide) + if flat1247 is not None: + assert flat1247 is not None + self.write(flat1247) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1786 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1792 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1786 = None - fields1239 = _t1786 - assert fields1239 is not None - unwrapped_fields1240 = fields1239 + _t1792 = None + fields1242 = _t1792 + assert fields1242 is not None + unwrapped_fields1243 = fields1242 self.write("(/") self.indent_sexp() self.newline() - field1241 = unwrapped_fields1240[0] - self.pretty_term(field1241) + field1244 = unwrapped_fields1243[0] + self.pretty_term(field1244) self.newline() - field1242 = unwrapped_fields1240[1] - self.pretty_term(field1242) + field1245 = unwrapped_fields1243[1] + self.pretty_term(field1245) self.newline() - field1243 = unwrapped_fields1240[2] - self.pretty_term(field1243) + field1246 = unwrapped_fields1243[2] + self.pretty_term(field1246) self.dedent() self.write(")") def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat1249 = self._try_flat(msg, self.pretty_rel_term) - if flat1249 is not None: - assert flat1249 is not None - self.write(flat1249) + flat1252 = self._try_flat(msg, self.pretty_rel_term) + if flat1252 is not None: + assert flat1252 is not None + self.write(flat1252) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("specialized_value"): - _t1787 = _dollar_dollar.specialized_value + _t1793 = _dollar_dollar.specialized_value else: - _t1787 = None - deconstruct_result1247 = _t1787 - if deconstruct_result1247 is not None: - assert deconstruct_result1247 is not None - unwrapped1248 = deconstruct_result1247 - self.pretty_specialized_value(unwrapped1248) + _t1793 = None + deconstruct_result1250 = _t1793 + if deconstruct_result1250 is not None: + assert deconstruct_result1250 is not None + unwrapped1251 = deconstruct_result1250 + self.pretty_specialized_value(unwrapped1251) else: _dollar_dollar = msg if _dollar_dollar.HasField("term"): - _t1788 = _dollar_dollar.term + _t1794 = _dollar_dollar.term else: - _t1788 = None - deconstruct_result1245 = _t1788 - if deconstruct_result1245 is not None: - assert deconstruct_result1245 is not None - unwrapped1246 = deconstruct_result1245 - self.pretty_term(unwrapped1246) + _t1794 = None + deconstruct_result1248 = _t1794 + if deconstruct_result1248 is not None: + assert deconstruct_result1248 is not None + unwrapped1249 = deconstruct_result1248 + self.pretty_term(unwrapped1249) else: raise ParseError("No matching rule for rel_term") def pretty_specialized_value(self, msg: logic_pb2.Value): - flat1251 = self._try_flat(msg, self.pretty_specialized_value) - if flat1251 is not None: - assert flat1251 is not None - self.write(flat1251) + flat1254 = self._try_flat(msg, self.pretty_specialized_value) + if flat1254 is not None: + assert flat1254 is not None + self.write(flat1254) return None else: - fields1250 = msg + fields1253 = msg self.write("#") - self.pretty_raw_value(fields1250) + self.pretty_raw_value(fields1253) def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat1258 = self._try_flat(msg, self.pretty_rel_atom) - if flat1258 is not None: - assert flat1258 is not None - self.write(flat1258) + flat1261 = self._try_flat(msg, self.pretty_rel_atom) + if flat1261 is not None: + assert flat1261 is not None + self.write(flat1261) return None else: _dollar_dollar = msg - fields1252 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1252 is not None - unwrapped_fields1253 = fields1252 + fields1255 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1255 is not None + unwrapped_fields1256 = fields1255 self.write("(relatom") self.indent_sexp() self.newline() - field1254 = unwrapped_fields1253[0] - self.pretty_name(field1254) - field1255 = unwrapped_fields1253[1] - if not len(field1255) == 0: + field1257 = unwrapped_fields1256[0] + self.pretty_name(field1257) + field1258 = unwrapped_fields1256[1] + if not len(field1258) == 0: self.newline() - for i1257, elem1256 in enumerate(field1255): - if (i1257 > 0): + for i1260, elem1259 in enumerate(field1258): + if (i1260 > 0): self.newline() - self.pretty_rel_term(elem1256) + self.pretty_rel_term(elem1259) self.dedent() self.write(")") def pretty_cast(self, msg: logic_pb2.Cast): - flat1263 = self._try_flat(msg, self.pretty_cast) - if flat1263 is not None: - assert flat1263 is not None - self.write(flat1263) + flat1266 = self._try_flat(msg, self.pretty_cast) + if flat1266 is not None: + assert flat1266 is not None + self.write(flat1266) return None else: _dollar_dollar = msg - fields1259 = (_dollar_dollar.input, _dollar_dollar.result,) - assert fields1259 is not None - unwrapped_fields1260 = fields1259 + fields1262 = (_dollar_dollar.input, _dollar_dollar.result,) + assert fields1262 is not None + unwrapped_fields1263 = fields1262 self.write("(cast") self.indent_sexp() self.newline() - field1261 = unwrapped_fields1260[0] - self.pretty_term(field1261) + field1264 = unwrapped_fields1263[0] + self.pretty_term(field1264) self.newline() - field1262 = unwrapped_fields1260[1] - self.pretty_term(field1262) + field1265 = unwrapped_fields1263[1] + self.pretty_term(field1265) self.dedent() self.write(")") def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1267 = self._try_flat(msg, self.pretty_attrs) - if flat1267 is not None: - assert flat1267 is not None - self.write(flat1267) + flat1270 = self._try_flat(msg, self.pretty_attrs) + if flat1270 is not None: + assert flat1270 is not None + self.write(flat1270) return None else: - fields1264 = msg + fields1267 = msg self.write("(attrs") self.indent_sexp() - if not len(fields1264) == 0: + if not len(fields1267) == 0: self.newline() - for i1266, elem1265 in enumerate(fields1264): - if (i1266 > 0): + for i1269, elem1268 in enumerate(fields1267): + if (i1269 > 0): self.newline() - self.pretty_attribute(elem1265) + self.pretty_attribute(elem1268) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1274 = self._try_flat(msg, self.pretty_attribute) - if flat1274 is not None: - assert flat1274 is not None - self.write(flat1274) + flat1277 = self._try_flat(msg, self.pretty_attribute) + if flat1277 is not None: + assert flat1277 is not None + self.write(flat1277) return None else: _dollar_dollar = msg - fields1268 = (_dollar_dollar.name, _dollar_dollar.args,) - assert fields1268 is not None - unwrapped_fields1269 = fields1268 + fields1271 = (_dollar_dollar.name, _dollar_dollar.args,) + assert fields1271 is not None + unwrapped_fields1272 = fields1271 self.write("(attribute") self.indent_sexp() self.newline() - field1270 = unwrapped_fields1269[0] - self.pretty_name(field1270) - field1271 = unwrapped_fields1269[1] - if not len(field1271) == 0: + field1273 = unwrapped_fields1272[0] + self.pretty_name(field1273) + field1274 = unwrapped_fields1272[1] + if not len(field1274) == 0: self.newline() - for i1273, elem1272 in enumerate(field1271): - if (i1273 > 0): + for i1276, elem1275 in enumerate(field1274): + if (i1276 > 0): self.newline() - self.pretty_raw_value(elem1272) + self.pretty_raw_value(elem1275) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1283 = self._try_flat(msg, self.pretty_algorithm) - if flat1283 is not None: - assert flat1283 is not None - self.write(flat1283) + flat1286 = self._try_flat(msg, self.pretty_algorithm) + if flat1286 is not None: + assert flat1286 is not None + self.write(flat1286) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1789 = _dollar_dollar.attrs + _t1795 = _dollar_dollar.attrs else: - _t1789 = None - fields1275 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1789,) - assert fields1275 is not None - unwrapped_fields1276 = fields1275 + _t1795 = None + fields1278 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1795,) + assert fields1278 is not None + unwrapped_fields1279 = fields1278 self.write("(algorithm") self.indent_sexp() - field1277 = unwrapped_fields1276[0] - if not len(field1277) == 0: + field1280 = unwrapped_fields1279[0] + if not len(field1280) == 0: self.newline() - for i1279, elem1278 in enumerate(field1277): - if (i1279 > 0): + for i1282, elem1281 in enumerate(field1280): + if (i1282 > 0): self.newline() - self.pretty_relation_id(elem1278) + self.pretty_relation_id(elem1281) self.newline() - field1280 = unwrapped_fields1276[1] - self.pretty_script(field1280) - field1281 = unwrapped_fields1276[2] - if field1281 is not None: + field1283 = unwrapped_fields1279[1] + self.pretty_script(field1283) + field1284 = unwrapped_fields1279[2] + if field1284 is not None: self.newline() - assert field1281 is not None - opt_val1282 = field1281 - self.pretty_attrs(opt_val1282) + assert field1284 is not None + opt_val1285 = field1284 + self.pretty_attrs(opt_val1285) self.dedent() self.write(")") def pretty_script(self, msg: logic_pb2.Script): - flat1288 = self._try_flat(msg, self.pretty_script) - if flat1288 is not None: - assert flat1288 is not None - self.write(flat1288) + flat1291 = self._try_flat(msg, self.pretty_script) + if flat1291 is not None: + assert flat1291 is not None + self.write(flat1291) return None else: _dollar_dollar = msg - fields1284 = _dollar_dollar.constructs - assert fields1284 is not None - unwrapped_fields1285 = fields1284 + fields1287 = _dollar_dollar.constructs + assert fields1287 is not None + unwrapped_fields1288 = fields1287 self.write("(script") self.indent_sexp() - if not len(unwrapped_fields1285) == 0: + if not len(unwrapped_fields1288) == 0: self.newline() - for i1287, elem1286 in enumerate(unwrapped_fields1285): - if (i1287 > 0): + for i1290, elem1289 in enumerate(unwrapped_fields1288): + if (i1290 > 0): self.newline() - self.pretty_construct(elem1286) + self.pretty_construct(elem1289) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1293 = self._try_flat(msg, self.pretty_construct) - if flat1293 is not None: - assert flat1293 is not None - self.write(flat1293) + flat1296 = self._try_flat(msg, self.pretty_construct) + if flat1296 is not None: + assert flat1296 is not None + self.write(flat1296) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("loop"): - _t1790 = _dollar_dollar.loop + _t1796 = _dollar_dollar.loop else: - _t1790 = None - deconstruct_result1291 = _t1790 - if deconstruct_result1291 is not None: - assert deconstruct_result1291 is not None - unwrapped1292 = deconstruct_result1291 - self.pretty_loop(unwrapped1292) + _t1796 = None + deconstruct_result1294 = _t1796 + if deconstruct_result1294 is not None: + assert deconstruct_result1294 is not None + unwrapped1295 = deconstruct_result1294 + self.pretty_loop(unwrapped1295) else: _dollar_dollar = msg if _dollar_dollar.HasField("instruction"): - _t1791 = _dollar_dollar.instruction + _t1797 = _dollar_dollar.instruction else: - _t1791 = None - deconstruct_result1289 = _t1791 - if deconstruct_result1289 is not None: - assert deconstruct_result1289 is not None - unwrapped1290 = deconstruct_result1289 - self.pretty_instruction(unwrapped1290) + _t1797 = None + deconstruct_result1292 = _t1797 + if deconstruct_result1292 is not None: + assert deconstruct_result1292 is not None + unwrapped1293 = deconstruct_result1292 + self.pretty_instruction(unwrapped1293) else: raise ParseError("No matching rule for construct") def pretty_loop(self, msg: logic_pb2.Loop): - flat1300 = self._try_flat(msg, self.pretty_loop) - if flat1300 is not None: - assert flat1300 is not None - self.write(flat1300) + flat1303 = self._try_flat(msg, self.pretty_loop) + if flat1303 is not None: + assert flat1303 is not None + self.write(flat1303) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1792 = _dollar_dollar.attrs + _t1798 = _dollar_dollar.attrs else: - _t1792 = None - fields1294 = (_dollar_dollar.init, _dollar_dollar.body, _t1792,) - assert fields1294 is not None - unwrapped_fields1295 = fields1294 + _t1798 = None + fields1297 = (_dollar_dollar.init, _dollar_dollar.body, _t1798,) + assert fields1297 is not None + unwrapped_fields1298 = fields1297 self.write("(loop") self.indent_sexp() self.newline() - field1296 = unwrapped_fields1295[0] - self.pretty_init(field1296) + field1299 = unwrapped_fields1298[0] + self.pretty_init(field1299) self.newline() - field1297 = unwrapped_fields1295[1] - self.pretty_script(field1297) - field1298 = unwrapped_fields1295[2] - if field1298 is not None: + field1300 = unwrapped_fields1298[1] + self.pretty_script(field1300) + field1301 = unwrapped_fields1298[2] + if field1301 is not None: self.newline() - assert field1298 is not None - opt_val1299 = field1298 - self.pretty_attrs(opt_val1299) + assert field1301 is not None + opt_val1302 = field1301 + self.pretty_attrs(opt_val1302) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1304 = self._try_flat(msg, self.pretty_init) - if flat1304 is not None: - assert flat1304 is not None - self.write(flat1304) + flat1307 = self._try_flat(msg, self.pretty_init) + if flat1307 is not None: + assert flat1307 is not None + self.write(flat1307) return None else: - fields1301 = msg + fields1304 = msg self.write("(init") self.indent_sexp() - if not len(fields1301) == 0: + if not len(fields1304) == 0: self.newline() - for i1303, elem1302 in enumerate(fields1301): - if (i1303 > 0): + for i1306, elem1305 in enumerate(fields1304): + if (i1306 > 0): self.newline() - self.pretty_instruction(elem1302) + self.pretty_instruction(elem1305) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1315 = self._try_flat(msg, self.pretty_instruction) - if flat1315 is not None: - assert flat1315 is not None - self.write(flat1315) + flat1318 = self._try_flat(msg, self.pretty_instruction) + if flat1318 is not None: + assert flat1318 is not None + self.write(flat1318) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("assign"): - _t1793 = _dollar_dollar.assign + _t1799 = _dollar_dollar.assign else: - _t1793 = None - deconstruct_result1313 = _t1793 - if deconstruct_result1313 is not None: - assert deconstruct_result1313 is not None - unwrapped1314 = deconstruct_result1313 - self.pretty_assign(unwrapped1314) + _t1799 = None + deconstruct_result1316 = _t1799 + if deconstruct_result1316 is not None: + assert deconstruct_result1316 is not None + unwrapped1317 = deconstruct_result1316 + self.pretty_assign(unwrapped1317) else: _dollar_dollar = msg if _dollar_dollar.HasField("upsert"): - _t1794 = _dollar_dollar.upsert + _t1800 = _dollar_dollar.upsert else: - _t1794 = None - deconstruct_result1311 = _t1794 - if deconstruct_result1311 is not None: - assert deconstruct_result1311 is not None - unwrapped1312 = deconstruct_result1311 - self.pretty_upsert(unwrapped1312) + _t1800 = None + deconstruct_result1314 = _t1800 + if deconstruct_result1314 is not None: + assert deconstruct_result1314 is not None + unwrapped1315 = deconstruct_result1314 + self.pretty_upsert(unwrapped1315) else: _dollar_dollar = msg if _dollar_dollar.HasField("break"): - _t1795 = getattr(_dollar_dollar, 'break') + _t1801 = getattr(_dollar_dollar, 'break') else: - _t1795 = None - deconstruct_result1309 = _t1795 - if deconstruct_result1309 is not None: - assert deconstruct_result1309 is not None - unwrapped1310 = deconstruct_result1309 - self.pretty_break(unwrapped1310) + _t1801 = None + deconstruct_result1312 = _t1801 + if deconstruct_result1312 is not None: + assert deconstruct_result1312 is not None + unwrapped1313 = deconstruct_result1312 + self.pretty_break(unwrapped1313) else: _dollar_dollar = msg if _dollar_dollar.HasField("monoid_def"): - _t1796 = _dollar_dollar.monoid_def + _t1802 = _dollar_dollar.monoid_def else: - _t1796 = None - deconstruct_result1307 = _t1796 - if deconstruct_result1307 is not None: - assert deconstruct_result1307 is not None - unwrapped1308 = deconstruct_result1307 - self.pretty_monoid_def(unwrapped1308) + _t1802 = None + deconstruct_result1310 = _t1802 + if deconstruct_result1310 is not None: + assert deconstruct_result1310 is not None + unwrapped1311 = deconstruct_result1310 + self.pretty_monoid_def(unwrapped1311) else: _dollar_dollar = msg if _dollar_dollar.HasField("monus_def"): - _t1797 = _dollar_dollar.monus_def + _t1803 = _dollar_dollar.monus_def else: - _t1797 = None - deconstruct_result1305 = _t1797 - if deconstruct_result1305 is not None: - assert deconstruct_result1305 is not None - unwrapped1306 = deconstruct_result1305 - self.pretty_monus_def(unwrapped1306) + _t1803 = None + deconstruct_result1308 = _t1803 + if deconstruct_result1308 is not None: + assert deconstruct_result1308 is not None + unwrapped1309 = deconstruct_result1308 + self.pretty_monus_def(unwrapped1309) else: raise ParseError("No matching rule for instruction") def pretty_assign(self, msg: logic_pb2.Assign): - flat1322 = self._try_flat(msg, self.pretty_assign) - if flat1322 is not None: - assert flat1322 is not None - self.write(flat1322) + flat1325 = self._try_flat(msg, self.pretty_assign) + if flat1325 is not None: + assert flat1325 is not None + self.write(flat1325) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1798 = _dollar_dollar.attrs + _t1804 = _dollar_dollar.attrs else: - _t1798 = None - fields1316 = (_dollar_dollar.name, _dollar_dollar.body, _t1798,) - assert fields1316 is not None - unwrapped_fields1317 = fields1316 + _t1804 = None + fields1319 = (_dollar_dollar.name, _dollar_dollar.body, _t1804,) + assert fields1319 is not None + unwrapped_fields1320 = fields1319 self.write("(assign") self.indent_sexp() self.newline() - field1318 = unwrapped_fields1317[0] - self.pretty_relation_id(field1318) + field1321 = unwrapped_fields1320[0] + self.pretty_relation_id(field1321) self.newline() - field1319 = unwrapped_fields1317[1] - self.pretty_abstraction(field1319) - field1320 = unwrapped_fields1317[2] - if field1320 is not None: + field1322 = unwrapped_fields1320[1] + self.pretty_abstraction(field1322) + field1323 = unwrapped_fields1320[2] + if field1323 is not None: self.newline() - assert field1320 is not None - opt_val1321 = field1320 - self.pretty_attrs(opt_val1321) + assert field1323 is not None + opt_val1324 = field1323 + self.pretty_attrs(opt_val1324) self.dedent() self.write(")") def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1329 = self._try_flat(msg, self.pretty_upsert) - if flat1329 is not None: - assert flat1329 is not None - self.write(flat1329) + flat1332 = self._try_flat(msg, self.pretty_upsert) + if flat1332 is not None: + assert flat1332 is not None + self.write(flat1332) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1799 = _dollar_dollar.attrs + _t1805 = _dollar_dollar.attrs else: - _t1799 = None - fields1323 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1799,) - assert fields1323 is not None - unwrapped_fields1324 = fields1323 + _t1805 = None + fields1326 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1805,) + assert fields1326 is not None + unwrapped_fields1327 = fields1326 self.write("(upsert") self.indent_sexp() self.newline() - field1325 = unwrapped_fields1324[0] - self.pretty_relation_id(field1325) + field1328 = unwrapped_fields1327[0] + self.pretty_relation_id(field1328) self.newline() - field1326 = unwrapped_fields1324[1] - self.pretty_abstraction_with_arity(field1326) - field1327 = unwrapped_fields1324[2] - if field1327 is not None: + field1329 = unwrapped_fields1327[1] + self.pretty_abstraction_with_arity(field1329) + field1330 = unwrapped_fields1327[2] + if field1330 is not None: self.newline() - assert field1327 is not None - opt_val1328 = field1327 - self.pretty_attrs(opt_val1328) + assert field1330 is not None + opt_val1331 = field1330 + self.pretty_attrs(opt_val1331) self.dedent() self.write(")") def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1334 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1334 is not None: - assert flat1334 is not None - self.write(flat1334) + flat1337 = self._try_flat(msg, self.pretty_abstraction_with_arity) + if flat1337 is not None: + assert flat1337 is not None + self.write(flat1337) return None else: _dollar_dollar = msg - _t1800 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - fields1330 = (_t1800, _dollar_dollar[0].value,) - assert fields1330 is not None - unwrapped_fields1331 = fields1330 + _t1806 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) + fields1333 = (_t1806, _dollar_dollar[0].value,) + assert fields1333 is not None + unwrapped_fields1334 = fields1333 self.write("(") self.indent() - field1332 = unwrapped_fields1331[0] - self.pretty_bindings(field1332) + field1335 = unwrapped_fields1334[0] + self.pretty_bindings(field1335) self.newline() - field1333 = unwrapped_fields1331[1] - self.pretty_formula(field1333) + field1336 = unwrapped_fields1334[1] + self.pretty_formula(field1336) self.dedent() self.write(")") def pretty_break(self, msg: logic_pb2.Break): - flat1341 = self._try_flat(msg, self.pretty_break) - if flat1341 is not None: - assert flat1341 is not None - self.write(flat1341) + flat1344 = self._try_flat(msg, self.pretty_break) + if flat1344 is not None: + assert flat1344 is not None + self.write(flat1344) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1801 = _dollar_dollar.attrs + _t1807 = _dollar_dollar.attrs else: - _t1801 = None - fields1335 = (_dollar_dollar.name, _dollar_dollar.body, _t1801,) - assert fields1335 is not None - unwrapped_fields1336 = fields1335 + _t1807 = None + fields1338 = (_dollar_dollar.name, _dollar_dollar.body, _t1807,) + assert fields1338 is not None + unwrapped_fields1339 = fields1338 self.write("(break") self.indent_sexp() self.newline() - field1337 = unwrapped_fields1336[0] - self.pretty_relation_id(field1337) + field1340 = unwrapped_fields1339[0] + self.pretty_relation_id(field1340) self.newline() - field1338 = unwrapped_fields1336[1] - self.pretty_abstraction(field1338) - field1339 = unwrapped_fields1336[2] - if field1339 is not None: + field1341 = unwrapped_fields1339[1] + self.pretty_abstraction(field1341) + field1342 = unwrapped_fields1339[2] + if field1342 is not None: self.newline() - assert field1339 is not None - opt_val1340 = field1339 - self.pretty_attrs(opt_val1340) + assert field1342 is not None + opt_val1343 = field1342 + self.pretty_attrs(opt_val1343) self.dedent() self.write(")") def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1349 = self._try_flat(msg, self.pretty_monoid_def) - if flat1349 is not None: - assert flat1349 is not None - self.write(flat1349) + flat1352 = self._try_flat(msg, self.pretty_monoid_def) + if flat1352 is not None: + assert flat1352 is not None + self.write(flat1352) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1802 = _dollar_dollar.attrs + _t1808 = _dollar_dollar.attrs else: - _t1802 = None - fields1342 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1802,) - assert fields1342 is not None - unwrapped_fields1343 = fields1342 + _t1808 = None + fields1345 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1808,) + assert fields1345 is not None + unwrapped_fields1346 = fields1345 self.write("(monoid") self.indent_sexp() self.newline() - field1344 = unwrapped_fields1343[0] - self.pretty_monoid(field1344) + field1347 = unwrapped_fields1346[0] + self.pretty_monoid(field1347) self.newline() - field1345 = unwrapped_fields1343[1] - self.pretty_relation_id(field1345) + field1348 = unwrapped_fields1346[1] + self.pretty_relation_id(field1348) self.newline() - field1346 = unwrapped_fields1343[2] - self.pretty_abstraction_with_arity(field1346) - field1347 = unwrapped_fields1343[3] - if field1347 is not None: + field1349 = unwrapped_fields1346[2] + self.pretty_abstraction_with_arity(field1349) + field1350 = unwrapped_fields1346[3] + if field1350 is not None: self.newline() - assert field1347 is not None - opt_val1348 = field1347 - self.pretty_attrs(opt_val1348) + assert field1350 is not None + opt_val1351 = field1350 + self.pretty_attrs(opt_val1351) self.dedent() self.write(")") def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1358 = self._try_flat(msg, self.pretty_monoid) - if flat1358 is not None: - assert flat1358 is not None - self.write(flat1358) + flat1361 = self._try_flat(msg, self.pretty_monoid) + if flat1361 is not None: + assert flat1361 is not None + self.write(flat1361) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("or_monoid"): - _t1803 = _dollar_dollar.or_monoid + _t1809 = _dollar_dollar.or_monoid else: - _t1803 = None - deconstruct_result1356 = _t1803 - if deconstruct_result1356 is not None: - assert deconstruct_result1356 is not None - unwrapped1357 = deconstruct_result1356 - self.pretty_or_monoid(unwrapped1357) + _t1809 = None + deconstruct_result1359 = _t1809 + if deconstruct_result1359 is not None: + assert deconstruct_result1359 is not None + unwrapped1360 = deconstruct_result1359 + self.pretty_or_monoid(unwrapped1360) else: _dollar_dollar = msg if _dollar_dollar.HasField("min_monoid"): - _t1804 = _dollar_dollar.min_monoid + _t1810 = _dollar_dollar.min_monoid else: - _t1804 = None - deconstruct_result1354 = _t1804 - if deconstruct_result1354 is not None: - assert deconstruct_result1354 is not None - unwrapped1355 = deconstruct_result1354 - self.pretty_min_monoid(unwrapped1355) + _t1810 = None + deconstruct_result1357 = _t1810 + if deconstruct_result1357 is not None: + assert deconstruct_result1357 is not None + unwrapped1358 = deconstruct_result1357 + self.pretty_min_monoid(unwrapped1358) else: _dollar_dollar = msg if _dollar_dollar.HasField("max_monoid"): - _t1805 = _dollar_dollar.max_monoid + _t1811 = _dollar_dollar.max_monoid else: - _t1805 = None - deconstruct_result1352 = _t1805 - if deconstruct_result1352 is not None: - assert deconstruct_result1352 is not None - unwrapped1353 = deconstruct_result1352 - self.pretty_max_monoid(unwrapped1353) + _t1811 = None + deconstruct_result1355 = _t1811 + if deconstruct_result1355 is not None: + assert deconstruct_result1355 is not None + unwrapped1356 = deconstruct_result1355 + self.pretty_max_monoid(unwrapped1356) else: _dollar_dollar = msg if _dollar_dollar.HasField("sum_monoid"): - _t1806 = _dollar_dollar.sum_monoid + _t1812 = _dollar_dollar.sum_monoid else: - _t1806 = None - deconstruct_result1350 = _t1806 - if deconstruct_result1350 is not None: - assert deconstruct_result1350 is not None - unwrapped1351 = deconstruct_result1350 - self.pretty_sum_monoid(unwrapped1351) + _t1812 = None + deconstruct_result1353 = _t1812 + if deconstruct_result1353 is not None: + assert deconstruct_result1353 is not None + unwrapped1354 = deconstruct_result1353 + self.pretty_sum_monoid(unwrapped1354) else: raise ParseError("No matching rule for monoid") def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1359 = msg + fields1362 = msg self.write("(or)") def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1362 = self._try_flat(msg, self.pretty_min_monoid) - if flat1362 is not None: - assert flat1362 is not None - self.write(flat1362) - return None - else: - _dollar_dollar = msg - fields1360 = _dollar_dollar.type - assert fields1360 is not None - unwrapped_fields1361 = fields1360 - self.write("(min") - self.indent_sexp() - self.newline() - self.pretty_type(unwrapped_fields1361) - self.dedent() - self.write(")") - - def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1365 = self._try_flat(msg, self.pretty_max_monoid) + flat1365 = self._try_flat(msg, self.pretty_min_monoid) if flat1365 is not None: assert flat1365 is not None self.write(flat1365) @@ -3011,15 +2996,15 @@ def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): fields1363 = _dollar_dollar.type assert fields1363 is not None unwrapped_fields1364 = fields1363 - self.write("(max") + self.write("(min") self.indent_sexp() self.newline() self.pretty_type(unwrapped_fields1364) self.dedent() self.write(")") - def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1368 = self._try_flat(msg, self.pretty_sum_monoid) + def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): + flat1368 = self._try_flat(msg, self.pretty_max_monoid) if flat1368 is not None: assert flat1368 is not None self.write(flat1368) @@ -3029,1601 +3014,1647 @@ def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): fields1366 = _dollar_dollar.type assert fields1366 is not None unwrapped_fields1367 = fields1366 - self.write("(sum") + self.write("(max") self.indent_sexp() self.newline() self.pretty_type(unwrapped_fields1367) self.dedent() self.write(")") + def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): + flat1371 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1371 is not None: + assert flat1371 is not None + self.write(flat1371) + return None + else: + _dollar_dollar = msg + fields1369 = _dollar_dollar.type + assert fields1369 is not None + unwrapped_fields1370 = fields1369 + self.write("(sum") + self.indent_sexp() + self.newline() + self.pretty_type(unwrapped_fields1370) + self.dedent() + self.write(")") + def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1376 = self._try_flat(msg, self.pretty_monus_def) - if flat1376 is not None: - assert flat1376 is not None - self.write(flat1376) + flat1379 = self._try_flat(msg, self.pretty_monus_def) + if flat1379 is not None: + assert flat1379 is not None + self.write(flat1379) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1807 = _dollar_dollar.attrs + _t1813 = _dollar_dollar.attrs else: - _t1807 = None - fields1369 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1807,) - assert fields1369 is not None - unwrapped_fields1370 = fields1369 + _t1813 = None + fields1372 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1813,) + assert fields1372 is not None + unwrapped_fields1373 = fields1372 self.write("(monus") self.indent_sexp() self.newline() - field1371 = unwrapped_fields1370[0] - self.pretty_monoid(field1371) + field1374 = unwrapped_fields1373[0] + self.pretty_monoid(field1374) self.newline() - field1372 = unwrapped_fields1370[1] - self.pretty_relation_id(field1372) + field1375 = unwrapped_fields1373[1] + self.pretty_relation_id(field1375) self.newline() - field1373 = unwrapped_fields1370[2] - self.pretty_abstraction_with_arity(field1373) - field1374 = unwrapped_fields1370[3] - if field1374 is not None: + field1376 = unwrapped_fields1373[2] + self.pretty_abstraction_with_arity(field1376) + field1377 = unwrapped_fields1373[3] + if field1377 is not None: self.newline() - assert field1374 is not None - opt_val1375 = field1374 - self.pretty_attrs(opt_val1375) + assert field1377 is not None + opt_val1378 = field1377 + self.pretty_attrs(opt_val1378) self.dedent() self.write(")") def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1383 = self._try_flat(msg, self.pretty_constraint) - if flat1383 is not None: - assert flat1383 is not None - self.write(flat1383) + flat1386 = self._try_flat(msg, self.pretty_constraint) + if flat1386 is not None: + assert flat1386 is not None + self.write(flat1386) return None else: _dollar_dollar = msg - fields1377 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - assert fields1377 is not None - unwrapped_fields1378 = fields1377 + fields1380 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) + assert fields1380 is not None + unwrapped_fields1381 = fields1380 self.write("(functional_dependency") self.indent_sexp() self.newline() - field1379 = unwrapped_fields1378[0] - self.pretty_relation_id(field1379) + field1382 = unwrapped_fields1381[0] + self.pretty_relation_id(field1382) self.newline() - field1380 = unwrapped_fields1378[1] - self.pretty_abstraction(field1380) + field1383 = unwrapped_fields1381[1] + self.pretty_abstraction(field1383) self.newline() - field1381 = unwrapped_fields1378[2] - self.pretty_functional_dependency_keys(field1381) + field1384 = unwrapped_fields1381[2] + self.pretty_functional_dependency_keys(field1384) self.newline() - field1382 = unwrapped_fields1378[3] - self.pretty_functional_dependency_values(field1382) + field1385 = unwrapped_fields1381[3] + self.pretty_functional_dependency_values(field1385) self.dedent() self.write(")") def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1387 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1387 is not None: - assert flat1387 is not None - self.write(flat1387) + flat1390 = self._try_flat(msg, self.pretty_functional_dependency_keys) + if flat1390 is not None: + assert flat1390 is not None + self.write(flat1390) return None else: - fields1384 = msg + fields1387 = msg self.write("(keys") self.indent_sexp() - if not len(fields1384) == 0: + if not len(fields1387) == 0: self.newline() - for i1386, elem1385 in enumerate(fields1384): - if (i1386 > 0): + for i1389, elem1388 in enumerate(fields1387): + if (i1389 > 0): self.newline() - self.pretty_var(elem1385) + self.pretty_var(elem1388) self.dedent() self.write(")") def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1391 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1391 is not None: - assert flat1391 is not None - self.write(flat1391) + flat1394 = self._try_flat(msg, self.pretty_functional_dependency_values) + if flat1394 is not None: + assert flat1394 is not None + self.write(flat1394) return None else: - fields1388 = msg + fields1391 = msg self.write("(values") self.indent_sexp() - if not len(fields1388) == 0: + if not len(fields1391) == 0: self.newline() - for i1390, elem1389 in enumerate(fields1388): - if (i1390 > 0): + for i1393, elem1392 in enumerate(fields1391): + if (i1393 > 0): self.newline() - self.pretty_var(elem1389) + self.pretty_var(elem1392) self.dedent() self.write(")") def pretty_data(self, msg: logic_pb2.Data): - flat1400 = self._try_flat(msg, self.pretty_data) - if flat1400 is not None: - assert flat1400 is not None - self.write(flat1400) + flat1403 = self._try_flat(msg, self.pretty_data) + if flat1403 is not None: + assert flat1403 is not None + self.write(flat1403) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("edb"): - _t1808 = _dollar_dollar.edb + _t1814 = _dollar_dollar.edb else: - _t1808 = None - deconstruct_result1398 = _t1808 - if deconstruct_result1398 is not None: - assert deconstruct_result1398 is not None - unwrapped1399 = deconstruct_result1398 - self.pretty_edb(unwrapped1399) + _t1814 = None + deconstruct_result1401 = _t1814 + if deconstruct_result1401 is not None: + assert deconstruct_result1401 is not None + unwrapped1402 = deconstruct_result1401 + self.pretty_edb(unwrapped1402) else: _dollar_dollar = msg if _dollar_dollar.HasField("betree_relation"): - _t1809 = _dollar_dollar.betree_relation + _t1815 = _dollar_dollar.betree_relation else: - _t1809 = None - deconstruct_result1396 = _t1809 - if deconstruct_result1396 is not None: - assert deconstruct_result1396 is not None - unwrapped1397 = deconstruct_result1396 - self.pretty_betree_relation(unwrapped1397) + _t1815 = None + deconstruct_result1399 = _t1815 + if deconstruct_result1399 is not None: + assert deconstruct_result1399 is not None + unwrapped1400 = deconstruct_result1399 + self.pretty_betree_relation(unwrapped1400) else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_data"): - _t1810 = _dollar_dollar.csv_data + _t1816 = _dollar_dollar.csv_data else: - _t1810 = None - deconstruct_result1394 = _t1810 - if deconstruct_result1394 is not None: - assert deconstruct_result1394 is not None - unwrapped1395 = deconstruct_result1394 - self.pretty_csv_data(unwrapped1395) + _t1816 = None + deconstruct_result1397 = _t1816 + if deconstruct_result1397 is not None: + assert deconstruct_result1397 is not None + unwrapped1398 = deconstruct_result1397 + self.pretty_csv_data(unwrapped1398) else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_data"): - _t1811 = _dollar_dollar.iceberg_data + _t1817 = _dollar_dollar.iceberg_data else: - _t1811 = None - deconstruct_result1392 = _t1811 - if deconstruct_result1392 is not None: - assert deconstruct_result1392 is not None - unwrapped1393 = deconstruct_result1392 - self.pretty_iceberg_data(unwrapped1393) + _t1817 = None + deconstruct_result1395 = _t1817 + if deconstruct_result1395 is not None: + assert deconstruct_result1395 is not None + unwrapped1396 = deconstruct_result1395 + self.pretty_iceberg_data(unwrapped1396) else: raise ParseError("No matching rule for data") def pretty_edb(self, msg: logic_pb2.EDB): - flat1406 = self._try_flat(msg, self.pretty_edb) - if flat1406 is not None: - assert flat1406 is not None - self.write(flat1406) + flat1409 = self._try_flat(msg, self.pretty_edb) + if flat1409 is not None: + assert flat1409 is not None + self.write(flat1409) return None else: _dollar_dollar = msg - fields1401 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - assert fields1401 is not None - unwrapped_fields1402 = fields1401 + fields1404 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + assert fields1404 is not None + unwrapped_fields1405 = fields1404 self.write("(edb") self.indent_sexp() self.newline() - field1403 = unwrapped_fields1402[0] - self.pretty_relation_id(field1403) + field1406 = unwrapped_fields1405[0] + self.pretty_relation_id(field1406) self.newline() - field1404 = unwrapped_fields1402[1] - self.pretty_edb_path(field1404) + field1407 = unwrapped_fields1405[1] + self.pretty_edb_path(field1407) self.newline() - field1405 = unwrapped_fields1402[2] - self.pretty_edb_types(field1405) + field1408 = unwrapped_fields1405[2] + self.pretty_edb_types(field1408) self.dedent() self.write(")") def pretty_edb_path(self, msg: Sequence[str]): - flat1410 = self._try_flat(msg, self.pretty_edb_path) - if flat1410 is not None: - assert flat1410 is not None - self.write(flat1410) + flat1413 = self._try_flat(msg, self.pretty_edb_path) + if flat1413 is not None: + assert flat1413 is not None + self.write(flat1413) return None else: - fields1407 = msg + fields1410 = msg self.write("[") self.indent() - for i1409, elem1408 in enumerate(fields1407): - if (i1409 > 0): + for i1412, elem1411 in enumerate(fields1410): + if (i1412 > 0): self.newline() - self.write(self.format_string_value(elem1408)) + self.write(self.format_string_value(elem1411)) self.dedent() self.write("]") def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1414 = self._try_flat(msg, self.pretty_edb_types) - if flat1414 is not None: - assert flat1414 is not None - self.write(flat1414) + flat1417 = self._try_flat(msg, self.pretty_edb_types) + if flat1417 is not None: + assert flat1417 is not None + self.write(flat1417) return None else: - fields1411 = msg + fields1414 = msg self.write("[") self.indent() - for i1413, elem1412 in enumerate(fields1411): - if (i1413 > 0): + for i1416, elem1415 in enumerate(fields1414): + if (i1416 > 0): self.newline() - self.pretty_type(elem1412) + self.pretty_type(elem1415) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1419 = self._try_flat(msg, self.pretty_betree_relation) - if flat1419 is not None: - assert flat1419 is not None - self.write(flat1419) + flat1422 = self._try_flat(msg, self.pretty_betree_relation) + if flat1422 is not None: + assert flat1422 is not None + self.write(flat1422) return None else: _dollar_dollar = msg - fields1415 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - assert fields1415 is not None - unwrapped_fields1416 = fields1415 + fields1418 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + assert fields1418 is not None + unwrapped_fields1419 = fields1418 self.write("(betree_relation") self.indent_sexp() self.newline() - field1417 = unwrapped_fields1416[0] - self.pretty_relation_id(field1417) + field1420 = unwrapped_fields1419[0] + self.pretty_relation_id(field1420) self.newline() - field1418 = unwrapped_fields1416[1] - self.pretty_betree_info(field1418) + field1421 = unwrapped_fields1419[1] + self.pretty_betree_info(field1421) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1425 = self._try_flat(msg, self.pretty_betree_info) - if flat1425 is not None: - assert flat1425 is not None - self.write(flat1425) + flat1428 = self._try_flat(msg, self.pretty_betree_info) + if flat1428 is not None: + assert flat1428 is not None + self.write(flat1428) return None else: _dollar_dollar = msg - _t1812 = self.deconstruct_betree_info_config(_dollar_dollar) - fields1420 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1812,) - assert fields1420 is not None - unwrapped_fields1421 = fields1420 + _t1818 = self.deconstruct_betree_info_config(_dollar_dollar) + fields1423 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1818,) + assert fields1423 is not None + unwrapped_fields1424 = fields1423 self.write("(betree_info") self.indent_sexp() self.newline() - field1422 = unwrapped_fields1421[0] - self.pretty_betree_info_key_types(field1422) + field1425 = unwrapped_fields1424[0] + self.pretty_betree_info_key_types(field1425) self.newline() - field1423 = unwrapped_fields1421[1] - self.pretty_betree_info_value_types(field1423) + field1426 = unwrapped_fields1424[1] + self.pretty_betree_info_value_types(field1426) self.newline() - field1424 = unwrapped_fields1421[2] - self.pretty_config_dict(field1424) + field1427 = unwrapped_fields1424[2] + self.pretty_config_dict(field1427) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1429 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1429 is not None: - assert flat1429 is not None - self.write(flat1429) + flat1432 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1432 is not None: + assert flat1432 is not None + self.write(flat1432) return None else: - fields1426 = msg + fields1429 = msg self.write("(key_types") self.indent_sexp() - if not len(fields1426) == 0: + if not len(fields1429) == 0: self.newline() - for i1428, elem1427 in enumerate(fields1426): - if (i1428 > 0): + for i1431, elem1430 in enumerate(fields1429): + if (i1431 > 0): self.newline() - self.pretty_type(elem1427) + self.pretty_type(elem1430) self.dedent() self.write(")") def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1433 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1433 is not None: - assert flat1433 is not None - self.write(flat1433) + flat1436 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1436 is not None: + assert flat1436 is not None + self.write(flat1436) return None else: - fields1430 = msg + fields1433 = msg self.write("(value_types") self.indent_sexp() - if not len(fields1430) == 0: + if not len(fields1433) == 0: self.newline() - for i1432, elem1431 in enumerate(fields1430): - if (i1432 > 0): + for i1435, elem1434 in enumerate(fields1433): + if (i1435 > 0): self.newline() - self.pretty_type(elem1431) + self.pretty_type(elem1434) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1443 = self._try_flat(msg, self.pretty_csv_data) - if flat1443 is not None: - assert flat1443 is not None - self.write(flat1443) + flat1446 = self._try_flat(msg, self.pretty_csv_data) + if flat1446 is not None: + assert flat1446 is not None + self.write(flat1446) return None else: _dollar_dollar = msg - _t1813 = self.deconstruct_csv_data_columns_optional(_dollar_dollar) - _t1814 = self.deconstruct_csv_data_relations_optional(_dollar_dollar) - fields1434 = (_dollar_dollar.locator, _dollar_dollar.config, _t1813, _t1814, _dollar_dollar.asof,) - assert fields1434 is not None - unwrapped_fields1435 = fields1434 + _t1819 = self.deconstruct_csv_data_columns_optional(_dollar_dollar) + _t1820 = self.deconstruct_csv_data_relations_optional(_dollar_dollar) + fields1437 = (_dollar_dollar.locator, _dollar_dollar.config, _t1819, _t1820, _dollar_dollar.asof,) + assert fields1437 is not None + unwrapped_fields1438 = fields1437 self.write("(csv_data") self.indent_sexp() self.newline() - field1436 = unwrapped_fields1435[0] - self.pretty_csvlocator(field1436) + field1439 = unwrapped_fields1438[0] + self.pretty_csvlocator(field1439) self.newline() - field1437 = unwrapped_fields1435[1] - self.pretty_csv_config(field1437) - field1438 = unwrapped_fields1435[2] - if field1438 is not None: + field1440 = unwrapped_fields1438[1] + self.pretty_csv_config(field1440) + field1441 = unwrapped_fields1438[2] + if field1441 is not None: self.newline() - assert field1438 is not None - opt_val1439 = field1438 - self.pretty_gnf_columns(opt_val1439) - field1440 = unwrapped_fields1435[3] - if field1440 is not None: + assert field1441 is not None + opt_val1442 = field1441 + self.pretty_gnf_columns(opt_val1442) + field1443 = unwrapped_fields1438[3] + if field1443 is not None: self.newline() - assert field1440 is not None - opt_val1441 = field1440 - self.pretty_target_relations(opt_val1441) + assert field1443 is not None + opt_val1444 = field1443 + self.pretty_target_relations(opt_val1444) self.newline() - field1442 = unwrapped_fields1435[4] - self.pretty_csv_asof(field1442) + field1445 = unwrapped_fields1438[4] + self.pretty_csv_asof(field1445) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1450 = self._try_flat(msg, self.pretty_csvlocator) - if flat1450 is not None: - assert flat1450 is not None - self.write(flat1450) + flat1453 = self._try_flat(msg, self.pretty_csvlocator) + if flat1453 is not None: + assert flat1453 is not None + self.write(flat1453) return None else: _dollar_dollar = msg if not len(_dollar_dollar.paths) == 0: - _t1815 = _dollar_dollar.paths + _t1821 = _dollar_dollar.paths else: - _t1815 = None + _t1821 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1816 = _dollar_dollar.inline_data.decode('utf-8') + _t1822 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1816 = None - fields1444 = (_t1815, _t1816,) - assert fields1444 is not None - unwrapped_fields1445 = fields1444 + _t1822 = None + fields1447 = (_t1821, _t1822,) + assert fields1447 is not None + unwrapped_fields1448 = fields1447 self.write("(csv_locator") self.indent_sexp() - field1446 = unwrapped_fields1445[0] - if field1446 is not None: + field1449 = unwrapped_fields1448[0] + if field1449 is not None: self.newline() - assert field1446 is not None - opt_val1447 = field1446 - self.pretty_csv_locator_paths(opt_val1447) - field1448 = unwrapped_fields1445[1] - if field1448 is not None: + assert field1449 is not None + opt_val1450 = field1449 + self.pretty_csv_locator_paths(opt_val1450) + field1451 = unwrapped_fields1448[1] + if field1451 is not None: self.newline() - assert field1448 is not None - opt_val1449 = field1448 - self.pretty_csv_locator_inline_data(opt_val1449) + assert field1451 is not None + opt_val1452 = field1451 + self.pretty_csv_locator_inline_data(opt_val1452) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1454 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1454 is not None: - assert flat1454 is not None - self.write(flat1454) + flat1457 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1457 is not None: + assert flat1457 is not None + self.write(flat1457) return None else: - fields1451 = msg + fields1454 = msg self.write("(paths") self.indent_sexp() - if not len(fields1451) == 0: + if not len(fields1454) == 0: self.newline() - for i1453, elem1452 in enumerate(fields1451): - if (i1453 > 0): + for i1456, elem1455 in enumerate(fields1454): + if (i1456 > 0): self.newline() - self.write(self.format_string_value(elem1452)) + self.write(self.format_string_value(elem1455)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1456 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1456 is not None: - assert flat1456 is not None - self.write(flat1456) + flat1459 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1459 is not None: + assert flat1459 is not None + self.write(flat1459) return None else: - fields1455 = msg + fields1458 = msg self.write("(inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1455)) + self.write(self.format_string_value(fields1458)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1462 = self._try_flat(msg, self.pretty_csv_config) - if flat1462 is not None: - assert flat1462 is not None - self.write(flat1462) + flat1465 = self._try_flat(msg, self.pretty_csv_config) + if flat1465 is not None: + assert flat1465 is not None + self.write(flat1465) return None else: _dollar_dollar = msg - _t1817 = self.deconstruct_csv_config(_dollar_dollar) - _t1818 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1457 = (_t1817, _t1818,) - assert fields1457 is not None - unwrapped_fields1458 = fields1457 + _t1823 = self.deconstruct_csv_config(_dollar_dollar) + _t1824 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1460 = (_t1823, _t1824,) + assert fields1460 is not None + unwrapped_fields1461 = fields1460 self.write("(csv_config") self.indent_sexp() self.newline() - field1459 = unwrapped_fields1458[0] - self.pretty_config_dict(field1459) - field1460 = unwrapped_fields1458[1] - if field1460 is not None: + field1462 = unwrapped_fields1461[0] + self.pretty_config_dict(field1462) + field1463 = unwrapped_fields1461[1] + if field1463 is not None: self.newline() - assert field1460 is not None - opt_val1461 = field1460 - self.pretty__storage_integration(opt_val1461) + assert field1463 is not None + opt_val1464 = field1463 + self.pretty__storage_integration(opt_val1464) self.dedent() self.write(")") def pretty__storage_integration(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat1464 = self._try_flat(msg, self.pretty__storage_integration) - if flat1464 is not None: - assert flat1464 is not None - self.write(flat1464) + flat1467 = self._try_flat(msg, self.pretty__storage_integration) + if flat1467 is not None: + assert flat1467 is not None + self.write(flat1467) return None else: - fields1463 = msg + fields1466 = msg self.write("(storage_integration") self.indent_sexp() self.newline() - self.pretty_config_dict(fields1463) + self.pretty_config_dict(fields1466) self.dedent() self.write(")") def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): - flat1468 = self._try_flat(msg, self.pretty_gnf_columns) - if flat1468 is not None: - assert flat1468 is not None - self.write(flat1468) + flat1471 = self._try_flat(msg, self.pretty_gnf_columns) + if flat1471 is not None: + assert flat1471 is not None + self.write(flat1471) return None else: - fields1465 = msg + fields1468 = msg self.write("(columns") self.indent_sexp() - if not len(fields1465) == 0: + if not len(fields1468) == 0: self.newline() - for i1467, elem1466 in enumerate(fields1465): - if (i1467 > 0): + for i1470, elem1469 in enumerate(fields1468): + if (i1470 > 0): self.newline() - self.pretty_gnf_column(elem1466) + self.pretty_gnf_column(elem1469) self.dedent() self.write(")") def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): - flat1477 = self._try_flat(msg, self.pretty_gnf_column) - if flat1477 is not None: - assert flat1477 is not None - self.write(flat1477) + flat1480 = self._try_flat(msg, self.pretty_gnf_column) + if flat1480 is not None: + assert flat1480 is not None + self.write(flat1480) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("target_id"): - _t1819 = _dollar_dollar.target_id + _t1825 = _dollar_dollar.target_id else: - _t1819 = None - fields1469 = (_dollar_dollar.column_path, _t1819, _dollar_dollar.types,) - assert fields1469 is not None - unwrapped_fields1470 = fields1469 + _t1825 = None + fields1472 = (_dollar_dollar.column_path, _t1825, _dollar_dollar.types,) + assert fields1472 is not None + unwrapped_fields1473 = fields1472 self.write("(column") self.indent_sexp() self.newline() - field1471 = unwrapped_fields1470[0] - self.pretty_gnf_column_path(field1471) - field1472 = unwrapped_fields1470[1] - if field1472 is not None: + field1474 = unwrapped_fields1473[0] + self.pretty_gnf_column_path(field1474) + field1475 = unwrapped_fields1473[1] + if field1475 is not None: self.newline() - assert field1472 is not None - opt_val1473 = field1472 - self.pretty_relation_id(opt_val1473) + assert field1475 is not None + opt_val1476 = field1475 + self.pretty_relation_id(opt_val1476) self.newline() self.write("[") - field1474 = unwrapped_fields1470[2] - for i1476, elem1475 in enumerate(field1474): - if (i1476 > 0): + field1477 = unwrapped_fields1473[2] + for i1479, elem1478 in enumerate(field1477): + if (i1479 > 0): self.newline() - self.pretty_type(elem1475) + self.pretty_type(elem1478) self.write("]") self.dedent() self.write(")") def pretty_gnf_column_path(self, msg: Sequence[str]): - flat1484 = self._try_flat(msg, self.pretty_gnf_column_path) - if flat1484 is not None: - assert flat1484 is not None - self.write(flat1484) + flat1487 = self._try_flat(msg, self.pretty_gnf_column_path) + if flat1487 is not None: + assert flat1487 is not None + self.write(flat1487) return None else: _dollar_dollar = msg if len(_dollar_dollar) == 1: - _t1820 = _dollar_dollar[0] + _t1826 = _dollar_dollar[0] else: - _t1820 = None - deconstruct_result1482 = _t1820 - if deconstruct_result1482 is not None: - assert deconstruct_result1482 is not None - unwrapped1483 = deconstruct_result1482 - self.write(self.format_string_value(unwrapped1483)) + _t1826 = None + deconstruct_result1485 = _t1826 + if deconstruct_result1485 is not None: + assert deconstruct_result1485 is not None + unwrapped1486 = deconstruct_result1485 + self.write(self.format_string_value(unwrapped1486)) else: _dollar_dollar = msg if len(_dollar_dollar) != 1: - _t1821 = _dollar_dollar + _t1827 = _dollar_dollar else: - _t1821 = None - deconstruct_result1478 = _t1821 - if deconstruct_result1478 is not None: - assert deconstruct_result1478 is not None - unwrapped1479 = deconstruct_result1478 + _t1827 = None + deconstruct_result1481 = _t1827 + if deconstruct_result1481 is not None: + assert deconstruct_result1481 is not None + unwrapped1482 = deconstruct_result1481 self.write("[") self.indent() - for i1481, elem1480 in enumerate(unwrapped1479): - if (i1481 > 0): + for i1484, elem1483 in enumerate(unwrapped1482): + if (i1484 > 0): self.newline() - self.write(self.format_string_value(elem1480)) + self.write(self.format_string_value(elem1483)) self.dedent() self.write("]") else: raise ParseError("No matching rule for gnf_column_path") def pretty_target_relations(self, msg: logic_pb2.TargetRelations): - flat1489 = self._try_flat(msg, self.pretty_target_relations) - if flat1489 is not None: - assert flat1489 is not None - self.write(flat1489) + flat1492 = self._try_flat(msg, self.pretty_target_relations) + if flat1492 is not None: + assert flat1492 is not None + self.write(flat1492) return None else: _dollar_dollar = msg - fields1485 = (_dollar_dollar.keys, _dollar_dollar,) - assert fields1485 is not None - unwrapped_fields1486 = fields1485 + _t1828 = self.deconstruct_relation_keys(_dollar_dollar) + fields1488 = (_t1828, _dollar_dollar,) + assert fields1488 is not None + unwrapped_fields1489 = fields1488 self.write("(relations") self.indent_sexp() self.newline() - field1487 = unwrapped_fields1486[0] - self.pretty_relation_keys(field1487) + field1490 = unwrapped_fields1489[0] + self.pretty_relation_keys(field1490) self.newline() - field1488 = unwrapped_fields1486[1] - self.pretty_relation_body(field1488) + field1491 = unwrapped_fields1489[1] + self.pretty_relation_body(field1491) self.dedent() self.write(")") - def pretty_relation_keys(self, msg: Sequence[logic_pb2.NamedColumn]): - flat1493 = self._try_flat(msg, self.pretty_relation_keys) - if flat1493 is not None: - assert flat1493 is not None - self.write(flat1493) + def pretty_relation_keys(self, msg: tuple[Sequence[logic_pb2.NamedColumn], bool]): + flat1499 = self._try_flat(msg, self.pretty_relation_keys) + if flat1499 is not None: + assert flat1499 is not None + self.write(flat1499) return None else: - fields1490 = msg - self.write("(keys") - self.indent_sexp() - if not len(fields1490) == 0: - self.newline() - for i1492, elem1491 in enumerate(fields1490): - if (i1492 > 0): - self.newline() - self.pretty_named_column(elem1491) - self.dedent() - self.write(")") + _dollar_dollar = msg + if not _dollar_dollar[1]: + _t1829 = _dollar_dollar[0] + else: + _t1829 = None + deconstruct_result1495 = _t1829 + if deconstruct_result1495 is not None: + assert deconstruct_result1495 is not None + unwrapped1496 = deconstruct_result1495 + self.write("(keys") + self.indent_sexp() + if not len(unwrapped1496) == 0: + self.newline() + for i1498, elem1497 in enumerate(unwrapped1496): + if (i1498 > 0): + self.newline() + self.pretty_named_column(elem1497) + self.dedent() + self.write(")") + else: + _dollar_dollar = msg + if _dollar_dollar[1]: + _t1830 = "synthetic_key" + else: + _t1830 = None + deconstruct_result1493 = _t1830 + if deconstruct_result1493 is not None: + assert deconstruct_result1493 is not None + unwrapped1494 = deconstruct_result1493 + self.write("(keys") + self.indent_sexp() + self.newline() + self.write(":") + self.write(unwrapped1494) + self.dedent() + self.write(")") + else: + raise ParseError("No matching rule for relation_keys") def pretty_named_column(self, msg: logic_pb2.NamedColumn): - flat1498 = self._try_flat(msg, self.pretty_named_column) - if flat1498 is not None: - assert flat1498 is not None - self.write(flat1498) + flat1504 = self._try_flat(msg, self.pretty_named_column) + if flat1504 is not None: + assert flat1504 is not None + self.write(flat1504) return None else: _dollar_dollar = msg - fields1494 = (_dollar_dollar.name, _dollar_dollar.type,) - assert fields1494 is not None - unwrapped_fields1495 = fields1494 + fields1500 = (_dollar_dollar.name, _dollar_dollar.type,) + assert fields1500 is not None + unwrapped_fields1501 = fields1500 self.write("(column") self.indent_sexp() self.newline() - field1496 = unwrapped_fields1495[0] - self.write(self.format_string_value(field1496)) + field1502 = unwrapped_fields1501[0] + self.write(self.format_string_value(field1502)) self.newline() - field1497 = unwrapped_fields1495[1] - self.pretty_type(field1497) + field1503 = unwrapped_fields1501[1] + self.pretty_type(field1503) self.dedent() self.write(")") def pretty_relation_body(self, msg: logic_pb2.TargetRelations): - flat1505 = self._try_flat(msg, self.pretty_relation_body) - if flat1505 is not None: - assert flat1505 is not None - self.write(flat1505) + flat1511 = self._try_flat(msg, self.pretty_relation_body) + if flat1511 is not None: + assert flat1511 is not None + self.write(flat1511) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("plain"): - _t1822 = _dollar_dollar.plain.targets + _t1831 = _dollar_dollar.plain.targets else: - _t1822 = None - deconstruct_result1503 = _t1822 - if deconstruct_result1503 is not None: - assert deconstruct_result1503 is not None - unwrapped1504 = deconstruct_result1503 - self.pretty_non_cdc_relations(unwrapped1504) + _t1831 = None + deconstruct_result1509 = _t1831 + if deconstruct_result1509 is not None: + assert deconstruct_result1509 is not None + unwrapped1510 = deconstruct_result1509 + self.pretty_non_cdc_relations(unwrapped1510) else: _dollar_dollar = msg if _dollar_dollar.HasField("cdc"): - _t1823 = (_dollar_dollar.cdc.inserts, _dollar_dollar.cdc.deletes,) + _t1832 = (_dollar_dollar.cdc.inserts, _dollar_dollar.cdc.deletes,) else: - _t1823 = None - deconstruct_result1499 = _t1823 - if deconstruct_result1499 is not None: - assert deconstruct_result1499 is not None - unwrapped1500 = deconstruct_result1499 - field1501 = unwrapped1500[0] - self.pretty_cdc_inserts(field1501) + _t1832 = None + deconstruct_result1505 = _t1832 + if deconstruct_result1505 is not None: + assert deconstruct_result1505 is not None + unwrapped1506 = deconstruct_result1505 + field1507 = unwrapped1506[0] + self.pretty_cdc_inserts(field1507) self.write(" ") - field1502 = unwrapped1500[1] - self.pretty_cdc_deletes(field1502) + field1508 = unwrapped1506[1] + self.pretty_cdc_deletes(field1508) else: raise ParseError("No matching rule for relation_body") def pretty_non_cdc_relations(self, msg: Sequence[logic_pb2.TargetRelation]): - flat1509 = self._try_flat(msg, self.pretty_non_cdc_relations) - if flat1509 is not None: - assert flat1509 is not None - self.write(flat1509) + flat1515 = self._try_flat(msg, self.pretty_non_cdc_relations) + if flat1515 is not None: + assert flat1515 is not None + self.write(flat1515) return None else: - fields1506 = msg - for i1508, elem1507 in enumerate(fields1506): - if (i1508 > 0): + fields1512 = msg + for i1514, elem1513 in enumerate(fields1512): + if (i1514 > 0): self.newline() - self.pretty_target_relation(elem1507) + self.pretty_target_relation(elem1513) def pretty_target_relation(self, msg: logic_pb2.TargetRelation): - flat1516 = self._try_flat(msg, self.pretty_target_relation) - if flat1516 is not None: - assert flat1516 is not None - self.write(flat1516) + flat1522 = self._try_flat(msg, self.pretty_target_relation) + if flat1522 is not None: + assert flat1522 is not None + self.write(flat1522) return None else: _dollar_dollar = msg - fields1510 = (_dollar_dollar.target_id, _dollar_dollar.values,) - assert fields1510 is not None - unwrapped_fields1511 = fields1510 + fields1516 = (_dollar_dollar.target_id, _dollar_dollar.values,) + assert fields1516 is not None + unwrapped_fields1517 = fields1516 self.write("(relation") self.indent_sexp() self.newline() - field1512 = unwrapped_fields1511[0] - self.pretty_relation_id(field1512) - field1513 = unwrapped_fields1511[1] - if not len(field1513) == 0: + field1518 = unwrapped_fields1517[0] + self.pretty_relation_id(field1518) + field1519 = unwrapped_fields1517[1] + if not len(field1519) == 0: self.newline() - for i1515, elem1514 in enumerate(field1513): - if (i1515 > 0): + for i1521, elem1520 in enumerate(field1519): + if (i1521 > 0): self.newline() - self.pretty_named_column(elem1514) + self.pretty_named_column(elem1520) self.dedent() self.write(")") def pretty_cdc_inserts(self, msg: Sequence[logic_pb2.TargetRelation]): - flat1520 = self._try_flat(msg, self.pretty_cdc_inserts) - if flat1520 is not None: - assert flat1520 is not None - self.write(flat1520) + flat1526 = self._try_flat(msg, self.pretty_cdc_inserts) + if flat1526 is not None: + assert flat1526 is not None + self.write(flat1526) return None else: - fields1517 = msg + fields1523 = msg self.write("(inserts") self.indent_sexp() - if not len(fields1517) == 0: + if not len(fields1523) == 0: self.newline() - for i1519, elem1518 in enumerate(fields1517): - if (i1519 > 0): + for i1525, elem1524 in enumerate(fields1523): + if (i1525 > 0): self.newline() - self.pretty_target_relation(elem1518) + self.pretty_target_relation(elem1524) self.dedent() self.write(")") def pretty_cdc_deletes(self, msg: Sequence[logic_pb2.TargetRelation]): - flat1524 = self._try_flat(msg, self.pretty_cdc_deletes) - if flat1524 is not None: - assert flat1524 is not None - self.write(flat1524) + flat1530 = self._try_flat(msg, self.pretty_cdc_deletes) + if flat1530 is not None: + assert flat1530 is not None + self.write(flat1530) return None else: - fields1521 = msg + fields1527 = msg self.write("(deletes") self.indent_sexp() - if not len(fields1521) == 0: + if not len(fields1527) == 0: self.newline() - for i1523, elem1522 in enumerate(fields1521): - if (i1523 > 0): + for i1529, elem1528 in enumerate(fields1527): + if (i1529 > 0): self.newline() - self.pretty_target_relation(elem1522) + self.pretty_target_relation(elem1528) self.dedent() self.write(")") def pretty_csv_asof(self, msg: str): - flat1526 = self._try_flat(msg, self.pretty_csv_asof) - if flat1526 is not None: - assert flat1526 is not None - self.write(flat1526) + flat1532 = self._try_flat(msg, self.pretty_csv_asof) + if flat1532 is not None: + assert flat1532 is not None + self.write(flat1532) return None else: - fields1525 = msg + fields1531 = msg self.write("(asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1525)) + self.write(self.format_string_value(fields1531)) self.dedent() self.write(")") def pretty_iceberg_data(self, msg: logic_pb2.IcebergData): - flat1537 = self._try_flat(msg, self.pretty_iceberg_data) - if flat1537 is not None: - assert flat1537 is not None - self.write(flat1537) + flat1543 = self._try_flat(msg, self.pretty_iceberg_data) + if flat1543 is not None: + assert flat1543 is not None + self.write(flat1543) return None else: _dollar_dollar = msg - _t1824 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1825 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1527 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1824, _t1825, _dollar_dollar.returns_delta,) - assert fields1527 is not None - unwrapped_fields1528 = fields1527 + _t1833 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1834 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1533 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1833, _t1834, _dollar_dollar.returns_delta,) + assert fields1533 is not None + unwrapped_fields1534 = fields1533 self.write("(iceberg_data") self.indent_sexp() self.newline() - field1529 = unwrapped_fields1528[0] - self.pretty_iceberg_locator(field1529) + field1535 = unwrapped_fields1534[0] + self.pretty_iceberg_locator(field1535) self.newline() - field1530 = unwrapped_fields1528[1] - self.pretty_iceberg_catalog_config(field1530) + field1536 = unwrapped_fields1534[1] + self.pretty_iceberg_catalog_config(field1536) self.newline() - field1531 = unwrapped_fields1528[2] - self.pretty_gnf_columns(field1531) - field1532 = unwrapped_fields1528[3] - if field1532 is not None: + field1537 = unwrapped_fields1534[2] + self.pretty_gnf_columns(field1537) + field1538 = unwrapped_fields1534[3] + if field1538 is not None: self.newline() - assert field1532 is not None - opt_val1533 = field1532 - self.pretty_iceberg_from_snapshot(opt_val1533) - field1534 = unwrapped_fields1528[4] - if field1534 is not None: + assert field1538 is not None + opt_val1539 = field1538 + self.pretty_iceberg_from_snapshot(opt_val1539) + field1540 = unwrapped_fields1534[4] + if field1540 is not None: self.newline() - assert field1534 is not None - opt_val1535 = field1534 - self.pretty_iceberg_to_snapshot(opt_val1535) + assert field1540 is not None + opt_val1541 = field1540 + self.pretty_iceberg_to_snapshot(opt_val1541) self.newline() - field1536 = unwrapped_fields1528[5] - self.pretty_boolean_value(field1536) + field1542 = unwrapped_fields1534[5] + self.pretty_boolean_value(field1542) self.dedent() self.write(")") def pretty_iceberg_locator(self, msg: logic_pb2.IcebergLocator): - flat1543 = self._try_flat(msg, self.pretty_iceberg_locator) - if flat1543 is not None: - assert flat1543 is not None - self.write(flat1543) + flat1549 = self._try_flat(msg, self.pretty_iceberg_locator) + if flat1549 is not None: + assert flat1549 is not None + self.write(flat1549) return None else: _dollar_dollar = msg - fields1538 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - assert fields1538 is not None - unwrapped_fields1539 = fields1538 + fields1544 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + assert fields1544 is not None + unwrapped_fields1545 = fields1544 self.write("(iceberg_locator") self.indent_sexp() self.newline() - field1540 = unwrapped_fields1539[0] - self.pretty_iceberg_locator_table_name(field1540) + field1546 = unwrapped_fields1545[0] + self.pretty_iceberg_locator_table_name(field1546) self.newline() - field1541 = unwrapped_fields1539[1] - self.pretty_iceberg_locator_namespace(field1541) + field1547 = unwrapped_fields1545[1] + self.pretty_iceberg_locator_namespace(field1547) self.newline() - field1542 = unwrapped_fields1539[2] - self.pretty_iceberg_locator_warehouse(field1542) + field1548 = unwrapped_fields1545[2] + self.pretty_iceberg_locator_warehouse(field1548) self.dedent() self.write(")") def pretty_iceberg_locator_table_name(self, msg: str): - flat1545 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) - if flat1545 is not None: - assert flat1545 is not None - self.write(flat1545) + flat1551 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) + if flat1551 is not None: + assert flat1551 is not None + self.write(flat1551) return None else: - fields1544 = msg + fields1550 = msg self.write("(table_name") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1544)) + self.write(self.format_string_value(fields1550)) self.dedent() self.write(")") def pretty_iceberg_locator_namespace(self, msg: Sequence[str]): - flat1549 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) - if flat1549 is not None: - assert flat1549 is not None - self.write(flat1549) + flat1555 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) + if flat1555 is not None: + assert flat1555 is not None + self.write(flat1555) return None else: - fields1546 = msg + fields1552 = msg self.write("(namespace") self.indent_sexp() - if not len(fields1546) == 0: + if not len(fields1552) == 0: self.newline() - for i1548, elem1547 in enumerate(fields1546): - if (i1548 > 0): + for i1554, elem1553 in enumerate(fields1552): + if (i1554 > 0): self.newline() - self.write(self.format_string_value(elem1547)) + self.write(self.format_string_value(elem1553)) self.dedent() self.write(")") def pretty_iceberg_locator_warehouse(self, msg: str): - flat1551 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) - if flat1551 is not None: - assert flat1551 is not None - self.write(flat1551) + flat1557 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) + if flat1557 is not None: + assert flat1557 is not None + self.write(flat1557) return None else: - fields1550 = msg + fields1556 = msg self.write("(warehouse") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1550)) + self.write(self.format_string_value(fields1556)) self.dedent() self.write(")") def pretty_iceberg_catalog_config(self, msg: logic_pb2.IcebergCatalogConfig): - flat1559 = self._try_flat(msg, self.pretty_iceberg_catalog_config) - if flat1559 is not None: - assert flat1559 is not None - self.write(flat1559) + flat1565 = self._try_flat(msg, self.pretty_iceberg_catalog_config) + if flat1565 is not None: + assert flat1565 is not None + self.write(flat1565) return None else: _dollar_dollar = msg - _t1826 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1552 = (_dollar_dollar.catalog_uri, _t1826, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) - assert fields1552 is not None - unwrapped_fields1553 = fields1552 + _t1835 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1558 = (_dollar_dollar.catalog_uri, _t1835, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) + assert fields1558 is not None + unwrapped_fields1559 = fields1558 self.write("(iceberg_catalog_config") self.indent_sexp() self.newline() - field1554 = unwrapped_fields1553[0] - self.pretty_iceberg_catalog_uri(field1554) - field1555 = unwrapped_fields1553[1] - if field1555 is not None: + field1560 = unwrapped_fields1559[0] + self.pretty_iceberg_catalog_uri(field1560) + field1561 = unwrapped_fields1559[1] + if field1561 is not None: self.newline() - assert field1555 is not None - opt_val1556 = field1555 - self.pretty_iceberg_catalog_config_scope(opt_val1556) + assert field1561 is not None + opt_val1562 = field1561 + self.pretty_iceberg_catalog_config_scope(opt_val1562) self.newline() - field1557 = unwrapped_fields1553[2] - self.pretty_iceberg_properties(field1557) + field1563 = unwrapped_fields1559[2] + self.pretty_iceberg_properties(field1563) self.newline() - field1558 = unwrapped_fields1553[3] - self.pretty_iceberg_auth_properties(field1558) + field1564 = unwrapped_fields1559[3] + self.pretty_iceberg_auth_properties(field1564) self.dedent() self.write(")") def pretty_iceberg_catalog_uri(self, msg: str): - flat1561 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) - if flat1561 is not None: - assert flat1561 is not None - self.write(flat1561) + flat1567 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) + if flat1567 is not None: + assert flat1567 is not None + self.write(flat1567) return None else: - fields1560 = msg + fields1566 = msg self.write("(catalog_uri") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1560)) + self.write(self.format_string_value(fields1566)) self.dedent() self.write(")") def pretty_iceberg_catalog_config_scope(self, msg: str): - flat1563 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) - if flat1563 is not None: - assert flat1563 is not None - self.write(flat1563) + flat1569 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) + if flat1569 is not None: + assert flat1569 is not None + self.write(flat1569) return None else: - fields1562 = msg + fields1568 = msg self.write("(scope") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1562)) + self.write(self.format_string_value(fields1568)) self.dedent() self.write(")") def pretty_iceberg_properties(self, msg: Sequence[tuple[str, str]]): - flat1567 = self._try_flat(msg, self.pretty_iceberg_properties) - if flat1567 is not None: - assert flat1567 is not None - self.write(flat1567) + flat1573 = self._try_flat(msg, self.pretty_iceberg_properties) + if flat1573 is not None: + assert flat1573 is not None + self.write(flat1573) return None else: - fields1564 = msg + fields1570 = msg self.write("(properties") self.indent_sexp() - if not len(fields1564) == 0: + if not len(fields1570) == 0: self.newline() - for i1566, elem1565 in enumerate(fields1564): - if (i1566 > 0): + for i1572, elem1571 in enumerate(fields1570): + if (i1572 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1565) + self.pretty_iceberg_property_entry(elem1571) self.dedent() self.write(")") def pretty_iceberg_property_entry(self, msg: tuple[str, str]): - flat1572 = self._try_flat(msg, self.pretty_iceberg_property_entry) - if flat1572 is not None: - assert flat1572 is not None - self.write(flat1572) + flat1578 = self._try_flat(msg, self.pretty_iceberg_property_entry) + if flat1578 is not None: + assert flat1578 is not None + self.write(flat1578) return None else: _dollar_dollar = msg - fields1568 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields1568 is not None - unwrapped_fields1569 = fields1568 + fields1574 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields1574 is not None + unwrapped_fields1575 = fields1574 self.write("(prop") self.indent_sexp() self.newline() - field1570 = unwrapped_fields1569[0] - self.write(self.format_string_value(field1570)) + field1576 = unwrapped_fields1575[0] + self.write(self.format_string_value(field1576)) self.newline() - field1571 = unwrapped_fields1569[1] - self.write(self.format_string_value(field1571)) + field1577 = unwrapped_fields1575[1] + self.write(self.format_string_value(field1577)) self.dedent() self.write(")") def pretty_iceberg_auth_properties(self, msg: Sequence[tuple[str, str]]): - flat1576 = self._try_flat(msg, self.pretty_iceberg_auth_properties) - if flat1576 is not None: - assert flat1576 is not None - self.write(flat1576) + flat1582 = self._try_flat(msg, self.pretty_iceberg_auth_properties) + if flat1582 is not None: + assert flat1582 is not None + self.write(flat1582) return None else: - fields1573 = msg + fields1579 = msg self.write("(auth_properties") self.indent_sexp() - if not len(fields1573) == 0: + if not len(fields1579) == 0: self.newline() - for i1575, elem1574 in enumerate(fields1573): - if (i1575 > 0): + for i1581, elem1580 in enumerate(fields1579): + if (i1581 > 0): self.newline() - self.pretty_iceberg_masked_property_entry(elem1574) + self.pretty_iceberg_masked_property_entry(elem1580) self.dedent() self.write(")") def pretty_iceberg_masked_property_entry(self, msg: tuple[str, str]): - flat1581 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) - if flat1581 is not None: - assert flat1581 is not None - self.write(flat1581) + flat1587 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) + if flat1587 is not None: + assert flat1587 is not None + self.write(flat1587) return None else: _dollar_dollar = msg - _t1827 = self.mask_secret_value(_dollar_dollar) - fields1577 = (_dollar_dollar[0], _t1827,) - assert fields1577 is not None - unwrapped_fields1578 = fields1577 + _t1836 = self.mask_secret_value(_dollar_dollar) + fields1583 = (_dollar_dollar[0], _t1836,) + assert fields1583 is not None + unwrapped_fields1584 = fields1583 self.write("(prop") self.indent_sexp() self.newline() - field1579 = unwrapped_fields1578[0] - self.write(self.format_string_value(field1579)) + field1585 = unwrapped_fields1584[0] + self.write(self.format_string_value(field1585)) self.newline() - field1580 = unwrapped_fields1578[1] - self.write(self.format_string_value(field1580)) + field1586 = unwrapped_fields1584[1] + self.write(self.format_string_value(field1586)) self.dedent() self.write(")") def pretty_iceberg_from_snapshot(self, msg: str): - flat1583 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) - if flat1583 is not None: - assert flat1583 is not None - self.write(flat1583) + flat1589 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) + if flat1589 is not None: + assert flat1589 is not None + self.write(flat1589) return None else: - fields1582 = msg + fields1588 = msg self.write("(from_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1582)) + self.write(self.format_string_value(fields1588)) self.dedent() self.write(")") def pretty_iceberg_to_snapshot(self, msg: str): - flat1585 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) - if flat1585 is not None: - assert flat1585 is not None - self.write(flat1585) + flat1591 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) + if flat1591 is not None: + assert flat1591 is not None + self.write(flat1591) return None else: - fields1584 = msg + fields1590 = msg self.write("(to_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1584)) + self.write(self.format_string_value(fields1590)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1588 = self._try_flat(msg, self.pretty_undefine) - if flat1588 is not None: - assert flat1588 is not None - self.write(flat1588) + flat1594 = self._try_flat(msg, self.pretty_undefine) + if flat1594 is not None: + assert flat1594 is not None + self.write(flat1594) return None else: _dollar_dollar = msg - fields1586 = _dollar_dollar.fragment_id - assert fields1586 is not None - unwrapped_fields1587 = fields1586 + fields1592 = _dollar_dollar.fragment_id + assert fields1592 is not None + unwrapped_fields1593 = fields1592 self.write("(undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1587) + self.pretty_fragment_id(unwrapped_fields1593) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1593 = self._try_flat(msg, self.pretty_context) - if flat1593 is not None: - assert flat1593 is not None - self.write(flat1593) + flat1599 = self._try_flat(msg, self.pretty_context) + if flat1599 is not None: + assert flat1599 is not None + self.write(flat1599) return None else: _dollar_dollar = msg - fields1589 = _dollar_dollar.relations - assert fields1589 is not None - unwrapped_fields1590 = fields1589 + fields1595 = _dollar_dollar.relations + assert fields1595 is not None + unwrapped_fields1596 = fields1595 self.write("(context") self.indent_sexp() - if not len(unwrapped_fields1590) == 0: + if not len(unwrapped_fields1596) == 0: self.newline() - for i1592, elem1591 in enumerate(unwrapped_fields1590): - if (i1592 > 0): + for i1598, elem1597 in enumerate(unwrapped_fields1596): + if (i1598 > 0): self.newline() - self.pretty_relation_id(elem1591) + self.pretty_relation_id(elem1597) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1600 = self._try_flat(msg, self.pretty_snapshot) - if flat1600 is not None: - assert flat1600 is not None - self.write(flat1600) + flat1606 = self._try_flat(msg, self.pretty_snapshot) + if flat1606 is not None: + assert flat1606 is not None + self.write(flat1606) return None else: _dollar_dollar = msg - fields1594 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - assert fields1594 is not None - unwrapped_fields1595 = fields1594 + fields1600 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + assert fields1600 is not None + unwrapped_fields1601 = fields1600 self.write("(snapshot") self.indent_sexp() self.newline() - field1596 = unwrapped_fields1595[0] - self.pretty_edb_path(field1596) - field1597 = unwrapped_fields1595[1] - if not len(field1597) == 0: + field1602 = unwrapped_fields1601[0] + self.pretty_edb_path(field1602) + field1603 = unwrapped_fields1601[1] + if not len(field1603) == 0: self.newline() - for i1599, elem1598 in enumerate(field1597): - if (i1599 > 0): + for i1605, elem1604 in enumerate(field1603): + if (i1605 > 0): self.newline() - self.pretty_snapshot_mapping(elem1598) + self.pretty_snapshot_mapping(elem1604) self.dedent() self.write(")") def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping): - flat1605 = self._try_flat(msg, self.pretty_snapshot_mapping) - if flat1605 is not None: - assert flat1605 is not None - self.write(flat1605) + flat1611 = self._try_flat(msg, self.pretty_snapshot_mapping) + if flat1611 is not None: + assert flat1611 is not None + self.write(flat1611) return None else: _dollar_dollar = msg - fields1601 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - assert fields1601 is not None - unwrapped_fields1602 = fields1601 - field1603 = unwrapped_fields1602[0] - self.pretty_edb_path(field1603) + fields1607 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + assert fields1607 is not None + unwrapped_fields1608 = fields1607 + field1609 = unwrapped_fields1608[0] + self.pretty_edb_path(field1609) self.write(" ") - field1604 = unwrapped_fields1602[1] - self.pretty_relation_id(field1604) + field1610 = unwrapped_fields1608[1] + self.pretty_relation_id(field1610) def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1609 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1609 is not None: - assert flat1609 is not None - self.write(flat1609) + flat1615 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1615 is not None: + assert flat1615 is not None + self.write(flat1615) return None else: - fields1606 = msg + fields1612 = msg self.write("(reads") self.indent_sexp() - if not len(fields1606) == 0: + if not len(fields1612) == 0: self.newline() - for i1608, elem1607 in enumerate(fields1606): - if (i1608 > 0): + for i1614, elem1613 in enumerate(fields1612): + if (i1614 > 0): self.newline() - self.pretty_read(elem1607) + self.pretty_read(elem1613) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1620 = self._try_flat(msg, self.pretty_read) - if flat1620 is not None: - assert flat1620 is not None - self.write(flat1620) + flat1626 = self._try_flat(msg, self.pretty_read) + if flat1626 is not None: + assert flat1626 is not None + self.write(flat1626) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("demand"): - _t1828 = _dollar_dollar.demand + _t1837 = _dollar_dollar.demand else: - _t1828 = None - deconstruct_result1618 = _t1828 - if deconstruct_result1618 is not None: - assert deconstruct_result1618 is not None - unwrapped1619 = deconstruct_result1618 - self.pretty_demand(unwrapped1619) + _t1837 = None + deconstruct_result1624 = _t1837 + if deconstruct_result1624 is not None: + assert deconstruct_result1624 is not None + unwrapped1625 = deconstruct_result1624 + self.pretty_demand(unwrapped1625) else: _dollar_dollar = msg if _dollar_dollar.HasField("output"): - _t1829 = _dollar_dollar.output + _t1838 = _dollar_dollar.output else: - _t1829 = None - deconstruct_result1616 = _t1829 - if deconstruct_result1616 is not None: - assert deconstruct_result1616 is not None - unwrapped1617 = deconstruct_result1616 - self.pretty_output(unwrapped1617) + _t1838 = None + deconstruct_result1622 = _t1838 + if deconstruct_result1622 is not None: + assert deconstruct_result1622 is not None + unwrapped1623 = deconstruct_result1622 + self.pretty_output(unwrapped1623) else: _dollar_dollar = msg if _dollar_dollar.HasField("what_if"): - _t1830 = _dollar_dollar.what_if + _t1839 = _dollar_dollar.what_if else: - _t1830 = None - deconstruct_result1614 = _t1830 - if deconstruct_result1614 is not None: - assert deconstruct_result1614 is not None - unwrapped1615 = deconstruct_result1614 - self.pretty_what_if(unwrapped1615) + _t1839 = None + deconstruct_result1620 = _t1839 + if deconstruct_result1620 is not None: + assert deconstruct_result1620 is not None + unwrapped1621 = deconstruct_result1620 + self.pretty_what_if(unwrapped1621) else: _dollar_dollar = msg if _dollar_dollar.HasField("abort"): - _t1831 = _dollar_dollar.abort + _t1840 = _dollar_dollar.abort else: - _t1831 = None - deconstruct_result1612 = _t1831 - if deconstruct_result1612 is not None: - assert deconstruct_result1612 is not None - unwrapped1613 = deconstruct_result1612 - self.pretty_abort(unwrapped1613) + _t1840 = None + deconstruct_result1618 = _t1840 + if deconstruct_result1618 is not None: + assert deconstruct_result1618 is not None + unwrapped1619 = deconstruct_result1618 + self.pretty_abort(unwrapped1619) else: _dollar_dollar = msg if _dollar_dollar.HasField("export"): - _t1832 = _dollar_dollar.export + _t1841 = _dollar_dollar.export else: - _t1832 = None - deconstruct_result1610 = _t1832 - if deconstruct_result1610 is not None: - assert deconstruct_result1610 is not None - unwrapped1611 = deconstruct_result1610 - self.pretty_export(unwrapped1611) + _t1841 = None + deconstruct_result1616 = _t1841 + if deconstruct_result1616 is not None: + assert deconstruct_result1616 is not None + unwrapped1617 = deconstruct_result1616 + self.pretty_export(unwrapped1617) else: raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1623 = self._try_flat(msg, self.pretty_demand) - if flat1623 is not None: - assert flat1623 is not None - self.write(flat1623) + flat1629 = self._try_flat(msg, self.pretty_demand) + if flat1629 is not None: + assert flat1629 is not None + self.write(flat1629) return None else: _dollar_dollar = msg - fields1621 = _dollar_dollar.relation_id - assert fields1621 is not None - unwrapped_fields1622 = fields1621 + fields1627 = _dollar_dollar.relation_id + assert fields1627 is not None + unwrapped_fields1628 = fields1627 self.write("(demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1622) + self.pretty_relation_id(unwrapped_fields1628) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1628 = self._try_flat(msg, self.pretty_output) - if flat1628 is not None: - assert flat1628 is not None - self.write(flat1628) + flat1634 = self._try_flat(msg, self.pretty_output) + if flat1634 is not None: + assert flat1634 is not None + self.write(flat1634) return None else: _dollar_dollar = msg - fields1624 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - assert fields1624 is not None - unwrapped_fields1625 = fields1624 + fields1630 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + assert fields1630 is not None + unwrapped_fields1631 = fields1630 self.write("(output") self.indent_sexp() self.newline() - field1626 = unwrapped_fields1625[0] - self.pretty_name(field1626) + field1632 = unwrapped_fields1631[0] + self.pretty_name(field1632) self.newline() - field1627 = unwrapped_fields1625[1] - self.pretty_relation_id(field1627) + field1633 = unwrapped_fields1631[1] + self.pretty_relation_id(field1633) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1633 = self._try_flat(msg, self.pretty_what_if) - if flat1633 is not None: - assert flat1633 is not None - self.write(flat1633) + flat1639 = self._try_flat(msg, self.pretty_what_if) + if flat1639 is not None: + assert flat1639 is not None + self.write(flat1639) return None else: _dollar_dollar = msg - fields1629 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - assert fields1629 is not None - unwrapped_fields1630 = fields1629 + fields1635 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + assert fields1635 is not None + unwrapped_fields1636 = fields1635 self.write("(what_if") self.indent_sexp() self.newline() - field1631 = unwrapped_fields1630[0] - self.pretty_name(field1631) + field1637 = unwrapped_fields1636[0] + self.pretty_name(field1637) self.newline() - field1632 = unwrapped_fields1630[1] - self.pretty_epoch(field1632) + field1638 = unwrapped_fields1636[1] + self.pretty_epoch(field1638) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - flat1639 = self._try_flat(msg, self.pretty_abort) - if flat1639 is not None: - assert flat1639 is not None - self.write(flat1639) + flat1645 = self._try_flat(msg, self.pretty_abort) + if flat1645 is not None: + assert flat1645 is not None + self.write(flat1645) return None else: _dollar_dollar = msg if _dollar_dollar.name != "abort": - _t1833 = _dollar_dollar.name + _t1842 = _dollar_dollar.name else: - _t1833 = None - fields1634 = (_t1833, _dollar_dollar.relation_id,) - assert fields1634 is not None - unwrapped_fields1635 = fields1634 + _t1842 = None + fields1640 = (_t1842, _dollar_dollar.relation_id,) + assert fields1640 is not None + unwrapped_fields1641 = fields1640 self.write("(abort") self.indent_sexp() - field1636 = unwrapped_fields1635[0] - if field1636 is not None: + field1642 = unwrapped_fields1641[0] + if field1642 is not None: self.newline() - assert field1636 is not None - opt_val1637 = field1636 - self.pretty_name(opt_val1637) + assert field1642 is not None + opt_val1643 = field1642 + self.pretty_name(opt_val1643) self.newline() - field1638 = unwrapped_fields1635[1] - self.pretty_relation_id(field1638) + field1644 = unwrapped_fields1641[1] + self.pretty_relation_id(field1644) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1644 = self._try_flat(msg, self.pretty_export) - if flat1644 is not None: - assert flat1644 is not None - self.write(flat1644) + flat1650 = self._try_flat(msg, self.pretty_export) + if flat1650 is not None: + assert flat1650 is not None + self.write(flat1650) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_config"): - _t1834 = _dollar_dollar.csv_config + _t1843 = _dollar_dollar.csv_config else: - _t1834 = None - deconstruct_result1642 = _t1834 - if deconstruct_result1642 is not None: - assert deconstruct_result1642 is not None - unwrapped1643 = deconstruct_result1642 + _t1843 = None + deconstruct_result1648 = _t1843 + if deconstruct_result1648 is not None: + assert deconstruct_result1648 is not None + unwrapped1649 = deconstruct_result1648 self.write("(export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped1643) + self.pretty_export_csv_config(unwrapped1649) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_config"): - _t1835 = _dollar_dollar.iceberg_config + _t1844 = _dollar_dollar.iceberg_config else: - _t1835 = None - deconstruct_result1640 = _t1835 - if deconstruct_result1640 is not None: - assert deconstruct_result1640 is not None - unwrapped1641 = deconstruct_result1640 + _t1844 = None + deconstruct_result1646 = _t1844 + if deconstruct_result1646 is not None: + assert deconstruct_result1646 is not None + unwrapped1647 = deconstruct_result1646 self.write("(export_iceberg") self.indent_sexp() self.newline() - self.pretty_export_iceberg_config(unwrapped1641) + self.pretty_export_iceberg_config(unwrapped1647) self.dedent() self.write(")") else: raise ParseError("No matching rule for export") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): - flat1655 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1655 is not None: - assert flat1655 is not None - self.write(flat1655) + flat1661 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1661 is not None: + assert flat1661 is not None + self.write(flat1661) return None else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) == 0: - _t1837 = self.deconstruct_export_csv_output_location(_dollar_dollar) - _t1836 = (_t1837, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1846 = self.deconstruct_export_csv_output_location(_dollar_dollar) + _t1845 = (_t1846, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else: - _t1836 = None - deconstruct_result1650 = _t1836 - if deconstruct_result1650 is not None: - assert deconstruct_result1650 is not None - unwrapped1651 = deconstruct_result1650 + _t1845 = None + deconstruct_result1656 = _t1845 + if deconstruct_result1656 is not None: + assert deconstruct_result1656 is not None + unwrapped1657 = deconstruct_result1656 self.write("(export_csv_config_v2") self.indent_sexp() self.newline() - field1652 = unwrapped1651[0] - self.pretty_export_csv_output_location(field1652) + field1658 = unwrapped1657[0] + self.pretty_export_csv_output_location(field1658) self.newline() - field1653 = unwrapped1651[1] - self.pretty_export_csv_source(field1653) + field1659 = unwrapped1657[1] + self.pretty_export_csv_source(field1659) self.newline() - field1654 = unwrapped1651[2] - self.pretty_csv_config(field1654) + field1660 = unwrapped1657[2] + self.pretty_csv_config(field1660) self.dedent() self.write(")") else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) != 0: - _t1839 = self.deconstruct_export_csv_config(_dollar_dollar) - _t1838 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1839,) + _t1848 = self.deconstruct_export_csv_config(_dollar_dollar) + _t1847 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1848,) else: - _t1838 = None - deconstruct_result1645 = _t1838 - if deconstruct_result1645 is not None: - assert deconstruct_result1645 is not None - unwrapped1646 = deconstruct_result1645 + _t1847 = None + deconstruct_result1651 = _t1847 + if deconstruct_result1651 is not None: + assert deconstruct_result1651 is not None + unwrapped1652 = deconstruct_result1651 self.write("(export_csv_config") self.indent_sexp() self.newline() - field1647 = unwrapped1646[0] - self.pretty_export_csv_path(field1647) + field1653 = unwrapped1652[0] + self.pretty_export_csv_path(field1653) self.newline() - field1648 = unwrapped1646[1] - self.pretty_export_csv_columns_list(field1648) + field1654 = unwrapped1652[1] + self.pretty_export_csv_columns_list(field1654) self.newline() - field1649 = unwrapped1646[2] - self.pretty_config_dict(field1649) + field1655 = unwrapped1652[2] + self.pretty_config_dict(field1655) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_config") def pretty_export_csv_output_location(self, msg: tuple[str, str]): - flat1660 = self._try_flat(msg, self.pretty_export_csv_output_location) - if flat1660 is not None: - assert flat1660 is not None - self.write(flat1660) + flat1666 = self._try_flat(msg, self.pretty_export_csv_output_location) + if flat1666 is not None: + assert flat1666 is not None + self.write(flat1666) return None else: _dollar_dollar = msg if _dollar_dollar[0] != "": - _t1840 = _dollar_dollar[0] + _t1849 = _dollar_dollar[0] else: - _t1840 = None - deconstruct_result1658 = _t1840 - if deconstruct_result1658 is not None: - assert deconstruct_result1658 is not None - unwrapped1659 = deconstruct_result1658 + _t1849 = None + deconstruct_result1664 = _t1849 + if deconstruct_result1664 is not None: + assert deconstruct_result1664 is not None + unwrapped1665 = deconstruct_result1664 self.write("(path") self.indent_sexp() self.newline() - self.write(self.format_string_value(unwrapped1659)) + self.write(self.format_string_value(unwrapped1665)) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar[1] != "": - _t1841 = _dollar_dollar[1] + _t1850 = _dollar_dollar[1] else: - _t1841 = None - deconstruct_result1656 = _t1841 - if deconstruct_result1656 is not None: - assert deconstruct_result1656 is not None - unwrapped1657 = deconstruct_result1656 + _t1850 = None + deconstruct_result1662 = _t1850 + if deconstruct_result1662 is not None: + assert deconstruct_result1662 is not None + unwrapped1663 = deconstruct_result1662 self.write("(transaction_output_name") self.indent_sexp() self.newline() - self.pretty_name(unwrapped1657) + self.pretty_name(unwrapped1663) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_output_location") def pretty_export_csv_source(self, msg: transactions_pb2.ExportCSVSource): - flat1667 = self._try_flat(msg, self.pretty_export_csv_source) - if flat1667 is not None: - assert flat1667 is not None - self.write(flat1667) + flat1673 = self._try_flat(msg, self.pretty_export_csv_source) + if flat1673 is not None: + assert flat1673 is not None + self.write(flat1673) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("gnf_columns"): - _t1842 = _dollar_dollar.gnf_columns.columns + _t1851 = _dollar_dollar.gnf_columns.columns else: - _t1842 = None - deconstruct_result1663 = _t1842 - if deconstruct_result1663 is not None: - assert deconstruct_result1663 is not None - unwrapped1664 = deconstruct_result1663 + _t1851 = None + deconstruct_result1669 = _t1851 + if deconstruct_result1669 is not None: + assert deconstruct_result1669 is not None + unwrapped1670 = deconstruct_result1669 self.write("(gnf_columns") self.indent_sexp() - if not len(unwrapped1664) == 0: + if not len(unwrapped1670) == 0: self.newline() - for i1666, elem1665 in enumerate(unwrapped1664): - if (i1666 > 0): + for i1672, elem1671 in enumerate(unwrapped1670): + if (i1672 > 0): self.newline() - self.pretty_export_csv_column(elem1665) + self.pretty_export_csv_column(elem1671) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("table_def"): - _t1843 = _dollar_dollar.table_def + _t1852 = _dollar_dollar.table_def else: - _t1843 = None - deconstruct_result1661 = _t1843 - if deconstruct_result1661 is not None: - assert deconstruct_result1661 is not None - unwrapped1662 = deconstruct_result1661 + _t1852 = None + deconstruct_result1667 = _t1852 + if deconstruct_result1667 is not None: + assert deconstruct_result1667 is not None + unwrapped1668 = deconstruct_result1667 self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped1662) + self.pretty_relation_id(unwrapped1668) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_source") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): - flat1672 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1672 is not None: - assert flat1672 is not None - self.write(flat1672) + flat1678 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1678 is not None: + assert flat1678 is not None + self.write(flat1678) return None else: _dollar_dollar = msg - fields1668 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - assert fields1668 is not None - unwrapped_fields1669 = fields1668 + fields1674 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + assert fields1674 is not None + unwrapped_fields1675 = fields1674 self.write("(column") self.indent_sexp() self.newline() - field1670 = unwrapped_fields1669[0] - self.write(self.format_string_value(field1670)) + field1676 = unwrapped_fields1675[0] + self.write(self.format_string_value(field1676)) self.newline() - field1671 = unwrapped_fields1669[1] - self.pretty_relation_id(field1671) + field1677 = unwrapped_fields1675[1] + self.pretty_relation_id(field1677) self.dedent() self.write(")") def pretty_export_csv_path(self, msg: str): - flat1674 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1674 is not None: - assert flat1674 is not None - self.write(flat1674) + flat1680 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1680 is not None: + assert flat1680 is not None + self.write(flat1680) return None else: - fields1673 = msg + fields1679 = msg self.write("(path") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1673)) + self.write(self.format_string_value(fields1679)) self.dedent() self.write(")") def pretty_export_csv_columns_list(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - flat1678 = self._try_flat(msg, self.pretty_export_csv_columns_list) - if flat1678 is not None: - assert flat1678 is not None - self.write(flat1678) + flat1684 = self._try_flat(msg, self.pretty_export_csv_columns_list) + if flat1684 is not None: + assert flat1684 is not None + self.write(flat1684) return None else: - fields1675 = msg + fields1681 = msg self.write("(columns") self.indent_sexp() - if not len(fields1675) == 0: + if not len(fields1681) == 0: self.newline() - for i1677, elem1676 in enumerate(fields1675): - if (i1677 > 0): + for i1683, elem1682 in enumerate(fields1681): + if (i1683 > 0): self.newline() - self.pretty_export_csv_column(elem1676) + self.pretty_export_csv_column(elem1682) self.dedent() self.write(")") def pretty_export_iceberg_config(self, msg: transactions_pb2.ExportIcebergConfig): - flat1687 = self._try_flat(msg, self.pretty_export_iceberg_config) - if flat1687 is not None: - assert flat1687 is not None - self.write(flat1687) + flat1693 = self._try_flat(msg, self.pretty_export_iceberg_config) + if flat1693 is not None: + assert flat1693 is not None + self.write(flat1693) return None else: _dollar_dollar = msg - _t1844 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1679 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1844,) - assert fields1679 is not None - unwrapped_fields1680 = fields1679 + _t1853 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1685 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1853,) + assert fields1685 is not None + unwrapped_fields1686 = fields1685 self.write("(export_iceberg_config") self.indent_sexp() self.newline() - field1681 = unwrapped_fields1680[0] - self.pretty_iceberg_locator(field1681) + field1687 = unwrapped_fields1686[0] + self.pretty_iceberg_locator(field1687) self.newline() - field1682 = unwrapped_fields1680[1] - self.pretty_iceberg_catalog_config(field1682) + field1688 = unwrapped_fields1686[1] + self.pretty_iceberg_catalog_config(field1688) self.newline() - field1683 = unwrapped_fields1680[2] - self.pretty_export_iceberg_table_def(field1683) + field1689 = unwrapped_fields1686[2] + self.pretty_export_iceberg_table_def(field1689) self.newline() - field1684 = unwrapped_fields1680[3] - self.pretty_iceberg_table_properties(field1684) - field1685 = unwrapped_fields1680[4] - if field1685 is not None: + field1690 = unwrapped_fields1686[3] + self.pretty_iceberg_table_properties(field1690) + field1691 = unwrapped_fields1686[4] + if field1691 is not None: self.newline() - assert field1685 is not None - opt_val1686 = field1685 - self.pretty_config_dict(opt_val1686) + assert field1691 is not None + opt_val1692 = field1691 + self.pretty_config_dict(opt_val1692) self.dedent() self.write(")") def pretty_export_iceberg_table_def(self, msg: logic_pb2.RelationId): - flat1689 = self._try_flat(msg, self.pretty_export_iceberg_table_def) - if flat1689 is not None: - assert flat1689 is not None - self.write(flat1689) + flat1695 = self._try_flat(msg, self.pretty_export_iceberg_table_def) + if flat1695 is not None: + assert flat1695 is not None + self.write(flat1695) return None else: - fields1688 = msg + fields1694 = msg self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(fields1688) + self.pretty_relation_id(fields1694) self.dedent() self.write(")") def pretty_iceberg_table_properties(self, msg: Sequence[tuple[str, str]]): - flat1693 = self._try_flat(msg, self.pretty_iceberg_table_properties) - if flat1693 is not None: - assert flat1693 is not None - self.write(flat1693) + flat1699 = self._try_flat(msg, self.pretty_iceberg_table_properties) + if flat1699 is not None: + assert flat1699 is not None + self.write(flat1699) return None else: - fields1690 = msg + fields1696 = msg self.write("(table_properties") self.indent_sexp() - if not len(fields1690) == 0: + if not len(fields1696) == 0: self.newline() - for i1692, elem1691 in enumerate(fields1690): - if (i1692 > 0): + for i1698, elem1697 in enumerate(fields1696): + if (i1698 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1691) + self.pretty_iceberg_property_entry(elem1697) self.dedent() self.write(")") @@ -4636,8 +4667,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1898 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1898) + _t1907 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1907) self.write(" ") self.write(self.format_string_value(msg.orig_names[_idx])) self.write(")") diff --git a/sdks/python/src/lqp/proto/v1/logic_pb2.py b/sdks/python/src/lqp/proto/v1/logic_pb2.py index a9401c43..192085e8 100644 --- a/sdks/python/src/lqp/proto/v1/logic_pb2.py +++ b/sdks/python/src/lqp/proto/v1/logic_pb2.py @@ -24,7 +24,7 @@ -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1frelationalai/lqp/v1/logic.proto\x12\x13relationalai.lqp.v1\"\x83\x02\n\x0b\x44\x65\x63laration\x12,\n\x03\x64\x65\x66\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.DefH\x00R\x03\x64\x65\x66\x12>\n\talgorithm\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.AlgorithmH\x00R\talgorithm\x12\x41\n\nconstraint\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.ConstraintH\x00R\nconstraint\x12/\n\x04\x64\x61ta\x18\x04 \x01(\x0b\x32\x19.relationalai.lqp.v1.DataH\x00R\x04\x64\x61taB\x12\n\x10\x64\x65\x63laration_type\"\xa6\x01\n\x03\x44\x65\x66\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xb6\x01\n\nConstraint\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12`\n\x15\x66unctional_dependency\x18\x01 \x01(\x0b\x32).relationalai.lqp.v1.FunctionalDependencyH\x00R\x14\x66unctionalDependencyB\x11\n\x0f\x63onstraint_type\"\xae\x01\n\x14\x46unctionalDependency\x12\x36\n\x05guard\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x05guard\x12,\n\x04keys\x18\x02 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x04keys\x12\x30\n\x06values\x18\x03 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x06values\"\xab\x01\n\tAlgorithm\x12\x37\n\x06global\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x06global\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"H\n\x06Script\x12>\n\nconstructs\x18\x01 \x03(\x0b\x32\x1e.relationalai.lqp.v1.ConstructR\nconstructs\"\x94\x01\n\tConstruct\x12/\n\x04loop\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.LoopH\x00R\x04loop\x12\x44\n\x0binstruction\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.InstructionH\x00R\x0binstructionB\x10\n\x0e\x63onstruct_type\"\xa3\x01\n\x04Loop\x12\x34\n\x04init\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.InstructionR\x04init\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xc2\x02\n\x0bInstruction\x12\x35\n\x06\x61ssign\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.AssignH\x00R\x06\x61ssign\x12\x35\n\x06upsert\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.UpsertH\x00R\x06upsert\x12\x32\n\x05\x62reak\x18\x03 \x01(\x0b\x32\x1a.relationalai.lqp.v1.BreakH\x00R\x05\x62reak\x12?\n\nmonoid_def\x18\x05 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MonoidDefH\x00R\tmonoidDef\x12<\n\tmonus_def\x18\x06 \x01(\x0b\x32\x1d.relationalai.lqp.v1.MonusDefH\x00R\x08monusDefB\x0c\n\ninstr_typeJ\x04\x08\x04\x10\x05\"\xa9\x01\n\x06\x41ssign\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xca\x01\n\x06Upsert\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x04 \x01(\x03R\nvalueArity\"\xa8\x01\n\x05\x42reak\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\x82\x02\n\tMonoidDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x81\x02\n\x08MonusDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x92\x02\n\x06Monoid\x12<\n\tor_monoid\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.OrMonoidH\x00R\x08orMonoid\x12?\n\nmin_monoid\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MinMonoidH\x00R\tminMonoid\x12?\n\nmax_monoid\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MaxMonoidH\x00R\tmaxMonoid\x12?\n\nsum_monoid\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.SumMonoidH\x00R\tsumMonoidB\x07\n\x05value\"\n\n\x08OrMonoid\":\n\tMinMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tMaxMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tSumMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"d\n\x07\x42inding\x12*\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarR\x03var\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"s\n\x0b\x41\x62straction\x12\x30\n\x04vars\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.BindingR\x04vars\x12\x32\n\x05value\x18\x02 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x05value\"\x83\x05\n\x07\x46ormula\x12\x35\n\x06\x65xists\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExistsH\x00R\x06\x65xists\x12\x35\n\x06reduce\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ReduceH\x00R\x06reduce\x12\x44\n\x0b\x63onjunction\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.ConjunctionH\x00R\x0b\x63onjunction\x12\x44\n\x0b\x64isjunction\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.DisjunctionH\x00R\x0b\x64isjunction\x12,\n\x03not\x18\x05 \x01(\x0b\x32\x18.relationalai.lqp.v1.NotH\x00R\x03not\x12,\n\x03\x66\x66i\x18\x06 \x01(\x0b\x32\x18.relationalai.lqp.v1.FFIH\x00R\x03\x66\x66i\x12/\n\x04\x61tom\x18\x07 \x01(\x0b\x32\x19.relationalai.lqp.v1.AtomH\x00R\x04\x61tom\x12\x35\n\x06pragma\x18\x08 \x01(\x0b\x32\x1b.relationalai.lqp.v1.PragmaH\x00R\x06pragma\x12>\n\tprimitive\x18\t \x01(\x0b\x32\x1e.relationalai.lqp.v1.PrimitiveH\x00R\tprimitive\x12\x39\n\x08rel_atom\x18\n \x01(\x0b\x32\x1c.relationalai.lqp.v1.RelAtomH\x00R\x07relAtom\x12/\n\x04\x63\x61st\x18\x0b \x01(\x0b\x32\x19.relationalai.lqp.v1.CastH\x00R\x04\x63\x61stB\x0e\n\x0c\x66ormula_type\">\n\x06\x45xists\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\"\xa1\x01\n\x06Reduce\x12\x30\n\x02op\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x02op\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"?\n\x0b\x43onjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"?\n\x0b\x44isjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"5\n\x03Not\x12.\n\x03\x61rg\x18\x01 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x03\x61rg\"\x80\x01\n\x03\x46\x46I\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x34\n\x04\x61rgs\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x61rgs\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"l\n\x04\x41tom\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"M\n\x06Pragma\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"S\n\tPrimitive\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"Q\n\x07RelAtom\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"j\n\x04\x43\x61st\x12/\n\x05input\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05input\x12\x31\n\x06result\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x06result\"\x96\x01\n\x07RelTerm\x12I\n\x11specialized_value\x18\x01 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x10specializedValue\x12/\n\x04term\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermH\x00R\x04termB\x0f\n\rrel_term_type\"{\n\x04Term\x12,\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarH\x00R\x03var\x12\x38\n\x08\x63onstant\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x08\x63onstantB\x0b\n\tterm_type\"\x19\n\x03Var\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"O\n\tAttribute\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12.\n\x04\x61rgs\x18\x02 \x03(\x0b\x32\x1a.relationalai.lqp.v1.ValueR\x04\x61rgs\"\x93\x02\n\x04\x44\x61ta\x12,\n\x03\x65\x64\x62\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.EDBH\x00R\x03\x65\x64\x62\x12N\n\x0f\x62\x65tree_relation\x18\x02 \x01(\x0b\x32#.relationalai.lqp.v1.BeTreeRelationH\x00R\x0e\x62\x65treeRelation\x12\x39\n\x08\x63sv_data\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.CSVDataH\x00R\x07\x63svData\x12\x45\n\x0ciceberg_data\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.IcebergDataH\x00R\x0bicebergDataB\x0b\n\tdata_type\"\x88\x01\n\x03\x45\x44\x42\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x12\n\x04path\x18\x02 \x03(\tR\x04path\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05types\"\x8b\x01\n\x0e\x42\x65TreeRelation\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x44\n\rrelation_info\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.BeTreeInfoR\x0crelationInfo\"\x9f\x02\n\nBeTreeInfo\x12\x36\n\tkey_types\x18\x01 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x08keyTypes\x12:\n\x0bvalue_types\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\nvalueTypes\x12H\n\x0estorage_config\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.BeTreeConfigR\rstorageConfig\x12M\n\x10relation_locator\x18\x05 \x01(\x0b\x32\".relationalai.lqp.v1.BeTreeLocatorR\x0frelationLocatorJ\x04\x08\x03\x10\x04\"\x81\x01\n\x0c\x42\x65TreeConfig\x12\x18\n\x07\x65psilon\x18\x01 \x01(\x01R\x07\x65psilon\x12\x1d\n\nmax_pivots\x18\x02 \x01(\x03R\tmaxPivots\x12\x1d\n\nmax_deltas\x18\x03 \x01(\x03R\tmaxDeltas\x12\x19\n\x08max_leaf\x18\x04 \x01(\x03R\x07maxLeaf\"\xca\x01\n\rBeTreeLocator\x12\x44\n\x0broot_pageid\x18\x01 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\nrootPageid\x12!\n\x0binline_data\x18\x04 \x01(\x0cH\x00R\ninlineData\x12#\n\relement_count\x18\x02 \x01(\x03R\x0c\x65lementCount\x12\x1f\n\x0btree_height\x18\x03 \x01(\x03R\ntreeHeightB\n\n\x08location\"\xcf\x01\n\x12StorageIntegration\x12\x1a\n\x08provider\x18\x01 \x01(\tR\x08provider\x12&\n\x0f\x61zure_sas_token\x18\x02 \x01(\tR\razureSasToken\x12\x1b\n\ts3_region\x18\x03 \x01(\tR\x08s3Region\x12\'\n\x10s3_access_key_id\x18\x04 \x01(\tR\rs3AccessKeyId\x12/\n\x14s3_secret_access_key\x18\x05 \x01(\tR\x11s3SecretAccessKey\"P\n\x0bNamedColumn\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"\x88\x01\n\x0eTargetRelation\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x38\n\x06values\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.NamedColumnR\x06values\"M\n\x0cPlainTargets\x12=\n\x07targets\x18\x01 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07targets\"\x8a\x01\n\nCDCTargets\x12=\n\x07inserts\x18\x01 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07inserts\x12=\n\x07\x64\x65letes\x18\x02 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07\x64\x65letes\"\xbf\x01\n\x0fTargetRelations\x12\x34\n\x04keys\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.NamedColumnR\x04keys\x12\x39\n\x05plain\x18\x02 \x01(\x0b\x32!.relationalai.lqp.v1.PlainTargetsH\x00R\x05plain\x12\x33\n\x03\x63\x64\x63\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CDCTargetsH\x00R\x03\x63\x64\x63\x42\x06\n\x04\x62ody\"\xa1\x02\n\x07\x43SVData\x12\x39\n\x07locator\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CSVLocatorR\x07locator\x12\x36\n\x06\x63onfig\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.GNFColumnR\x07\x63olumns\x12\x12\n\x04\x61sof\x18\x04 \x01(\tR\x04\x61sof\x12G\n\trelations\x18\x05 \x01(\x0b\x32$.relationalai.lqp.v1.TargetRelationsH\x00R\trelations\x88\x01\x01\x42\x0c\n\n_relations\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\x86\x04\n\tCSVConfig\x12\x1d\n\nheader_row\x18\x01 \x01(\x05R\theaderRow\x12\x12\n\x04skip\x18\x02 \x01(\x03R\x04skip\x12\x19\n\x08new_line\x18\x03 \x01(\tR\x07newLine\x12\x1c\n\tdelimiter\x18\x04 \x01(\tR\tdelimiter\x12\x1c\n\tquotechar\x18\x05 \x01(\tR\tquotechar\x12\x1e\n\nescapechar\x18\x06 \x01(\tR\nescapechar\x12\x18\n\x07\x63omment\x18\x07 \x01(\tR\x07\x63omment\x12\'\n\x0fmissing_strings\x18\x08 \x03(\tR\x0emissingStrings\x12+\n\x11\x64\x65\x63imal_separator\x18\t \x01(\tR\x10\x64\x65\x63imalSeparator\x12\x1a\n\x08\x65ncoding\x18\n \x01(\tR\x08\x65ncoding\x12 \n\x0b\x63ompression\x18\x0b \x01(\tR\x0b\x63ompression\x12*\n\x11partition_size_mb\x18\x0c \x01(\x03R\x0fpartitionSizeMb\x12]\n\x13storage_integration\x18\r \x01(\x0b\x32\'.relationalai.lqp.v1.StorageIntegrationH\x00R\x12storageIntegration\x88\x01\x01\x42\x16\n\x14_storage_integration\"\xe0\x02\n\x0bIcebergData\x12=\n\x07locator\x18\x01 \x01(\x0b\x32#.relationalai.lqp.v1.IcebergLocatorR\x07locator\x12\x41\n\x06\x63onfig\x18\x02 \x01(\x0b\x32).relationalai.lqp.v1.IcebergCatalogConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.GNFColumnR\x07\x63olumns\x12(\n\rfrom_snapshot\x18\x04 \x01(\tH\x00R\x0c\x66romSnapshot\x88\x01\x01\x12$\n\x0bto_snapshot\x18\x05 \x01(\tH\x01R\ntoSnapshot\x88\x01\x01\x12#\n\rreturns_delta\x18\x06 \x01(\x08R\x0creturnsDeltaB\x10\n\x0e_from_snapshotB\x0e\n\x0c_to_snapshot\"k\n\x0eIcebergLocator\x12\x1d\n\ntable_name\x18\x01 \x01(\tR\ttableName\x12\x1c\n\tnamespace\x18\x02 \x03(\tR\tnamespace\x12\x1c\n\twarehouse\x18\x03 \x01(\tR\twarehouse\"\xa1\x03\n\x14IcebergCatalogConfig\x12\x1f\n\x0b\x63\x61talog_uri\x18\x01 \x01(\tR\ncatalogUri\x12\x19\n\x05scope\x18\x02 \x01(\tH\x00R\x05scope\x88\x01\x01\x12Y\n\nproperties\x18\x03 \x03(\x0b\x32\x39.relationalai.lqp.v1.IcebergCatalogConfig.PropertiesEntryR\nproperties\x12\x66\n\x0f\x61uth_properties\x18\x04 \x03(\x0b\x32=.relationalai.lqp.v1.IcebergCatalogConfig.AuthPropertiesEntryR\x0e\x61uthProperties\x1a=\n\x0fPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a\x41\n\x13\x41uthPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\x08\n\x06_scope\"\xae\x01\n\tGNFColumn\x12\x1f\n\x0b\x63olumn_path\x18\x01 \x03(\tR\ncolumnPath\x12\x41\n\ttarget_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdH\x00R\x08targetId\x88\x01\x01\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05typesB\x0c\n\n_target_id\"<\n\nRelationId\x12\x15\n\x06id_low\x18\x01 \x01(\x06R\x05idLow\x12\x17\n\x07id_high\x18\x02 \x01(\x06R\x06idHigh\"\xd5\x07\n\x04Type\x12Q\n\x10unspecified_type\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.UnspecifiedTypeH\x00R\x0funspecifiedType\x12\x42\n\x0bstring_type\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.StringTypeH\x00R\nstringType\x12\x39\n\x08int_type\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.IntTypeH\x00R\x07intType\x12?\n\nfloat_type\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.FloatTypeH\x00R\tfloatType\x12\x45\n\x0cuint128_type\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.UInt128TypeH\x00R\x0buint128Type\x12\x42\n\x0bint128_type\x18\x06 \x01(\x0b\x32\x1f.relationalai.lqp.v1.Int128TypeH\x00R\nint128Type\x12<\n\tdate_type\x18\x07 \x01(\x0b\x32\x1d.relationalai.lqp.v1.DateTypeH\x00R\x08\x64\x61teType\x12H\n\rdatetime_type\x18\x08 \x01(\x0b\x32!.relationalai.lqp.v1.DateTimeTypeH\x00R\x0c\x64\x61tetimeType\x12\x45\n\x0cmissing_type\x18\t \x01(\x0b\x32 .relationalai.lqp.v1.MissingTypeH\x00R\x0bmissingType\x12\x45\n\x0c\x64\x65\x63imal_type\x18\n \x01(\x0b\x32 .relationalai.lqp.v1.DecimalTypeH\x00R\x0b\x64\x65\x63imalType\x12\x45\n\x0c\x62oolean_type\x18\x0b \x01(\x0b\x32 .relationalai.lqp.v1.BooleanTypeH\x00R\x0b\x62ooleanType\x12?\n\nint32_type\x18\x0c \x01(\x0b\x32\x1e.relationalai.lqp.v1.Int32TypeH\x00R\tint32Type\x12\x45\n\x0c\x66loat32_type\x18\r \x01(\x0b\x32 .relationalai.lqp.v1.Float32TypeH\x00R\x0b\x66loat32Type\x12\x42\n\x0buint32_type\x18\x0e \x01(\x0b\x32\x1f.relationalai.lqp.v1.UInt32TypeH\x00R\nuint32TypeB\x06\n\x04type\"\x11\n\x0fUnspecifiedType\"\x0c\n\nStringType\"\t\n\x07IntType\"\x0b\n\tFloatType\"\r\n\x0bUInt128Type\"\x0c\n\nInt128Type\"\n\n\x08\x44\x61teType\"\x0e\n\x0c\x44\x61teTimeType\"\r\n\x0bMissingType\"A\n\x0b\x44\x65\x63imalType\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\"\r\n\x0b\x42ooleanType\"\x0b\n\tInt32Type\"\r\n\x0b\x46loat32Type\"\x0c\n\nUInt32Type\"\xc0\x05\n\x05Value\x12#\n\x0cstring_value\x18\x01 \x01(\tH\x00R\x0bstringValue\x12\x1d\n\tint_value\x18\x02 \x01(\x03H\x00R\x08intValue\x12!\n\x0b\x66loat_value\x18\x03 \x01(\x01H\x00R\nfloatValue\x12H\n\ruint128_value\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\x0cuint128Value\x12\x45\n\x0cint128_value\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueH\x00R\x0bint128Value\x12H\n\rmissing_value\x18\x06 \x01(\x0b\x32!.relationalai.lqp.v1.MissingValueH\x00R\x0cmissingValue\x12?\n\ndate_value\x18\x07 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DateValueH\x00R\tdateValue\x12K\n\x0e\x64\x61tetime_value\x18\x08 \x01(\x0b\x32\".relationalai.lqp.v1.DateTimeValueH\x00R\rdatetimeValue\x12H\n\rdecimal_value\x18\t \x01(\x0b\x32!.relationalai.lqp.v1.DecimalValueH\x00R\x0c\x64\x65\x63imalValue\x12%\n\rboolean_value\x18\n \x01(\x08H\x00R\x0c\x62ooleanValue\x12!\n\x0bint32_value\x18\x0b \x01(\x05H\x00R\nint32Value\x12%\n\rfloat32_value\x18\x0c \x01(\x02H\x00R\x0c\x66loat32Value\x12#\n\x0cuint32_value\x18\r \x01(\rH\x00R\x0buint32ValueB\x07\n\x05value\"4\n\x0cUInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"3\n\x0bInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"\x0e\n\x0cMissingValue\"G\n\tDateValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\"\xb1\x01\n\rDateTimeValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\x12\x12\n\x04hour\x18\x04 \x01(\x05R\x04hour\x12\x16\n\x06minute\x18\x05 \x01(\x05R\x06minute\x12\x16\n\x06second\x18\x06 \x01(\x05R\x06second\x12 \n\x0bmicrosecond\x18\x07 \x01(\x05R\x0bmicrosecond\"z\n\x0c\x44\x65\x63imalValue\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\x12\x36\n\x05value\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueR\x05valueBCZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1frelationalai/lqp/v1/logic.proto\x12\x13relationalai.lqp.v1\"\x83\x02\n\x0b\x44\x65\x63laration\x12,\n\x03\x64\x65\x66\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.DefH\x00R\x03\x64\x65\x66\x12>\n\talgorithm\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.AlgorithmH\x00R\talgorithm\x12\x41\n\nconstraint\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.ConstraintH\x00R\nconstraint\x12/\n\x04\x64\x61ta\x18\x04 \x01(\x0b\x32\x19.relationalai.lqp.v1.DataH\x00R\x04\x64\x61taB\x12\n\x10\x64\x65\x63laration_type\"\xa6\x01\n\x03\x44\x65\x66\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xb6\x01\n\nConstraint\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12`\n\x15\x66unctional_dependency\x18\x01 \x01(\x0b\x32).relationalai.lqp.v1.FunctionalDependencyH\x00R\x14\x66unctionalDependencyB\x11\n\x0f\x63onstraint_type\"\xae\x01\n\x14\x46unctionalDependency\x12\x36\n\x05guard\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x05guard\x12,\n\x04keys\x18\x02 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x04keys\x12\x30\n\x06values\x18\x03 \x03(\x0b\x32\x18.relationalai.lqp.v1.VarR\x06values\"\xab\x01\n\tAlgorithm\x12\x37\n\x06global\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x06global\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"H\n\x06Script\x12>\n\nconstructs\x18\x01 \x03(\x0b\x32\x1e.relationalai.lqp.v1.ConstructR\nconstructs\"\x94\x01\n\tConstruct\x12/\n\x04loop\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.LoopH\x00R\x04loop\x12\x44\n\x0binstruction\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.InstructionH\x00R\x0binstructionB\x10\n\x0e\x63onstruct_type\"\xa3\x01\n\x04Loop\x12\x34\n\x04init\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.InstructionR\x04init\x12/\n\x04\x62ody\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ScriptR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xc2\x02\n\x0bInstruction\x12\x35\n\x06\x61ssign\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.AssignH\x00R\x06\x61ssign\x12\x35\n\x06upsert\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.UpsertH\x00R\x06upsert\x12\x32\n\x05\x62reak\x18\x03 \x01(\x0b\x32\x1a.relationalai.lqp.v1.BreakH\x00R\x05\x62reak\x12?\n\nmonoid_def\x18\x05 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MonoidDefH\x00R\tmonoidDef\x12<\n\tmonus_def\x18\x06 \x01(\x0b\x32\x1d.relationalai.lqp.v1.MonusDefH\x00R\x08monusDefB\x0c\n\ninstr_typeJ\x04\x08\x04\x10\x05\"\xa9\x01\n\x06\x41ssign\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\xca\x01\n\x06Upsert\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x04 \x01(\x03R\nvalueArity\"\xa8\x01\n\x05\x42reak\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\"\x82\x02\n\tMonoidDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x81\x02\n\x08MonusDef\x12\x33\n\x06monoid\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.MonoidR\x06monoid\x12\x33\n\x04name\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12\x34\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32\x1e.relationalai.lqp.v1.AttributeR\x05\x61ttrs\x12\x1f\n\x0bvalue_arity\x18\x05 \x01(\x03R\nvalueArity\"\x92\x02\n\x06Monoid\x12<\n\tor_monoid\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.OrMonoidH\x00R\x08orMonoid\x12?\n\nmin_monoid\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MinMonoidH\x00R\tminMonoid\x12?\n\nmax_monoid\x18\x03 \x01(\x0b\x32\x1e.relationalai.lqp.v1.MaxMonoidH\x00R\tmaxMonoid\x12?\n\nsum_monoid\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.SumMonoidH\x00R\tsumMonoidB\x07\n\x05value\"\n\n\x08OrMonoid\":\n\tMinMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tMaxMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\":\n\tSumMonoid\x12-\n\x04type\x18\x01 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"d\n\x07\x42inding\x12*\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarR\x03var\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"s\n\x0b\x41\x62straction\x12\x30\n\x04vars\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.BindingR\x04vars\x12\x32\n\x05value\x18\x02 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x05value\"\x83\x05\n\x07\x46ormula\x12\x35\n\x06\x65xists\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExistsH\x00R\x06\x65xists\x12\x35\n\x06reduce\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ReduceH\x00R\x06reduce\x12\x44\n\x0b\x63onjunction\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.ConjunctionH\x00R\x0b\x63onjunction\x12\x44\n\x0b\x64isjunction\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.DisjunctionH\x00R\x0b\x64isjunction\x12,\n\x03not\x18\x05 \x01(\x0b\x32\x18.relationalai.lqp.v1.NotH\x00R\x03not\x12,\n\x03\x66\x66i\x18\x06 \x01(\x0b\x32\x18.relationalai.lqp.v1.FFIH\x00R\x03\x66\x66i\x12/\n\x04\x61tom\x18\x07 \x01(\x0b\x32\x19.relationalai.lqp.v1.AtomH\x00R\x04\x61tom\x12\x35\n\x06pragma\x18\x08 \x01(\x0b\x32\x1b.relationalai.lqp.v1.PragmaH\x00R\x06pragma\x12>\n\tprimitive\x18\t \x01(\x0b\x32\x1e.relationalai.lqp.v1.PrimitiveH\x00R\tprimitive\x12\x39\n\x08rel_atom\x18\n \x01(\x0b\x32\x1c.relationalai.lqp.v1.RelAtomH\x00R\x07relAtom\x12/\n\x04\x63\x61st\x18\x0b \x01(\x0b\x32\x19.relationalai.lqp.v1.CastH\x00R\x04\x63\x61stB\x0e\n\x0c\x66ormula_type\">\n\x06\x45xists\x12\x34\n\x04\x62ody\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\"\xa1\x01\n\x06Reduce\x12\x30\n\x02op\x18\x01 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x02op\x12\x34\n\x04\x62ody\x18\x02 \x01(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x62ody\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"?\n\x0b\x43onjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"?\n\x0b\x44isjunction\x12\x30\n\x04\x61rgs\x18\x01 \x03(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x04\x61rgs\"5\n\x03Not\x12.\n\x03\x61rg\x18\x01 \x01(\x0b\x32\x1c.relationalai.lqp.v1.FormulaR\x03\x61rg\"\x80\x01\n\x03\x46\x46I\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x34\n\x04\x61rgs\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.AbstractionR\x04\x61rgs\x12/\n\x05terms\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"l\n\x04\x41tom\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"M\n\x06Pragma\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12/\n\x05terms\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05terms\"S\n\tPrimitive\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"Q\n\x07RelAtom\x12\x12\n\x04name\x18\x03 \x01(\tR\x04name\x12\x32\n\x05terms\x18\x02 \x03(\x0b\x32\x1c.relationalai.lqp.v1.RelTermR\x05terms\"j\n\x04\x43\x61st\x12/\n\x05input\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x05input\x12\x31\n\x06result\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermR\x06result\"\x96\x01\n\x07RelTerm\x12I\n\x11specialized_value\x18\x01 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x10specializedValue\x12/\n\x04term\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TermH\x00R\x04termB\x0f\n\rrel_term_type\"{\n\x04Term\x12,\n\x03var\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.VarH\x00R\x03var\x12\x38\n\x08\x63onstant\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.ValueH\x00R\x08\x63onstantB\x0b\n\tterm_type\"\x19\n\x03Var\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\"O\n\tAttribute\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12.\n\x04\x61rgs\x18\x02 \x03(\x0b\x32\x1a.relationalai.lqp.v1.ValueR\x04\x61rgs\"\x93\x02\n\x04\x44\x61ta\x12,\n\x03\x65\x64\x62\x18\x01 \x01(\x0b\x32\x18.relationalai.lqp.v1.EDBH\x00R\x03\x65\x64\x62\x12N\n\x0f\x62\x65tree_relation\x18\x02 \x01(\x0b\x32#.relationalai.lqp.v1.BeTreeRelationH\x00R\x0e\x62\x65treeRelation\x12\x39\n\x08\x63sv_data\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.CSVDataH\x00R\x07\x63svData\x12\x45\n\x0ciceberg_data\x18\x04 \x01(\x0b\x32 .relationalai.lqp.v1.IcebergDataH\x00R\x0bicebergDataB\x0b\n\tdata_type\"\x88\x01\n\x03\x45\x44\x42\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x12\n\x04path\x18\x02 \x03(\tR\x04path\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05types\"\x8b\x01\n\x0e\x42\x65TreeRelation\x12\x33\n\x04name\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x04name\x12\x44\n\rrelation_info\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.BeTreeInfoR\x0crelationInfo\"\x9f\x02\n\nBeTreeInfo\x12\x36\n\tkey_types\x18\x01 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x08keyTypes\x12:\n\x0bvalue_types\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\nvalueTypes\x12H\n\x0estorage_config\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.BeTreeConfigR\rstorageConfig\x12M\n\x10relation_locator\x18\x05 \x01(\x0b\x32\".relationalai.lqp.v1.BeTreeLocatorR\x0frelationLocatorJ\x04\x08\x03\x10\x04\"\x81\x01\n\x0c\x42\x65TreeConfig\x12\x18\n\x07\x65psilon\x18\x01 \x01(\x01R\x07\x65psilon\x12\x1d\n\nmax_pivots\x18\x02 \x01(\x03R\tmaxPivots\x12\x1d\n\nmax_deltas\x18\x03 \x01(\x03R\tmaxDeltas\x12\x19\n\x08max_leaf\x18\x04 \x01(\x03R\x07maxLeaf\"\xca\x01\n\rBeTreeLocator\x12\x44\n\x0broot_pageid\x18\x01 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\nrootPageid\x12!\n\x0binline_data\x18\x04 \x01(\x0cH\x00R\ninlineData\x12#\n\relement_count\x18\x02 \x01(\x03R\x0c\x65lementCount\x12\x1f\n\x0btree_height\x18\x03 \x01(\x03R\ntreeHeightB\n\n\x08location\"\xcf\x01\n\x12StorageIntegration\x12\x1a\n\x08provider\x18\x01 \x01(\tR\x08provider\x12&\n\x0f\x61zure_sas_token\x18\x02 \x01(\tR\razureSasToken\x12\x1b\n\ts3_region\x18\x03 \x01(\tR\x08s3Region\x12\'\n\x10s3_access_key_id\x18\x04 \x01(\tR\rs3AccessKeyId\x12/\n\x14s3_secret_access_key\x18\x05 \x01(\tR\x11s3SecretAccessKey\"P\n\x0bNamedColumn\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12-\n\x04type\x18\x02 \x01(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x04type\"\x88\x01\n\x0eTargetRelation\x12<\n\ttarget_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08targetId\x12\x38\n\x06values\x18\x02 \x03(\x0b\x32 .relationalai.lqp.v1.NamedColumnR\x06values\"M\n\x0cPlainTargets\x12=\n\x07targets\x18\x01 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07targets\"\x8a\x01\n\nCDCTargets\x12=\n\x07inserts\x18\x01 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07inserts\x12=\n\x07\x64\x65letes\x18\x02 \x03(\x0b\x32#.relationalai.lqp.v1.TargetRelationR\x07\x64\x65letes\"\xe4\x01\n\x0fTargetRelations\x12\x34\n\x04keys\x18\x01 \x03(\x0b\x32 .relationalai.lqp.v1.NamedColumnR\x04keys\x12\x39\n\x05plain\x18\x02 \x01(\x0b\x32!.relationalai.lqp.v1.PlainTargetsH\x00R\x05plain\x12\x33\n\x03\x63\x64\x63\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CDCTargetsH\x00R\x03\x63\x64\x63\x12#\n\rsynthetic_key\x18\x04 \x01(\x08R\x0csyntheticKeyB\x06\n\x04\x62ody\"\xa1\x02\n\x07\x43SVData\x12\x39\n\x07locator\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.CSVLocatorR\x07locator\x12\x36\n\x06\x63onfig\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.GNFColumnR\x07\x63olumns\x12\x12\n\x04\x61sof\x18\x04 \x01(\tR\x04\x61sof\x12G\n\trelations\x18\x05 \x01(\x0b\x32$.relationalai.lqp.v1.TargetRelationsH\x00R\trelations\x88\x01\x01\x42\x0c\n\n_relations\"C\n\nCSVLocator\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05paths\x12\x1f\n\x0binline_data\x18\x02 \x01(\x0cR\ninlineData\"\x86\x04\n\tCSVConfig\x12\x1d\n\nheader_row\x18\x01 \x01(\x05R\theaderRow\x12\x12\n\x04skip\x18\x02 \x01(\x03R\x04skip\x12\x19\n\x08new_line\x18\x03 \x01(\tR\x07newLine\x12\x1c\n\tdelimiter\x18\x04 \x01(\tR\tdelimiter\x12\x1c\n\tquotechar\x18\x05 \x01(\tR\tquotechar\x12\x1e\n\nescapechar\x18\x06 \x01(\tR\nescapechar\x12\x18\n\x07\x63omment\x18\x07 \x01(\tR\x07\x63omment\x12\'\n\x0fmissing_strings\x18\x08 \x03(\tR\x0emissingStrings\x12+\n\x11\x64\x65\x63imal_separator\x18\t \x01(\tR\x10\x64\x65\x63imalSeparator\x12\x1a\n\x08\x65ncoding\x18\n \x01(\tR\x08\x65ncoding\x12 \n\x0b\x63ompression\x18\x0b \x01(\tR\x0b\x63ompression\x12*\n\x11partition_size_mb\x18\x0c \x01(\x03R\x0fpartitionSizeMb\x12]\n\x13storage_integration\x18\r \x01(\x0b\x32\'.relationalai.lqp.v1.StorageIntegrationH\x00R\x12storageIntegration\x88\x01\x01\x42\x16\n\x14_storage_integration\"\xe0\x02\n\x0bIcebergData\x12=\n\x07locator\x18\x01 \x01(\x0b\x32#.relationalai.lqp.v1.IcebergLocatorR\x07locator\x12\x41\n\x06\x63onfig\x18\x02 \x01(\x0b\x32).relationalai.lqp.v1.IcebergCatalogConfigR\x06\x63onfig\x12\x38\n\x07\x63olumns\x18\x03 \x03(\x0b\x32\x1e.relationalai.lqp.v1.GNFColumnR\x07\x63olumns\x12(\n\rfrom_snapshot\x18\x04 \x01(\tH\x00R\x0c\x66romSnapshot\x88\x01\x01\x12$\n\x0bto_snapshot\x18\x05 \x01(\tH\x01R\ntoSnapshot\x88\x01\x01\x12#\n\rreturns_delta\x18\x06 \x01(\x08R\x0creturnsDeltaB\x10\n\x0e_from_snapshotB\x0e\n\x0c_to_snapshot\"k\n\x0eIcebergLocator\x12\x1d\n\ntable_name\x18\x01 \x01(\tR\ttableName\x12\x1c\n\tnamespace\x18\x02 \x03(\tR\tnamespace\x12\x1c\n\twarehouse\x18\x03 \x01(\tR\twarehouse\"\xa1\x03\n\x14IcebergCatalogConfig\x12\x1f\n\x0b\x63\x61talog_uri\x18\x01 \x01(\tR\ncatalogUri\x12\x19\n\x05scope\x18\x02 \x01(\tH\x00R\x05scope\x88\x01\x01\x12Y\n\nproperties\x18\x03 \x03(\x0b\x32\x39.relationalai.lqp.v1.IcebergCatalogConfig.PropertiesEntryR\nproperties\x12\x66\n\x0f\x61uth_properties\x18\x04 \x03(\x0b\x32=.relationalai.lqp.v1.IcebergCatalogConfig.AuthPropertiesEntryR\x0e\x61uthProperties\x1a=\n\x0fPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x1a\x41\n\x13\x41uthPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\x08\n\x06_scope\"\xae\x01\n\tGNFColumn\x12\x1f\n\x0b\x63olumn_path\x18\x01 \x03(\tR\ncolumnPath\x12\x41\n\ttarget_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdH\x00R\x08targetId\x88\x01\x01\x12/\n\x05types\x18\x03 \x03(\x0b\x32\x19.relationalai.lqp.v1.TypeR\x05typesB\x0c\n\n_target_id\"<\n\nRelationId\x12\x15\n\x06id_low\x18\x01 \x01(\x06R\x05idLow\x12\x17\n\x07id_high\x18\x02 \x01(\x06R\x06idHigh\"\xd5\x07\n\x04Type\x12Q\n\x10unspecified_type\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.UnspecifiedTypeH\x00R\x0funspecifiedType\x12\x42\n\x0bstring_type\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.StringTypeH\x00R\nstringType\x12\x39\n\x08int_type\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.IntTypeH\x00R\x07intType\x12?\n\nfloat_type\x18\x04 \x01(\x0b\x32\x1e.relationalai.lqp.v1.FloatTypeH\x00R\tfloatType\x12\x45\n\x0cuint128_type\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.UInt128TypeH\x00R\x0buint128Type\x12\x42\n\x0bint128_type\x18\x06 \x01(\x0b\x32\x1f.relationalai.lqp.v1.Int128TypeH\x00R\nint128Type\x12<\n\tdate_type\x18\x07 \x01(\x0b\x32\x1d.relationalai.lqp.v1.DateTypeH\x00R\x08\x64\x61teType\x12H\n\rdatetime_type\x18\x08 \x01(\x0b\x32!.relationalai.lqp.v1.DateTimeTypeH\x00R\x0c\x64\x61tetimeType\x12\x45\n\x0cmissing_type\x18\t \x01(\x0b\x32 .relationalai.lqp.v1.MissingTypeH\x00R\x0bmissingType\x12\x45\n\x0c\x64\x65\x63imal_type\x18\n \x01(\x0b\x32 .relationalai.lqp.v1.DecimalTypeH\x00R\x0b\x64\x65\x63imalType\x12\x45\n\x0c\x62oolean_type\x18\x0b \x01(\x0b\x32 .relationalai.lqp.v1.BooleanTypeH\x00R\x0b\x62ooleanType\x12?\n\nint32_type\x18\x0c \x01(\x0b\x32\x1e.relationalai.lqp.v1.Int32TypeH\x00R\tint32Type\x12\x45\n\x0c\x66loat32_type\x18\r \x01(\x0b\x32 .relationalai.lqp.v1.Float32TypeH\x00R\x0b\x66loat32Type\x12\x42\n\x0buint32_type\x18\x0e \x01(\x0b\x32\x1f.relationalai.lqp.v1.UInt32TypeH\x00R\nuint32TypeB\x06\n\x04type\"\x11\n\x0fUnspecifiedType\"\x0c\n\nStringType\"\t\n\x07IntType\"\x0b\n\tFloatType\"\r\n\x0bUInt128Type\"\x0c\n\nInt128Type\"\n\n\x08\x44\x61teType\"\x0e\n\x0c\x44\x61teTimeType\"\r\n\x0bMissingType\"A\n\x0b\x44\x65\x63imalType\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\"\r\n\x0b\x42ooleanType\"\x0b\n\tInt32Type\"\r\n\x0b\x46loat32Type\"\x0c\n\nUInt32Type\"\xc0\x05\n\x05Value\x12#\n\x0cstring_value\x18\x01 \x01(\tH\x00R\x0bstringValue\x12\x1d\n\tint_value\x18\x02 \x01(\x03H\x00R\x08intValue\x12!\n\x0b\x66loat_value\x18\x03 \x01(\x01H\x00R\nfloatValue\x12H\n\ruint128_value\x18\x04 \x01(\x0b\x32!.relationalai.lqp.v1.UInt128ValueH\x00R\x0cuint128Value\x12\x45\n\x0cint128_value\x18\x05 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueH\x00R\x0bint128Value\x12H\n\rmissing_value\x18\x06 \x01(\x0b\x32!.relationalai.lqp.v1.MissingValueH\x00R\x0cmissingValue\x12?\n\ndate_value\x18\x07 \x01(\x0b\x32\x1e.relationalai.lqp.v1.DateValueH\x00R\tdateValue\x12K\n\x0e\x64\x61tetime_value\x18\x08 \x01(\x0b\x32\".relationalai.lqp.v1.DateTimeValueH\x00R\rdatetimeValue\x12H\n\rdecimal_value\x18\t \x01(\x0b\x32!.relationalai.lqp.v1.DecimalValueH\x00R\x0c\x64\x65\x63imalValue\x12%\n\rboolean_value\x18\n \x01(\x08H\x00R\x0c\x62ooleanValue\x12!\n\x0bint32_value\x18\x0b \x01(\x05H\x00R\nint32Value\x12%\n\rfloat32_value\x18\x0c \x01(\x02H\x00R\x0c\x66loat32Value\x12#\n\x0cuint32_value\x18\r \x01(\rH\x00R\x0buint32ValueB\x07\n\x05value\"4\n\x0cUInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"3\n\x0bInt128Value\x12\x10\n\x03low\x18\x01 \x01(\x06R\x03low\x12\x12\n\x04high\x18\x02 \x01(\x06R\x04high\"\x0e\n\x0cMissingValue\"G\n\tDateValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\"\xb1\x01\n\rDateTimeValue\x12\x12\n\x04year\x18\x01 \x01(\x05R\x04year\x12\x14\n\x05month\x18\x02 \x01(\x05R\x05month\x12\x10\n\x03\x64\x61y\x18\x03 \x01(\x05R\x03\x64\x61y\x12\x12\n\x04hour\x18\x04 \x01(\x05R\x04hour\x12\x16\n\x06minute\x18\x05 \x01(\x05R\x06minute\x12\x16\n\x06second\x18\x06 \x01(\x05R\x06second\x12 \n\x0bmicrosecond\x18\x07 \x01(\x05R\x0bmicrosecond\"z\n\x0c\x44\x65\x63imalValue\x12\x1c\n\tprecision\x18\x01 \x01(\x05R\tprecision\x12\x14\n\x05scale\x18\x02 \x01(\x05R\x05scale\x12\x36\n\x05value\x18\x03 \x01(\x0b\x32 .relationalai.lqp.v1.Int128ValueR\x05valueBCZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -133,69 +133,69 @@ _globals['_CDCTARGETS']._serialized_start=7234 _globals['_CDCTARGETS']._serialized_end=7372 _globals['_TARGETRELATIONS']._serialized_start=7375 - _globals['_TARGETRELATIONS']._serialized_end=7566 - _globals['_CSVDATA']._serialized_start=7569 - _globals['_CSVDATA']._serialized_end=7858 - _globals['_CSVLOCATOR']._serialized_start=7860 - _globals['_CSVLOCATOR']._serialized_end=7927 - _globals['_CSVCONFIG']._serialized_start=7930 - _globals['_CSVCONFIG']._serialized_end=8448 - _globals['_ICEBERGDATA']._serialized_start=8451 - _globals['_ICEBERGDATA']._serialized_end=8803 - _globals['_ICEBERGLOCATOR']._serialized_start=8805 - _globals['_ICEBERGLOCATOR']._serialized_end=8912 - _globals['_ICEBERGCATALOGCONFIG']._serialized_start=8915 - _globals['_ICEBERGCATALOGCONFIG']._serialized_end=9332 - _globals['_ICEBERGCATALOGCONFIG_PROPERTIESENTRY']._serialized_start=9194 - _globals['_ICEBERGCATALOGCONFIG_PROPERTIESENTRY']._serialized_end=9255 - _globals['_ICEBERGCATALOGCONFIG_AUTHPROPERTIESENTRY']._serialized_start=9257 - _globals['_ICEBERGCATALOGCONFIG_AUTHPROPERTIESENTRY']._serialized_end=9322 - _globals['_GNFCOLUMN']._serialized_start=9335 - _globals['_GNFCOLUMN']._serialized_end=9509 - _globals['_RELATIONID']._serialized_start=9511 - _globals['_RELATIONID']._serialized_end=9571 - _globals['_TYPE']._serialized_start=9574 - _globals['_TYPE']._serialized_end=10555 - _globals['_UNSPECIFIEDTYPE']._serialized_start=10557 - _globals['_UNSPECIFIEDTYPE']._serialized_end=10574 - _globals['_STRINGTYPE']._serialized_start=10576 - _globals['_STRINGTYPE']._serialized_end=10588 - _globals['_INTTYPE']._serialized_start=10590 - _globals['_INTTYPE']._serialized_end=10599 - _globals['_FLOATTYPE']._serialized_start=10601 - _globals['_FLOATTYPE']._serialized_end=10612 - _globals['_UINT128TYPE']._serialized_start=10614 - _globals['_UINT128TYPE']._serialized_end=10627 - _globals['_INT128TYPE']._serialized_start=10629 - _globals['_INT128TYPE']._serialized_end=10641 - _globals['_DATETYPE']._serialized_start=10643 - _globals['_DATETYPE']._serialized_end=10653 - _globals['_DATETIMETYPE']._serialized_start=10655 - _globals['_DATETIMETYPE']._serialized_end=10669 - _globals['_MISSINGTYPE']._serialized_start=10671 - _globals['_MISSINGTYPE']._serialized_end=10684 - _globals['_DECIMALTYPE']._serialized_start=10686 - _globals['_DECIMALTYPE']._serialized_end=10751 - _globals['_BOOLEANTYPE']._serialized_start=10753 - _globals['_BOOLEANTYPE']._serialized_end=10766 - _globals['_INT32TYPE']._serialized_start=10768 - _globals['_INT32TYPE']._serialized_end=10779 - _globals['_FLOAT32TYPE']._serialized_start=10781 - _globals['_FLOAT32TYPE']._serialized_end=10794 - _globals['_UINT32TYPE']._serialized_start=10796 - _globals['_UINT32TYPE']._serialized_end=10808 - _globals['_VALUE']._serialized_start=10811 - _globals['_VALUE']._serialized_end=11515 - _globals['_UINT128VALUE']._serialized_start=11517 - _globals['_UINT128VALUE']._serialized_end=11569 - _globals['_INT128VALUE']._serialized_start=11571 - _globals['_INT128VALUE']._serialized_end=11622 - _globals['_MISSINGVALUE']._serialized_start=11624 - _globals['_MISSINGVALUE']._serialized_end=11638 - _globals['_DATEVALUE']._serialized_start=11640 - _globals['_DATEVALUE']._serialized_end=11711 - _globals['_DATETIMEVALUE']._serialized_start=11714 - _globals['_DATETIMEVALUE']._serialized_end=11891 - _globals['_DECIMALVALUE']._serialized_start=11893 - _globals['_DECIMALVALUE']._serialized_end=12015 + _globals['_TARGETRELATIONS']._serialized_end=7603 + _globals['_CSVDATA']._serialized_start=7606 + _globals['_CSVDATA']._serialized_end=7895 + _globals['_CSVLOCATOR']._serialized_start=7897 + _globals['_CSVLOCATOR']._serialized_end=7964 + _globals['_CSVCONFIG']._serialized_start=7967 + _globals['_CSVCONFIG']._serialized_end=8485 + _globals['_ICEBERGDATA']._serialized_start=8488 + _globals['_ICEBERGDATA']._serialized_end=8840 + _globals['_ICEBERGLOCATOR']._serialized_start=8842 + _globals['_ICEBERGLOCATOR']._serialized_end=8949 + _globals['_ICEBERGCATALOGCONFIG']._serialized_start=8952 + _globals['_ICEBERGCATALOGCONFIG']._serialized_end=9369 + _globals['_ICEBERGCATALOGCONFIG_PROPERTIESENTRY']._serialized_start=9231 + _globals['_ICEBERGCATALOGCONFIG_PROPERTIESENTRY']._serialized_end=9292 + _globals['_ICEBERGCATALOGCONFIG_AUTHPROPERTIESENTRY']._serialized_start=9294 + _globals['_ICEBERGCATALOGCONFIG_AUTHPROPERTIESENTRY']._serialized_end=9359 + _globals['_GNFCOLUMN']._serialized_start=9372 + _globals['_GNFCOLUMN']._serialized_end=9546 + _globals['_RELATIONID']._serialized_start=9548 + _globals['_RELATIONID']._serialized_end=9608 + _globals['_TYPE']._serialized_start=9611 + _globals['_TYPE']._serialized_end=10592 + _globals['_UNSPECIFIEDTYPE']._serialized_start=10594 + _globals['_UNSPECIFIEDTYPE']._serialized_end=10611 + _globals['_STRINGTYPE']._serialized_start=10613 + _globals['_STRINGTYPE']._serialized_end=10625 + _globals['_INTTYPE']._serialized_start=10627 + _globals['_INTTYPE']._serialized_end=10636 + _globals['_FLOATTYPE']._serialized_start=10638 + _globals['_FLOATTYPE']._serialized_end=10649 + _globals['_UINT128TYPE']._serialized_start=10651 + _globals['_UINT128TYPE']._serialized_end=10664 + _globals['_INT128TYPE']._serialized_start=10666 + _globals['_INT128TYPE']._serialized_end=10678 + _globals['_DATETYPE']._serialized_start=10680 + _globals['_DATETYPE']._serialized_end=10690 + _globals['_DATETIMETYPE']._serialized_start=10692 + _globals['_DATETIMETYPE']._serialized_end=10706 + _globals['_MISSINGTYPE']._serialized_start=10708 + _globals['_MISSINGTYPE']._serialized_end=10721 + _globals['_DECIMALTYPE']._serialized_start=10723 + _globals['_DECIMALTYPE']._serialized_end=10788 + _globals['_BOOLEANTYPE']._serialized_start=10790 + _globals['_BOOLEANTYPE']._serialized_end=10803 + _globals['_INT32TYPE']._serialized_start=10805 + _globals['_INT32TYPE']._serialized_end=10816 + _globals['_FLOAT32TYPE']._serialized_start=10818 + _globals['_FLOAT32TYPE']._serialized_end=10831 + _globals['_UINT32TYPE']._serialized_start=10833 + _globals['_UINT32TYPE']._serialized_end=10845 + _globals['_VALUE']._serialized_start=10848 + _globals['_VALUE']._serialized_end=11552 + _globals['_UINT128VALUE']._serialized_start=11554 + _globals['_UINT128VALUE']._serialized_end=11606 + _globals['_INT128VALUE']._serialized_start=11608 + _globals['_INT128VALUE']._serialized_end=11659 + _globals['_MISSINGVALUE']._serialized_start=11661 + _globals['_MISSINGVALUE']._serialized_end=11675 + _globals['_DATEVALUE']._serialized_start=11677 + _globals['_DATEVALUE']._serialized_end=11748 + _globals['_DATETIMEVALUE']._serialized_start=11751 + _globals['_DATETIMEVALUE']._serialized_end=11928 + _globals['_DECIMALVALUE']._serialized_start=11930 + _globals['_DECIMALVALUE']._serialized_end=12052 # @@protoc_insertion_point(module_scope) diff --git a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi index 0cd0e651..5289b27f 100644 --- a/sdks/python/src/lqp/proto/v1/logic_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/logic_pb2.pyi @@ -451,14 +451,16 @@ class CDCTargets(_message.Message): def __init__(self, inserts: _Optional[_Iterable[_Union[TargetRelation, _Mapping]]] = ..., deletes: _Optional[_Iterable[_Union[TargetRelation, _Mapping]]] = ...) -> None: ... class TargetRelations(_message.Message): - __slots__ = ("keys", "plain", "cdc") + __slots__ = ("keys", "plain", "cdc", "synthetic_key") KEYS_FIELD_NUMBER: _ClassVar[int] PLAIN_FIELD_NUMBER: _ClassVar[int] CDC_FIELD_NUMBER: _ClassVar[int] + SYNTHETIC_KEY_FIELD_NUMBER: _ClassVar[int] keys: _containers.RepeatedCompositeFieldContainer[NamedColumn] plain: PlainTargets cdc: CDCTargets - def __init__(self, keys: _Optional[_Iterable[_Union[NamedColumn, _Mapping]]] = ..., plain: _Optional[_Union[PlainTargets, _Mapping]] = ..., cdc: _Optional[_Union[CDCTargets, _Mapping]] = ...) -> None: ... + synthetic_key: bool + def __init__(self, keys: _Optional[_Iterable[_Union[NamedColumn, _Mapping]]] = ..., plain: _Optional[_Union[PlainTargets, _Mapping]] = ..., cdc: _Optional[_Union[CDCTargets, _Mapping]] = ..., synthetic_key: _Optional[bool] = ...) -> None: ... class CSVData(_message.Message): __slots__ = ("locator", "config", "columns", "asof", "relations") diff --git a/sdks/python/tests/test_parser.py b/sdks/python/tests/test_parser.py index 1b7dfc1b..312a48c0 100644 --- a/sdks/python/tests/test_parser.py +++ b/sdks/python/tests/test_parser.py @@ -100,6 +100,39 @@ def test_int32_config_requires_i32_suffix(): assert _header_row_of(empty_fragment) == 1 +def _relations_fragment(keys_clause: str) -> str: + # Minimal fragment exercising the generalized `(relations ...)` loading form + # with a configurable `(keys ...)` clause. + return ( + '(fragment :f (csv_data (csv_locator (paths "x.csv")) (csv_config {}) ' + f'(relations {keys_clause} (relation :r (column "v" INT))) ' + '(asof "2025-01-01T00:00:00Z")))' + ) + + +def _relations_of(fragment: str): + result, _provenance = parse_fragment(fragment) + return result.declarations[0].data.csv_data.relations + + +def test_synthetic_key_marker(): + # `(keys :synthetic_key)` sets the synthetic_key flag and leaves keys empty. + relations = _relations_of(_relations_fragment("(keys :synthetic_key)")) + assert relations.synthetic_key is True + assert list(relations.keys) == [] + + # Explicit key columns leave synthetic_key unset. + relations = _relations_of(_relations_fragment('(keys (column "id" INT))')) + assert relations.synthetic_key is False + assert [c.name for c in relations.keys] == ["id"] + + +def test_synthetic_key_rejects_unknown_marker(): + # Only the `:synthetic_key` marker is accepted; anything else is a hard error. + with pytest.raises(ParseError): + parse_fragment(_relations_fragment("(keys :bogus)")) + + class TestSymbolLexing: """Tests for SYMBOL token regex — hyphen must be literal, not a range.""" diff --git a/tests/bin/relations_synthetic_key.bin b/tests/bin/relations_synthetic_key.bin new file mode 100644 index 0000000000000000000000000000000000000000..11bea394bd462f54189afbb3bd5321132e3cc5e8 GIT binary patch literal 304 zcmd;D&cyYYk?R2?*Ih;~7A~eVL!p_BO4AsnCNpx0bBPukTj}d3l_qDWmgwi@r=%9^ zB^Q?oiE=P1G3sbBDj6{7#SFu>Kd5o8W@Hc7+8T(l$N)UJC_od z5T}my=fAInrOpd_RP2yq^E7D`;^AT|Pt8ovC=p^(V&GB)s)=82-!;+f)B(XIE%V)P zq}`Y-#LdN;lbDp6Bg7=cpui|)iOnFa8rdO67Ynh0^%o1t3(0c91+h6tPDq9erWl)3 JScI537y+s5Sw;W= literal 0 HcmV?d00001 diff --git a/tests/bin/relations_synthetic_key_cdc.bin b/tests/bin/relations_synthetic_key_cdc.bin new file mode 100644 index 0000000000000000000000000000000000000000..90d08b3471a4bda834c7ddfdb92d35abe2743b57 GIT binary patch literal 319 zcmdDlSk?RE`*HcC=7A~eVL!nuWO4AvorZ94ebBPukTj}d3l_qDWmguLZq^B0^ zB^Q?oiE=P1G3sbBDj6{7#SFu>Kd5o8W@Hc7+8T(l$MW_2bU6; z5a+$sm1hoiAMX@QmflcW$y~uE#KXl_o|>7SQ6j{o#2^Gxlk6;CblKpowV;FEs `labels` +;; ID `0x813449061ab87848cf1a13eafdf33b2c` -> `weights` diff --git a/tests/pretty_debug/relations_synthetic_key_cdc.lqp b/tests/pretty_debug/relations_synthetic_key_cdc.lqp new file mode 100644 index 00000000..4e495b48 --- /dev/null +++ b/tests/pretty_debug/relations_synthetic_key_cdc.lqp @@ -0,0 +1,33 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes + (define + (fragment + :f1 + (csv_data + (csv_locator (paths "s3://bucket/edges.csv")) + (csv_config + { + :csv_compression "" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\"" + :csv_header_row 1i32 + :csv_quotechar "\"" + :csv_skip 0}) + (relations + (keys :synthetic_key) + (inserts (relation 0x678037975b01b6389c78bc1cc79abde (column "weight" FLOAT))) (deletes + (relation 0xb214f85adaa2e403bed30d3721f4363 (column "weight" FLOAT)))) + (asof "2025-06-01T00:00:00Z"))))) + (reads + (output :weight_ins 0x678037975b01b6389c78bc1cc79abde) + (output :weight_del 0xb214f85adaa2e403bed30d3721f4363)))) + +;; Debug information +;; ----------------------- +;; Original names +;; ID `0xb214f85adaa2e403bed30d3721f4363` -> `weight_del` +;; ID `0x678037975b01b6389c78bc1cc79abde` -> `weight_ins` From fad79e1a66389dac445b7d2a51e7b4634799ac54 Mon Sep 17 00:00:00 2001 From: Henrik Barthels <25176271+hbarthels@users.noreply.github.com> Date: Sat, 25 Jul 2026 17:48:20 +0200 Subject: [PATCH 2/3] Use bare `synthetic` marker instead of `:synthetic_key` Address review feedback: `:` is the ID sigil, and the synthetic-key marker is a constant, not an ID, so it shouldn't use `:`. Switch the keys clause from `(keys :synthetic_key)` to `(keys synthetic)`, where `synthetic` is a soft keyword. Unknown markers remain a hard parse error. The serialized proto is unchanged (the marker only affects surface syntax), so the binary snapshots and generated protobuf bindings are untouched. Co-Authored-By: Claude Opus 4.8 --- meta/src/meta/grammar.y | 13 +- sdks/go/src/parser.go | 5883 ++++++++--------- sdks/go/src/pretty.go | 12 +- .../LogicalQueryProtocol.jl/src/parser.jl | 4955 +++++++------- .../LogicalQueryProtocol.jl/src/pretty.jl | 8 +- sdks/python/src/lqp/gen/parser.py | 4903 +++++++------- sdks/python/src/lqp/gen/pretty.py | 8 +- sdks/python/tests/test_parser.py | 8 +- tests/lqp/relations_synthetic_key.lqp | 2 +- tests/lqp/relations_synthetic_key_cdc.lqp | 2 +- tests/pretty/relations_synthetic_key.lqp | 2 +- tests/pretty/relations_synthetic_key_cdc.lqp | 2 +- .../pretty_debug/relations_synthetic_key.lqp | 2 +- .../relations_synthetic_key_cdc.lqp | 2 +- 14 files changed, 7876 insertions(+), 7926 deletions(-) diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index 578fd3dd..8eac2218 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -1137,10 +1137,9 @@ relation_keys construct: $$ = builtin.tuple($3, False) deconstruct if not $$[1]: $3: Sequence[logic.NamedColumn] = $$[0] - | "(" "keys" ":" SYMBOL ")" - construct: $$ = construct_synthetic_keys($4) + | "(" "keys" "synthetic" ")" + construct: $$ = builtin.tuple(list[logic.NamedColumn](), True) deconstruct if $$[1]: - $4: String = "synthetic_key" target_relation : "(" "relation" relation_id named_column* ")" @@ -1565,14 +1564,6 @@ def construct_cdc_relations( ) -def construct_synthetic_keys( - marker: String, -) -> Tuple[Sequence[logic.NamedColumn], Boolean]: - if marker != "synthetic_key": - builtin.error("expected the `:synthetic_key` marker in the relation keys clause") - return builtin.tuple(list[logic.NamedColumn](), True) - - def deconstruct_relation_keys( msg: logic.TargetRelations, ) -> Tuple[Sequence[logic.NamedColumn], Boolean]: diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index 8fa8f399..6c069b30 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -655,220 +655,211 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t2224 interface{} + var _t2221 interface{} if value == nil { return int32(default_) } - _ = _t2224 - var _t2225 interface{} + _ = _t2221 + var _t2222 interface{} if hasProtoField(value, "int32_value") { return value.GetInt32Value() } - _ = _t2225 + _ = _t2222 panic(ParseError{msg: "expected an int32 value (e.g. `1i32`) for this config field"}) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t2226 interface{} + var _t2223 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2226 + _ = _t2223 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t2227 interface{} + var _t2224 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2227 + _ = _t2224 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t2228 interface{} + var _t2225 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2228 + _ = _t2225 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t2229 interface{} + var _t2226 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2229 + _ = _t2226 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t2230 interface{} + var _t2227 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2230 + _ = _t2227 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t2231 interface{} + var _t2228 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2231 + _ = _t2228 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t2232 interface{} + var _t2229 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2232 + _ = _t2229 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t2233 interface{} + var _t2230 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2233 + _ = _t2230 return nil } func (p *Parser) construct_non_cdc_relations(targets []*pb.TargetRelation) *pb.TargetRelations { - _t2234 := &pb.PlainTargets{Targets: targets} - _t2235 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2235.Body = &pb.TargetRelations_Plain{Plain: _t2234} - return _t2235 + _t2231 := &pb.PlainTargets{Targets: targets} + _t2232 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2232.Body = &pb.TargetRelations_Plain{Plain: _t2231} + return _t2232 } func (p *Parser) construct_cdc_relations(inserts []*pb.TargetRelation, deletes []*pb.TargetRelation) *pb.TargetRelations { - _t2236 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} - _t2237 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2237.Body = &pb.TargetRelations_Cdc{Cdc: _t2236} - return _t2237 -} - -func (p *Parser) construct_synthetic_keys(marker string) []interface{} { - var _t2238 interface{} - if marker != "synthetic_key" { - panic(ParseError{msg: "expected the `:synthetic_key` marker in the relation keys clause"}) - } - _ = _t2238 - return []interface{}{[]*pb.NamedColumn{}, true} + _t2233 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} + _t2234 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2234.Body = &pb.TargetRelations_Cdc{Cdc: _t2233} + return _t2234 } func (p *Parser) construct_relations(keys []interface{}, body *pb.TargetRelations) *pb.TargetRelations { - var _t2239 interface{} + var _t2235 interface{} if hasProtoField(body, "plain") { - _t2240 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool)} - _t2240.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} - return _t2240 + _t2236 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool)} + _t2236.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} + return _t2236 } - _ = _t2239 - _t2241 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool)} - _t2241.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} - return _t2241 + _ = _t2235 + _t2237 := &pb.TargetRelations{Keys: keys[0].([]*pb.NamedColumn), SyntheticKey: keys[1].(bool)} + _t2237.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} + return _t2237 } func (p *Parser) construct_csv_data(locator *pb.CSVLocator, config *pb.CSVConfig, columns_opt []*pb.GNFColumn, relations_opt *pb.TargetRelations, asof string) *pb.CSVData { - _t2242 := columns_opt + _t2238 := columns_opt if columns_opt == nil { - _t2242 = []*pb.GNFColumn{} + _t2238 = []*pb.GNFColumn{} } - _t2243 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2242, Asof: asof, Relations: relations_opt} - return _t2243 + _t2239 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2238, Asof: asof, Relations: relations_opt} + return _t2239 } func (p *Parser) construct_csv_config(config_dict [][]interface{}, storage_integration_opt [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t2244 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2244 - _t2245 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2245 - _t2246 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2246 - _t2247 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2247 - _t2248 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2248 - _t2249 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2249 - _t2250 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2250 - _t2251 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2251 - _t2252 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2252 - _t2253 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2253 - _t2254 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") - compression := _t2254 - _t2255 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2255 - _t2256 := p.construct_csv_storage_integration(storage_integration_opt) - storage_integration := _t2256 - _t2257 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression, PartitionSizeMb: partition_size_mb, StorageIntegration: storage_integration} - return _t2257 + _t2240 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t2240 + _t2241 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t2241 + _t2242 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t2242 + _t2243 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t2243 + _t2244 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t2244 + _t2245 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t2245 + _t2246 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t2246 + _t2247 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t2247 + _t2248 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t2248 + _t2249 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t2249 + _t2250 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") + compression := _t2250 + _t2251 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) + partition_size_mb := _t2251 + _t2252 := p.construct_csv_storage_integration(storage_integration_opt) + storage_integration := _t2252 + _t2253 := &pb.CSVConfig{HeaderRow: header_row, Skip: skip, NewLine: new_line, Delimiter: delimiter, Quotechar: quotechar, Escapechar: escapechar, Comment: comment, MissingStrings: missing_strings, DecimalSeparator: decimal_separator, Encoding: encoding, Compression: compression, PartitionSizeMb: partition_size_mb, StorageIntegration: storage_integration} + return _t2253 } func (p *Parser) construct_csv_storage_integration(storage_integration_opt [][]interface{}) *pb.StorageIntegration { - var _t2258 interface{} + var _t2254 interface{} if storage_integration_opt == nil { return nil } - _ = _t2258 + _ = _t2254 config := dictFromList(storage_integration_opt) - _t2259 := p._extract_value_string(dictGetValue(config, "provider"), "") - _t2260 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") - _t2261 := p._extract_value_string(dictGetValue(config, "s3_region"), "") - _t2262 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") - _t2263 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") - _t2264 := &pb.StorageIntegration{Provider: _t2259, AzureSasToken: _t2260, S3Region: _t2261, S3AccessKeyId: _t2262, S3SecretAccessKey: _t2263} - return _t2264 + _t2255 := p._extract_value_string(dictGetValue(config, "provider"), "") + _t2256 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") + _t2257 := p._extract_value_string(dictGetValue(config, "s3_region"), "") + _t2258 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") + _t2259 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") + _t2260 := &pb.StorageIntegration{Provider: _t2255, AzureSasToken: _t2256, S3Region: _t2257, S3AccessKeyId: _t2258, S3SecretAccessKey: _t2259} + return _t2260 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t2265 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2265 - _t2266 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2266 - _t2267 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2267 - _t2268 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2268 - _t2269 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2269 - _t2270 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2270 - _t2271 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2271 - _t2272 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2272 - _t2273 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2273 - _t2274 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t2261 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t2261 + _t2262 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t2262 + _t2263 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t2263 + _t2264 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t2264 + _t2265 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t2265 + _t2266 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t2266 + _t2267 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t2267 + _t2268 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t2268 + _t2269 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t2269 + _t2270 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t2274.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t2270.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t2274.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t2270.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t2274 - _t2275 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2275 + relation_locator := _t2270 + _t2271 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t2271 } func (p *Parser) default_configure() *pb.Configure { - _t2276 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2276 - _t2277 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2277 + _t2272 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t2272 + _t2273 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t2273 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -890,4534 +881,4532 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t2278 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2278 - _t2279 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2279 - _t2280 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t2280 + _t2274 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t2274 + _t2275 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t2275 + _t2276 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t2276 } func (p *Parser) construct_export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t2281 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2281 - _t2282 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2282 - _t2283 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2283 - _t2284 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2284 - _t2285 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2285 - _t2286 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2286 - _t2287 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2287 - _t2288 := &pb.ExportCSVConfig{Path: path, DataColumns: columns, PartitionSize: ptr(partition_size), Compression: ptr(compression), SyntaxHeaderRow: ptr(syntax_header_row), SyntaxMissingString: ptr(syntax_missing_string), SyntaxDelim: ptr(syntax_delim), SyntaxQuotechar: ptr(syntax_quotechar), SyntaxEscapechar: ptr(syntax_escapechar)} - return _t2288 + _t2277 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t2277 + _t2278 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t2278 + _t2279 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t2279 + _t2280 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t2280 + _t2281 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t2281 + _t2282 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t2282 + _t2283 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t2283 + _t2284 := &pb.ExportCSVConfig{Path: path, DataColumns: columns, PartitionSize: ptr(partition_size), Compression: ptr(compression), SyntaxHeaderRow: ptr(syntax_header_row), SyntaxMissingString: ptr(syntax_missing_string), SyntaxDelim: ptr(syntax_delim), SyntaxQuotechar: ptr(syntax_quotechar), SyntaxEscapechar: ptr(syntax_escapechar)} + return _t2284 } func (p *Parser) construct_export_csv_config_with_location(location []interface{}, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2289 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} - return _t2289 + _t2285 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} + return _t2285 } func (p *Parser) construct_iceberg_catalog_config(catalog_uri string, scope_opt *string, property_pairs [][]interface{}, auth_property_pairs [][]interface{}) *pb.IcebergCatalogConfig { props := stringMapFromPairs(property_pairs) auth_props := stringMapFromPairs(auth_property_pairs) - _t2290 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2290 + _t2286 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} + return _t2286 } func (p *Parser) construct_iceberg_data(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, columns []*pb.GNFColumn, from_snapshot_opt *string, to_snapshot_opt *string, returns_delta bool) *pb.IcebergData { - _t2291 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2291 + _t2287 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} + return _t2287 } func (p *Parser) construct_export_iceberg_config_full(locator *pb.IcebergLocator, config *pb.IcebergCatalogConfig, table_def *pb.RelationId, table_property_pairs [][]interface{}, config_dict [][]interface{}) *pb.ExportIcebergConfig { - _t2292 := config_dict + _t2288 := config_dict if config_dict == nil { - _t2292 = [][]interface{}{} - } - cfg := dictFromList(_t2292) - _t2293 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2293 - _t2294 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2294 - _t2295 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2295 + _t2288 = [][]interface{}{} + } + cfg := dictFromList(_t2288) + _t2289 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") + prefix := _t2289 + _t2290 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) + target_file_size_bytes := _t2290 + _t2291 := p._extract_value_string(dictGetValue(cfg, "compression"), "") + compression := _t2291 table_props := stringMapFromPairs(table_property_pairs) - _t2296 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2296 + _t2292 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} + return _t2292 } // --- Parse functions --- func (p *Parser) parse_transaction() *pb.Transaction { - span_start715 := int64(p.spanStart()) + span_start714 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t1418 *pb.Configure + var _t1416 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t1419 := p.parse_configure() - _t1418 = _t1419 + _t1417 := p.parse_configure() + _t1416 = _t1417 } - configure709 := _t1418 - var _t1420 *pb.Sync + configure708 := _t1416 + var _t1418 *pb.Sync if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t1421 := p.parse_sync() - _t1420 = _t1421 - } - sync710 := _t1420 - xs711 := []*pb.Epoch{} - cond712 := p.matchLookaheadLiteral("(", 0) - for cond712 { - _t1422 := p.parse_epoch() - item713 := _t1422 - xs711 = append(xs711, item713) - cond712 = p.matchLookaheadLiteral("(", 0) - } - epochs714 := xs711 + _t1419 := p.parse_sync() + _t1418 = _t1419 + } + sync709 := _t1418 + xs710 := []*pb.Epoch{} + cond711 := p.matchLookaheadLiteral("(", 0) + for cond711 { + _t1420 := p.parse_epoch() + item712 := _t1420 + xs710 = append(xs710, item712) + cond711 = p.matchLookaheadLiteral("(", 0) + } + epochs713 := xs710 p.consumeLiteral(")") - _t1423 := p.default_configure() - _t1424 := configure709 - if configure709 == nil { - _t1424 = _t1423 + _t1421 := p.default_configure() + _t1422 := configure708 + if configure708 == nil { + _t1422 = _t1421 } - _t1425 := &pb.Transaction{Epochs: epochs714, Configure: _t1424, Sync: sync710} - result716 := _t1425 - p.recordSpan(int(span_start715), "Transaction") - return result716 + _t1423 := &pb.Transaction{Epochs: epochs713, Configure: _t1422, Sync: sync709} + result715 := _t1423 + p.recordSpan(int(span_start714), "Transaction") + return result715 } func (p *Parser) parse_configure() *pb.Configure { - span_start718 := int64(p.spanStart()) + span_start717 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("configure") - _t1426 := p.parse_config_dict() - config_dict717 := _t1426 + _t1424 := p.parse_config_dict() + config_dict716 := _t1424 p.consumeLiteral(")") - _t1427 := p.construct_configure(config_dict717) - result719 := _t1427 - p.recordSpan(int(span_start718), "Configure") - return result719 + _t1425 := p.construct_configure(config_dict716) + result718 := _t1425 + p.recordSpan(int(span_start717), "Configure") + return result718 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs720 := [][]interface{}{} - cond721 := p.matchLookaheadLiteral(":", 0) - for cond721 { - _t1428 := p.parse_config_key_value() - item722 := _t1428 - xs720 = append(xs720, item722) - cond721 = p.matchLookaheadLiteral(":", 0) - } - config_key_values723 := xs720 + xs719 := [][]interface{}{} + cond720 := p.matchLookaheadLiteral(":", 0) + for cond720 { + _t1426 := p.parse_config_key_value() + item721 := _t1426 + xs719 = append(xs719, item721) + cond720 = p.matchLookaheadLiteral(":", 0) + } + config_key_values722 := xs719 p.consumeLiteral("}") - return config_key_values723 + return config_key_values722 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol724 := p.consumeTerminal("SYMBOL").Value.str - _t1429 := p.parse_raw_value() - raw_value725 := _t1429 - return []interface{}{symbol724, raw_value725} + symbol723 := p.consumeTerminal("SYMBOL").Value.str + _t1427 := p.parse_raw_value() + raw_value724 := _t1427 + return []interface{}{symbol723, raw_value724} } func (p *Parser) parse_raw_value() *pb.Value { - span_start739 := int64(p.spanStart()) - var _t1430 int64 + span_start738 := int64(p.spanStart()) + var _t1428 int64 if p.matchLookaheadLiteral("true", 0) { - _t1430 = 12 + _t1428 = 12 } else { - var _t1431 int64 + var _t1429 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1431 = 11 + _t1429 = 11 } else { - var _t1432 int64 + var _t1430 int64 if p.matchLookaheadLiteral("false", 0) { - _t1432 = 12 + _t1430 = 12 } else { - var _t1433 int64 + var _t1431 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1434 int64 + var _t1432 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1434 = 1 + _t1432 = 1 } else { - var _t1435 int64 + var _t1433 int64 if p.matchLookaheadLiteral("date", 1) { - _t1435 = 0 + _t1433 = 0 } else { - _t1435 = -1 + _t1433 = -1 } - _t1434 = _t1435 + _t1432 = _t1433 } - _t1433 = _t1434 + _t1431 = _t1432 } else { - var _t1436 int64 + var _t1434 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1436 = 7 + _t1434 = 7 } else { - var _t1437 int64 + var _t1435 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1437 = 8 + _t1435 = 8 } else { - var _t1438 int64 + var _t1436 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1438 = 2 + _t1436 = 2 } else { - var _t1439 int64 + var _t1437 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1439 = 3 + _t1437 = 3 } else { - var _t1440 int64 + var _t1438 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1440 = 9 + _t1438 = 9 } else { - var _t1441 int64 + var _t1439 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1441 = 4 + _t1439 = 4 } else { - var _t1442 int64 + var _t1440 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1442 = 5 + _t1440 = 5 } else { - var _t1443 int64 + var _t1441 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1443 = 6 + _t1441 = 6 } else { - var _t1444 int64 + var _t1442 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1444 = 10 + _t1442 = 10 } else { - _t1444 = -1 + _t1442 = -1 } - _t1443 = _t1444 + _t1441 = _t1442 } - _t1442 = _t1443 + _t1440 = _t1441 } - _t1441 = _t1442 + _t1439 = _t1440 } - _t1440 = _t1441 + _t1438 = _t1439 } - _t1439 = _t1440 + _t1437 = _t1438 } - _t1438 = _t1439 + _t1436 = _t1437 } - _t1437 = _t1438 + _t1435 = _t1436 } - _t1436 = _t1437 + _t1434 = _t1435 } - _t1433 = _t1436 + _t1431 = _t1434 } - _t1432 = _t1433 + _t1430 = _t1431 } - _t1431 = _t1432 + _t1429 = _t1430 } - _t1430 = _t1431 - } - prediction726 := _t1430 - var _t1445 *pb.Value - if prediction726 == 12 { - _t1446 := p.parse_boolean_value() - boolean_value738 := _t1446 - _t1447 := &pb.Value{} - _t1447.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value738} - _t1445 = _t1447 + _t1428 = _t1429 + } + prediction725 := _t1428 + var _t1443 *pb.Value + if prediction725 == 12 { + _t1444 := p.parse_boolean_value() + boolean_value737 := _t1444 + _t1445 := &pb.Value{} + _t1445.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value737} + _t1443 = _t1445 } else { - var _t1448 *pb.Value - if prediction726 == 11 { + var _t1446 *pb.Value + if prediction725 == 11 { p.consumeLiteral("missing") - _t1449 := &pb.MissingValue{} - _t1450 := &pb.Value{} - _t1450.Value = &pb.Value_MissingValue{MissingValue: _t1449} - _t1448 = _t1450 + _t1447 := &pb.MissingValue{} + _t1448 := &pb.Value{} + _t1448.Value = &pb.Value_MissingValue{MissingValue: _t1447} + _t1446 = _t1448 } else { - var _t1451 *pb.Value - if prediction726 == 10 { - decimal737 := p.consumeTerminal("DECIMAL").Value.decimal - _t1452 := &pb.Value{} - _t1452.Value = &pb.Value_DecimalValue{DecimalValue: decimal737} - _t1451 = _t1452 + var _t1449 *pb.Value + if prediction725 == 10 { + decimal736 := p.consumeTerminal("DECIMAL").Value.decimal + _t1450 := &pb.Value{} + _t1450.Value = &pb.Value_DecimalValue{DecimalValue: decimal736} + _t1449 = _t1450 } else { - var _t1453 *pb.Value - if prediction726 == 9 { - int128736 := p.consumeTerminal("INT128").Value.int128 - _t1454 := &pb.Value{} - _t1454.Value = &pb.Value_Int128Value{Int128Value: int128736} - _t1453 = _t1454 + var _t1451 *pb.Value + if prediction725 == 9 { + int128735 := p.consumeTerminal("INT128").Value.int128 + _t1452 := &pb.Value{} + _t1452.Value = &pb.Value_Int128Value{Int128Value: int128735} + _t1451 = _t1452 } else { - var _t1455 *pb.Value - if prediction726 == 8 { - uint128735 := p.consumeTerminal("UINT128").Value.uint128 - _t1456 := &pb.Value{} - _t1456.Value = &pb.Value_Uint128Value{Uint128Value: uint128735} - _t1455 = _t1456 + var _t1453 *pb.Value + if prediction725 == 8 { + uint128734 := p.consumeTerminal("UINT128").Value.uint128 + _t1454 := &pb.Value{} + _t1454.Value = &pb.Value_Uint128Value{Uint128Value: uint128734} + _t1453 = _t1454 } else { - var _t1457 *pb.Value - if prediction726 == 7 { - uint32734 := p.consumeTerminal("UINT32").Value.u32 - _t1458 := &pb.Value{} - _t1458.Value = &pb.Value_Uint32Value{Uint32Value: uint32734} - _t1457 = _t1458 + var _t1455 *pb.Value + if prediction725 == 7 { + uint32733 := p.consumeTerminal("UINT32").Value.u32 + _t1456 := &pb.Value{} + _t1456.Value = &pb.Value_Uint32Value{Uint32Value: uint32733} + _t1455 = _t1456 } else { - var _t1459 *pb.Value - if prediction726 == 6 { - float733 := p.consumeTerminal("FLOAT").Value.f64 - _t1460 := &pb.Value{} - _t1460.Value = &pb.Value_FloatValue{FloatValue: float733} - _t1459 = _t1460 + var _t1457 *pb.Value + if prediction725 == 6 { + float732 := p.consumeTerminal("FLOAT").Value.f64 + _t1458 := &pb.Value{} + _t1458.Value = &pb.Value_FloatValue{FloatValue: float732} + _t1457 = _t1458 } else { - var _t1461 *pb.Value - if prediction726 == 5 { - float32732 := p.consumeTerminal("FLOAT32").Value.f32 - _t1462 := &pb.Value{} - _t1462.Value = &pb.Value_Float32Value{Float32Value: float32732} - _t1461 = _t1462 + var _t1459 *pb.Value + if prediction725 == 5 { + float32731 := p.consumeTerminal("FLOAT32").Value.f32 + _t1460 := &pb.Value{} + _t1460.Value = &pb.Value_Float32Value{Float32Value: float32731} + _t1459 = _t1460 } else { - var _t1463 *pb.Value - if prediction726 == 4 { - int731 := p.consumeTerminal("INT").Value.i64 - _t1464 := &pb.Value{} - _t1464.Value = &pb.Value_IntValue{IntValue: int731} - _t1463 = _t1464 + var _t1461 *pb.Value + if prediction725 == 4 { + int730 := p.consumeTerminal("INT").Value.i64 + _t1462 := &pb.Value{} + _t1462.Value = &pb.Value_IntValue{IntValue: int730} + _t1461 = _t1462 } else { - var _t1465 *pb.Value - if prediction726 == 3 { - int32730 := p.consumeTerminal("INT32").Value.i32 - _t1466 := &pb.Value{} - _t1466.Value = &pb.Value_Int32Value{Int32Value: int32730} - _t1465 = _t1466 + var _t1463 *pb.Value + if prediction725 == 3 { + int32729 := p.consumeTerminal("INT32").Value.i32 + _t1464 := &pb.Value{} + _t1464.Value = &pb.Value_Int32Value{Int32Value: int32729} + _t1463 = _t1464 } else { - var _t1467 *pb.Value - if prediction726 == 2 { - string729 := p.consumeTerminal("STRING").Value.str - _t1468 := &pb.Value{} - _t1468.Value = &pb.Value_StringValue{StringValue: string729} - _t1467 = _t1468 + var _t1465 *pb.Value + if prediction725 == 2 { + string728 := p.consumeTerminal("STRING").Value.str + _t1466 := &pb.Value{} + _t1466.Value = &pb.Value_StringValue{StringValue: string728} + _t1465 = _t1466 } else { - var _t1469 *pb.Value - if prediction726 == 1 { - _t1470 := p.parse_raw_datetime() - raw_datetime728 := _t1470 - _t1471 := &pb.Value{} - _t1471.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime728} - _t1469 = _t1471 + var _t1467 *pb.Value + if prediction725 == 1 { + _t1468 := p.parse_raw_datetime() + raw_datetime727 := _t1468 + _t1469 := &pb.Value{} + _t1469.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime727} + _t1467 = _t1469 } else { - var _t1472 *pb.Value - if prediction726 == 0 { - _t1473 := p.parse_raw_date() - raw_date727 := _t1473 - _t1474 := &pb.Value{} - _t1474.Value = &pb.Value_DateValue{DateValue: raw_date727} - _t1472 = _t1474 + var _t1470 *pb.Value + if prediction725 == 0 { + _t1471 := p.parse_raw_date() + raw_date726 := _t1471 + _t1472 := &pb.Value{} + _t1472.Value = &pb.Value_DateValue{DateValue: raw_date726} + _t1470 = _t1472 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in raw_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1469 = _t1472 + _t1467 = _t1470 } - _t1467 = _t1469 + _t1465 = _t1467 } - _t1465 = _t1467 + _t1463 = _t1465 } - _t1463 = _t1465 + _t1461 = _t1463 } - _t1461 = _t1463 + _t1459 = _t1461 } - _t1459 = _t1461 + _t1457 = _t1459 } - _t1457 = _t1459 + _t1455 = _t1457 } - _t1455 = _t1457 + _t1453 = _t1455 } - _t1453 = _t1455 + _t1451 = _t1453 } - _t1451 = _t1453 + _t1449 = _t1451 } - _t1448 = _t1451 + _t1446 = _t1449 } - _t1445 = _t1448 + _t1443 = _t1446 } - result740 := _t1445 - p.recordSpan(int(span_start739), "Value") - return result740 + result739 := _t1443 + p.recordSpan(int(span_start738), "Value") + return result739 } func (p *Parser) parse_raw_date() *pb.DateValue { - span_start744 := int64(p.spanStart()) + span_start743 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - int741 := p.consumeTerminal("INT").Value.i64 - int_3742 := p.consumeTerminal("INT").Value.i64 - int_4743 := p.consumeTerminal("INT").Value.i64 + int740 := p.consumeTerminal("INT").Value.i64 + int_3741 := p.consumeTerminal("INT").Value.i64 + int_4742 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1475 := &pb.DateValue{Year: int32(int741), Month: int32(int_3742), Day: int32(int_4743)} - result745 := _t1475 - p.recordSpan(int(span_start744), "DateValue") - return result745 + _t1473 := &pb.DateValue{Year: int32(int740), Month: int32(int_3741), Day: int32(int_4742)} + result744 := _t1473 + p.recordSpan(int(span_start743), "DateValue") + return result744 } func (p *Parser) parse_raw_datetime() *pb.DateTimeValue { - span_start753 := int64(p.spanStart()) + span_start752 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - int746 := p.consumeTerminal("INT").Value.i64 - int_3747 := p.consumeTerminal("INT").Value.i64 - int_4748 := p.consumeTerminal("INT").Value.i64 - int_5749 := p.consumeTerminal("INT").Value.i64 - int_6750 := p.consumeTerminal("INT").Value.i64 - int_7751 := p.consumeTerminal("INT").Value.i64 - var _t1476 *int64 + int745 := p.consumeTerminal("INT").Value.i64 + int_3746 := p.consumeTerminal("INT").Value.i64 + int_4747 := p.consumeTerminal("INT").Value.i64 + int_5748 := p.consumeTerminal("INT").Value.i64 + int_6749 := p.consumeTerminal("INT").Value.i64 + int_7750 := p.consumeTerminal("INT").Value.i64 + var _t1474 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1476 = ptr(p.consumeTerminal("INT").Value.i64) + _t1474 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8752 := _t1476 + int_8751 := _t1474 p.consumeLiteral(")") - _t1477 := &pb.DateTimeValue{Year: int32(int746), Month: int32(int_3747), Day: int32(int_4748), Hour: int32(int_5749), Minute: int32(int_6750), Second: int32(int_7751), Microsecond: int32(deref(int_8752, 0))} - result754 := _t1477 - p.recordSpan(int(span_start753), "DateTimeValue") - return result754 + _t1475 := &pb.DateTimeValue{Year: int32(int745), Month: int32(int_3746), Day: int32(int_4747), Hour: int32(int_5748), Minute: int32(int_6749), Second: int32(int_7750), Microsecond: int32(deref(int_8751, 0))} + result753 := _t1475 + p.recordSpan(int(span_start752), "DateTimeValue") + return result753 } func (p *Parser) parse_boolean_value() bool { - var _t1478 int64 + var _t1476 int64 if p.matchLookaheadLiteral("true", 0) { - _t1478 = 0 + _t1476 = 0 } else { - var _t1479 int64 + var _t1477 int64 if p.matchLookaheadLiteral("false", 0) { - _t1479 = 1 + _t1477 = 1 } else { - _t1479 = -1 + _t1477 = -1 } - _t1478 = _t1479 + _t1476 = _t1477 } - prediction755 := _t1478 - var _t1480 bool - if prediction755 == 1 { + prediction754 := _t1476 + var _t1478 bool + if prediction754 == 1 { p.consumeLiteral("false") - _t1480 = false + _t1478 = false } else { - var _t1481 bool - if prediction755 == 0 { + var _t1479 bool + if prediction754 == 0 { p.consumeLiteral("true") - _t1481 = true + _t1479 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1480 = _t1481 + _t1478 = _t1479 } - return _t1480 + return _t1478 } func (p *Parser) parse_sync() *pb.Sync { - span_start760 := int64(p.spanStart()) + span_start759 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sync") - xs756 := []*pb.FragmentId{} - cond757 := p.matchLookaheadLiteral(":", 0) - for cond757 { - _t1482 := p.parse_fragment_id() - item758 := _t1482 - xs756 = append(xs756, item758) - cond757 = p.matchLookaheadLiteral(":", 0) - } - fragment_ids759 := xs756 + xs755 := []*pb.FragmentId{} + cond756 := p.matchLookaheadLiteral(":", 0) + for cond756 { + _t1480 := p.parse_fragment_id() + item757 := _t1480 + xs755 = append(xs755, item757) + cond756 = p.matchLookaheadLiteral(":", 0) + } + fragment_ids758 := xs755 p.consumeLiteral(")") - _t1483 := &pb.Sync{Fragments: fragment_ids759} - result761 := _t1483 - p.recordSpan(int(span_start760), "Sync") - return result761 + _t1481 := &pb.Sync{Fragments: fragment_ids758} + result760 := _t1481 + p.recordSpan(int(span_start759), "Sync") + return result760 } func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start763 := int64(p.spanStart()) + span_start762 := int64(p.spanStart()) p.consumeLiteral(":") - symbol762 := p.consumeTerminal("SYMBOL").Value.str - result764 := &pb.FragmentId{Id: []byte(symbol762)} - p.recordSpan(int(span_start763), "FragmentId") - return result764 + symbol761 := p.consumeTerminal("SYMBOL").Value.str + result763 := &pb.FragmentId{Id: []byte(symbol761)} + p.recordSpan(int(span_start762), "FragmentId") + return result763 } func (p *Parser) parse_epoch() *pb.Epoch { - span_start767 := int64(p.spanStart()) + span_start766 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t1484 []*pb.Write + var _t1482 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t1485 := p.parse_epoch_writes() - _t1484 = _t1485 + _t1483 := p.parse_epoch_writes() + _t1482 = _t1483 } - epoch_writes765 := _t1484 - var _t1486 []*pb.Read + epoch_writes764 := _t1482 + var _t1484 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t1487 := p.parse_epoch_reads() - _t1486 = _t1487 + _t1485 := p.parse_epoch_reads() + _t1484 = _t1485 } - epoch_reads766 := _t1486 + epoch_reads765 := _t1484 p.consumeLiteral(")") - _t1488 := epoch_writes765 - if epoch_writes765 == nil { - _t1488 = []*pb.Write{} + _t1486 := epoch_writes764 + if epoch_writes764 == nil { + _t1486 = []*pb.Write{} } - _t1489 := epoch_reads766 - if epoch_reads766 == nil { - _t1489 = []*pb.Read{} + _t1487 := epoch_reads765 + if epoch_reads765 == nil { + _t1487 = []*pb.Read{} } - _t1490 := &pb.Epoch{Writes: _t1488, Reads: _t1489} - result768 := _t1490 - p.recordSpan(int(span_start767), "Epoch") - return result768 + _t1488 := &pb.Epoch{Writes: _t1486, Reads: _t1487} + result767 := _t1488 + p.recordSpan(int(span_start766), "Epoch") + return result767 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs769 := []*pb.Write{} - cond770 := p.matchLookaheadLiteral("(", 0) - for cond770 { - _t1491 := p.parse_write() - item771 := _t1491 - xs769 = append(xs769, item771) - cond770 = p.matchLookaheadLiteral("(", 0) - } - writes772 := xs769 + xs768 := []*pb.Write{} + cond769 := p.matchLookaheadLiteral("(", 0) + for cond769 { + _t1489 := p.parse_write() + item770 := _t1489 + xs768 = append(xs768, item770) + cond769 = p.matchLookaheadLiteral("(", 0) + } + writes771 := xs768 p.consumeLiteral(")") - return writes772 + return writes771 } func (p *Parser) parse_write() *pb.Write { - span_start778 := int64(p.spanStart()) - var _t1492 int64 + span_start777 := int64(p.spanStart()) + var _t1490 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1493 int64 + var _t1491 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t1493 = 1 + _t1491 = 1 } else { - var _t1494 int64 + var _t1492 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t1494 = 3 + _t1492 = 3 } else { - var _t1495 int64 + var _t1493 int64 if p.matchLookaheadLiteral("define", 1) { - _t1495 = 0 + _t1493 = 0 } else { - var _t1496 int64 + var _t1494 int64 if p.matchLookaheadLiteral("context", 1) { - _t1496 = 2 + _t1494 = 2 } else { - _t1496 = -1 + _t1494 = -1 } - _t1495 = _t1496 + _t1493 = _t1494 } - _t1494 = _t1495 + _t1492 = _t1493 } - _t1493 = _t1494 + _t1491 = _t1492 } - _t1492 = _t1493 + _t1490 = _t1491 } else { - _t1492 = -1 - } - prediction773 := _t1492 - var _t1497 *pb.Write - if prediction773 == 3 { - _t1498 := p.parse_snapshot() - snapshot777 := _t1498 - _t1499 := &pb.Write{} - _t1499.WriteType = &pb.Write_Snapshot{Snapshot: snapshot777} - _t1497 = _t1499 + _t1490 = -1 + } + prediction772 := _t1490 + var _t1495 *pb.Write + if prediction772 == 3 { + _t1496 := p.parse_snapshot() + snapshot776 := _t1496 + _t1497 := &pb.Write{} + _t1497.WriteType = &pb.Write_Snapshot{Snapshot: snapshot776} + _t1495 = _t1497 } else { - var _t1500 *pb.Write - if prediction773 == 2 { - _t1501 := p.parse_context() - context776 := _t1501 - _t1502 := &pb.Write{} - _t1502.WriteType = &pb.Write_Context{Context: context776} - _t1500 = _t1502 + var _t1498 *pb.Write + if prediction772 == 2 { + _t1499 := p.parse_context() + context775 := _t1499 + _t1500 := &pb.Write{} + _t1500.WriteType = &pb.Write_Context{Context: context775} + _t1498 = _t1500 } else { - var _t1503 *pb.Write - if prediction773 == 1 { - _t1504 := p.parse_undefine() - undefine775 := _t1504 - _t1505 := &pb.Write{} - _t1505.WriteType = &pb.Write_Undefine{Undefine: undefine775} - _t1503 = _t1505 + var _t1501 *pb.Write + if prediction772 == 1 { + _t1502 := p.parse_undefine() + undefine774 := _t1502 + _t1503 := &pb.Write{} + _t1503.WriteType = &pb.Write_Undefine{Undefine: undefine774} + _t1501 = _t1503 } else { - var _t1506 *pb.Write - if prediction773 == 0 { - _t1507 := p.parse_define() - define774 := _t1507 - _t1508 := &pb.Write{} - _t1508.WriteType = &pb.Write_Define{Define: define774} - _t1506 = _t1508 + var _t1504 *pb.Write + if prediction772 == 0 { + _t1505 := p.parse_define() + define773 := _t1505 + _t1506 := &pb.Write{} + _t1506.WriteType = &pb.Write_Define{Define: define773} + _t1504 = _t1506 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1503 = _t1506 + _t1501 = _t1504 } - _t1500 = _t1503 + _t1498 = _t1501 } - _t1497 = _t1500 + _t1495 = _t1498 } - result779 := _t1497 - p.recordSpan(int(span_start778), "Write") - return result779 + result778 := _t1495 + p.recordSpan(int(span_start777), "Write") + return result778 } func (p *Parser) parse_define() *pb.Define { - span_start781 := int64(p.spanStart()) + span_start780 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("define") - _t1509 := p.parse_fragment() - fragment780 := _t1509 + _t1507 := p.parse_fragment() + fragment779 := _t1507 p.consumeLiteral(")") - _t1510 := &pb.Define{Fragment: fragment780} - result782 := _t1510 - p.recordSpan(int(span_start781), "Define") - return result782 + _t1508 := &pb.Define{Fragment: fragment779} + result781 := _t1508 + p.recordSpan(int(span_start780), "Define") + return result781 } func (p *Parser) parse_fragment() *pb.Fragment { - span_start788 := int64(p.spanStart()) + span_start787 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("fragment") - _t1511 := p.parse_new_fragment_id() - new_fragment_id783 := _t1511 - xs784 := []*pb.Declaration{} - cond785 := p.matchLookaheadLiteral("(", 0) - for cond785 { - _t1512 := p.parse_declaration() - item786 := _t1512 - xs784 = append(xs784, item786) - cond785 = p.matchLookaheadLiteral("(", 0) - } - declarations787 := xs784 + _t1509 := p.parse_new_fragment_id() + new_fragment_id782 := _t1509 + xs783 := []*pb.Declaration{} + cond784 := p.matchLookaheadLiteral("(", 0) + for cond784 { + _t1510 := p.parse_declaration() + item785 := _t1510 + xs783 = append(xs783, item785) + cond784 = p.matchLookaheadLiteral("(", 0) + } + declarations786 := xs783 p.consumeLiteral(")") - result789 := p.constructFragment(new_fragment_id783, declarations787) - p.recordSpan(int(span_start788), "Fragment") - return result789 + result788 := p.constructFragment(new_fragment_id782, declarations786) + p.recordSpan(int(span_start787), "Fragment") + return result788 } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - span_start791 := int64(p.spanStart()) - _t1513 := p.parse_fragment_id() - fragment_id790 := _t1513 - p.startFragment(fragment_id790) - result792 := fragment_id790 - p.recordSpan(int(span_start791), "FragmentId") - return result792 + span_start790 := int64(p.spanStart()) + _t1511 := p.parse_fragment_id() + fragment_id789 := _t1511 + p.startFragment(fragment_id789) + result791 := fragment_id789 + p.recordSpan(int(span_start790), "FragmentId") + return result791 } func (p *Parser) parse_declaration() *pb.Declaration { - span_start798 := int64(p.spanStart()) - var _t1514 int64 + span_start797 := int64(p.spanStart()) + var _t1512 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1515 int64 + var _t1513 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1515 = 3 + _t1513 = 3 } else { - var _t1516 int64 + var _t1514 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1516 = 2 + _t1514 = 2 } else { - var _t1517 int64 + var _t1515 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1517 = 3 + _t1515 = 3 } else { - var _t1518 int64 + var _t1516 int64 if p.matchLookaheadLiteral("def", 1) { - _t1518 = 0 + _t1516 = 0 } else { - var _t1519 int64 + var _t1517 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1519 = 3 + _t1517 = 3 } else { - var _t1520 int64 + var _t1518 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1520 = 3 + _t1518 = 3 } else { - var _t1521 int64 + var _t1519 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t1521 = 1 + _t1519 = 1 } else { - _t1521 = -1 + _t1519 = -1 } - _t1520 = _t1521 + _t1518 = _t1519 } - _t1519 = _t1520 + _t1517 = _t1518 } - _t1518 = _t1519 + _t1516 = _t1517 } - _t1517 = _t1518 + _t1515 = _t1516 } - _t1516 = _t1517 + _t1514 = _t1515 } - _t1515 = _t1516 + _t1513 = _t1514 } - _t1514 = _t1515 + _t1512 = _t1513 } else { - _t1514 = -1 - } - prediction793 := _t1514 - var _t1522 *pb.Declaration - if prediction793 == 3 { - _t1523 := p.parse_data() - data797 := _t1523 - _t1524 := &pb.Declaration{} - _t1524.DeclarationType = &pb.Declaration_Data{Data: data797} - _t1522 = _t1524 + _t1512 = -1 + } + prediction792 := _t1512 + var _t1520 *pb.Declaration + if prediction792 == 3 { + _t1521 := p.parse_data() + data796 := _t1521 + _t1522 := &pb.Declaration{} + _t1522.DeclarationType = &pb.Declaration_Data{Data: data796} + _t1520 = _t1522 } else { - var _t1525 *pb.Declaration - if prediction793 == 2 { - _t1526 := p.parse_constraint() - constraint796 := _t1526 - _t1527 := &pb.Declaration{} - _t1527.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint796} - _t1525 = _t1527 + var _t1523 *pb.Declaration + if prediction792 == 2 { + _t1524 := p.parse_constraint() + constraint795 := _t1524 + _t1525 := &pb.Declaration{} + _t1525.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint795} + _t1523 = _t1525 } else { - var _t1528 *pb.Declaration - if prediction793 == 1 { - _t1529 := p.parse_algorithm() - algorithm795 := _t1529 - _t1530 := &pb.Declaration{} - _t1530.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm795} - _t1528 = _t1530 + var _t1526 *pb.Declaration + if prediction792 == 1 { + _t1527 := p.parse_algorithm() + algorithm794 := _t1527 + _t1528 := &pb.Declaration{} + _t1528.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm794} + _t1526 = _t1528 } else { - var _t1531 *pb.Declaration - if prediction793 == 0 { - _t1532 := p.parse_def() - def794 := _t1532 - _t1533 := &pb.Declaration{} - _t1533.DeclarationType = &pb.Declaration_Def{Def: def794} - _t1531 = _t1533 + var _t1529 *pb.Declaration + if prediction792 == 0 { + _t1530 := p.parse_def() + def793 := _t1530 + _t1531 := &pb.Declaration{} + _t1531.DeclarationType = &pb.Declaration_Def{Def: def793} + _t1529 = _t1531 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1528 = _t1531 + _t1526 = _t1529 } - _t1525 = _t1528 + _t1523 = _t1526 } - _t1522 = _t1525 + _t1520 = _t1523 } - result799 := _t1522 - p.recordSpan(int(span_start798), "Declaration") - return result799 + result798 := _t1520 + p.recordSpan(int(span_start797), "Declaration") + return result798 } func (p *Parser) parse_def() *pb.Def { - span_start803 := int64(p.spanStart()) + span_start802 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("def") - _t1534 := p.parse_relation_id() - relation_id800 := _t1534 - _t1535 := p.parse_abstraction() - abstraction801 := _t1535 - var _t1536 []*pb.Attribute + _t1532 := p.parse_relation_id() + relation_id799 := _t1532 + _t1533 := p.parse_abstraction() + abstraction800 := _t1533 + var _t1534 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1537 := p.parse_attrs() - _t1536 = _t1537 + _t1535 := p.parse_attrs() + _t1534 = _t1535 } - attrs802 := _t1536 + attrs801 := _t1534 p.consumeLiteral(")") - _t1538 := attrs802 - if attrs802 == nil { - _t1538 = []*pb.Attribute{} + _t1536 := attrs801 + if attrs801 == nil { + _t1536 = []*pb.Attribute{} } - _t1539 := &pb.Def{Name: relation_id800, Body: abstraction801, Attrs: _t1538} - result804 := _t1539 - p.recordSpan(int(span_start803), "Def") - return result804 + _t1537 := &pb.Def{Name: relation_id799, Body: abstraction800, Attrs: _t1536} + result803 := _t1537 + p.recordSpan(int(span_start802), "Def") + return result803 } func (p *Parser) parse_relation_id() *pb.RelationId { - span_start808 := int64(p.spanStart()) - var _t1540 int64 + span_start807 := int64(p.spanStart()) + var _t1538 int64 if p.matchLookaheadLiteral(":", 0) { - _t1540 = 0 + _t1538 = 0 } else { - var _t1541 int64 + var _t1539 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1541 = 1 + _t1539 = 1 } else { - _t1541 = -1 + _t1539 = -1 } - _t1540 = _t1541 - } - prediction805 := _t1540 - var _t1542 *pb.RelationId - if prediction805 == 1 { - uint128807 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128807 - _t1542 = &pb.RelationId{IdLow: uint128807.Low, IdHigh: uint128807.High} + _t1538 = _t1539 + } + prediction804 := _t1538 + var _t1540 *pb.RelationId + if prediction804 == 1 { + uint128806 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128806 + _t1540 = &pb.RelationId{IdLow: uint128806.Low, IdHigh: uint128806.High} } else { - var _t1543 *pb.RelationId - if prediction805 == 0 { + var _t1541 *pb.RelationId + if prediction804 == 0 { p.consumeLiteral(":") - symbol806 := p.consumeTerminal("SYMBOL").Value.str - _t1543 = p.relationIdFromString(symbol806) + symbol805 := p.consumeTerminal("SYMBOL").Value.str + _t1541 = p.relationIdFromString(symbol805) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1542 = _t1543 + _t1540 = _t1541 } - result809 := _t1542 - p.recordSpan(int(span_start808), "RelationId") - return result809 + result808 := _t1540 + p.recordSpan(int(span_start807), "RelationId") + return result808 } func (p *Parser) parse_abstraction() *pb.Abstraction { - span_start812 := int64(p.spanStart()) + span_start811 := int64(p.spanStart()) p.consumeLiteral("(") - _t1544 := p.parse_bindings() - bindings810 := _t1544 - _t1545 := p.parse_formula() - formula811 := _t1545 + _t1542 := p.parse_bindings() + bindings809 := _t1542 + _t1543 := p.parse_formula() + formula810 := _t1543 p.consumeLiteral(")") - _t1546 := &pb.Abstraction{Vars: listConcat(bindings810[0].([]*pb.Binding), bindings810[1].([]*pb.Binding)), Value: formula811} - result813 := _t1546 - p.recordSpan(int(span_start812), "Abstraction") - return result813 + _t1544 := &pb.Abstraction{Vars: listConcat(bindings809[0].([]*pb.Binding), bindings809[1].([]*pb.Binding)), Value: formula810} + result812 := _t1544 + p.recordSpan(int(span_start811), "Abstraction") + return result812 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs814 := []*pb.Binding{} - cond815 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond815 { - _t1547 := p.parse_binding() - item816 := _t1547 - xs814 = append(xs814, item816) - cond815 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings817 := xs814 - var _t1548 []*pb.Binding + xs813 := []*pb.Binding{} + cond814 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond814 { + _t1545 := p.parse_binding() + item815 := _t1545 + xs813 = append(xs813, item815) + cond814 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings816 := xs813 + var _t1546 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t1549 := p.parse_value_bindings() - _t1548 = _t1549 + _t1547 := p.parse_value_bindings() + _t1546 = _t1547 } - value_bindings818 := _t1548 + value_bindings817 := _t1546 p.consumeLiteral("]") - _t1550 := value_bindings818 - if value_bindings818 == nil { - _t1550 = []*pb.Binding{} + _t1548 := value_bindings817 + if value_bindings817 == nil { + _t1548 = []*pb.Binding{} } - return []interface{}{bindings817, _t1550} + return []interface{}{bindings816, _t1548} } func (p *Parser) parse_binding() *pb.Binding { - span_start821 := int64(p.spanStart()) - symbol819 := p.consumeTerminal("SYMBOL").Value.str + span_start820 := int64(p.spanStart()) + symbol818 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t1551 := p.parse_type() - type820 := _t1551 - _t1552 := &pb.Var{Name: symbol819} - _t1553 := &pb.Binding{Var: _t1552, Type: type820} - result822 := _t1553 - p.recordSpan(int(span_start821), "Binding") - return result822 + _t1549 := p.parse_type() + type819 := _t1549 + _t1550 := &pb.Var{Name: symbol818} + _t1551 := &pb.Binding{Var: _t1550, Type: type819} + result821 := _t1551 + p.recordSpan(int(span_start820), "Binding") + return result821 } func (p *Parser) parse_type() *pb.Type { - span_start838 := int64(p.spanStart()) - var _t1554 int64 + span_start837 := int64(p.spanStart()) + var _t1552 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1554 = 0 + _t1552 = 0 } else { - var _t1555 int64 + var _t1553 int64 if p.matchLookaheadLiteral("UINT32", 0) { - _t1555 = 13 + _t1553 = 13 } else { - var _t1556 int64 + var _t1554 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t1556 = 4 + _t1554 = 4 } else { - var _t1557 int64 + var _t1555 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t1557 = 1 + _t1555 = 1 } else { - var _t1558 int64 + var _t1556 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t1558 = 8 + _t1556 = 8 } else { - var _t1559 int64 + var _t1557 int64 if p.matchLookaheadLiteral("INT32", 0) { - _t1559 = 11 + _t1557 = 11 } else { - var _t1560 int64 + var _t1558 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t1560 = 5 + _t1558 = 5 } else { - var _t1561 int64 + var _t1559 int64 if p.matchLookaheadLiteral("INT", 0) { - _t1561 = 2 + _t1559 = 2 } else { - var _t1562 int64 + var _t1560 int64 if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1562 = 12 + _t1560 = 12 } else { - var _t1563 int64 + var _t1561 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t1563 = 3 + _t1561 = 3 } else { - var _t1564 int64 + var _t1562 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t1564 = 7 + _t1562 = 7 } else { - var _t1565 int64 + var _t1563 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t1565 = 6 + _t1563 = 6 } else { - var _t1566 int64 + var _t1564 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1566 = 10 + _t1564 = 10 } else { - var _t1567 int64 + var _t1565 int64 if p.matchLookaheadLiteral("(", 0) { - _t1567 = 9 + _t1565 = 9 } else { - _t1567 = -1 + _t1565 = -1 } - _t1566 = _t1567 + _t1564 = _t1565 } - _t1565 = _t1566 + _t1563 = _t1564 } - _t1564 = _t1565 + _t1562 = _t1563 } - _t1563 = _t1564 + _t1561 = _t1562 } - _t1562 = _t1563 + _t1560 = _t1561 } - _t1561 = _t1562 + _t1559 = _t1560 } - _t1560 = _t1561 + _t1558 = _t1559 } - _t1559 = _t1560 + _t1557 = _t1558 } - _t1558 = _t1559 + _t1556 = _t1557 } - _t1557 = _t1558 + _t1555 = _t1556 } - _t1556 = _t1557 + _t1554 = _t1555 } - _t1555 = _t1556 + _t1553 = _t1554 } - _t1554 = _t1555 - } - prediction823 := _t1554 - var _t1568 *pb.Type - if prediction823 == 13 { - _t1569 := p.parse_uint32_type() - uint32_type837 := _t1569 - _t1570 := &pb.Type{} - _t1570.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type837} - _t1568 = _t1570 + _t1552 = _t1553 + } + prediction822 := _t1552 + var _t1566 *pb.Type + if prediction822 == 13 { + _t1567 := p.parse_uint32_type() + uint32_type836 := _t1567 + _t1568 := &pb.Type{} + _t1568.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type836} + _t1566 = _t1568 } else { - var _t1571 *pb.Type - if prediction823 == 12 { - _t1572 := p.parse_float32_type() - float32_type836 := _t1572 - _t1573 := &pb.Type{} - _t1573.Type = &pb.Type_Float32Type{Float32Type: float32_type836} - _t1571 = _t1573 + var _t1569 *pb.Type + if prediction822 == 12 { + _t1570 := p.parse_float32_type() + float32_type835 := _t1570 + _t1571 := &pb.Type{} + _t1571.Type = &pb.Type_Float32Type{Float32Type: float32_type835} + _t1569 = _t1571 } else { - var _t1574 *pb.Type - if prediction823 == 11 { - _t1575 := p.parse_int32_type() - int32_type835 := _t1575 - _t1576 := &pb.Type{} - _t1576.Type = &pb.Type_Int32Type{Int32Type: int32_type835} - _t1574 = _t1576 + var _t1572 *pb.Type + if prediction822 == 11 { + _t1573 := p.parse_int32_type() + int32_type834 := _t1573 + _t1574 := &pb.Type{} + _t1574.Type = &pb.Type_Int32Type{Int32Type: int32_type834} + _t1572 = _t1574 } else { - var _t1577 *pb.Type - if prediction823 == 10 { - _t1578 := p.parse_boolean_type() - boolean_type834 := _t1578 - _t1579 := &pb.Type{} - _t1579.Type = &pb.Type_BooleanType{BooleanType: boolean_type834} - _t1577 = _t1579 + var _t1575 *pb.Type + if prediction822 == 10 { + _t1576 := p.parse_boolean_type() + boolean_type833 := _t1576 + _t1577 := &pb.Type{} + _t1577.Type = &pb.Type_BooleanType{BooleanType: boolean_type833} + _t1575 = _t1577 } else { - var _t1580 *pb.Type - if prediction823 == 9 { - _t1581 := p.parse_decimal_type() - decimal_type833 := _t1581 - _t1582 := &pb.Type{} - _t1582.Type = &pb.Type_DecimalType{DecimalType: decimal_type833} - _t1580 = _t1582 + var _t1578 *pb.Type + if prediction822 == 9 { + _t1579 := p.parse_decimal_type() + decimal_type832 := _t1579 + _t1580 := &pb.Type{} + _t1580.Type = &pb.Type_DecimalType{DecimalType: decimal_type832} + _t1578 = _t1580 } else { - var _t1583 *pb.Type - if prediction823 == 8 { - _t1584 := p.parse_missing_type() - missing_type832 := _t1584 - _t1585 := &pb.Type{} - _t1585.Type = &pb.Type_MissingType{MissingType: missing_type832} - _t1583 = _t1585 + var _t1581 *pb.Type + if prediction822 == 8 { + _t1582 := p.parse_missing_type() + missing_type831 := _t1582 + _t1583 := &pb.Type{} + _t1583.Type = &pb.Type_MissingType{MissingType: missing_type831} + _t1581 = _t1583 } else { - var _t1586 *pb.Type - if prediction823 == 7 { - _t1587 := p.parse_datetime_type() - datetime_type831 := _t1587 - _t1588 := &pb.Type{} - _t1588.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type831} - _t1586 = _t1588 + var _t1584 *pb.Type + if prediction822 == 7 { + _t1585 := p.parse_datetime_type() + datetime_type830 := _t1585 + _t1586 := &pb.Type{} + _t1586.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type830} + _t1584 = _t1586 } else { - var _t1589 *pb.Type - if prediction823 == 6 { - _t1590 := p.parse_date_type() - date_type830 := _t1590 - _t1591 := &pb.Type{} - _t1591.Type = &pb.Type_DateType{DateType: date_type830} - _t1589 = _t1591 + var _t1587 *pb.Type + if prediction822 == 6 { + _t1588 := p.parse_date_type() + date_type829 := _t1588 + _t1589 := &pb.Type{} + _t1589.Type = &pb.Type_DateType{DateType: date_type829} + _t1587 = _t1589 } else { - var _t1592 *pb.Type - if prediction823 == 5 { - _t1593 := p.parse_int128_type() - int128_type829 := _t1593 - _t1594 := &pb.Type{} - _t1594.Type = &pb.Type_Int128Type{Int128Type: int128_type829} - _t1592 = _t1594 + var _t1590 *pb.Type + if prediction822 == 5 { + _t1591 := p.parse_int128_type() + int128_type828 := _t1591 + _t1592 := &pb.Type{} + _t1592.Type = &pb.Type_Int128Type{Int128Type: int128_type828} + _t1590 = _t1592 } else { - var _t1595 *pb.Type - if prediction823 == 4 { - _t1596 := p.parse_uint128_type() - uint128_type828 := _t1596 - _t1597 := &pb.Type{} - _t1597.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type828} - _t1595 = _t1597 + var _t1593 *pb.Type + if prediction822 == 4 { + _t1594 := p.parse_uint128_type() + uint128_type827 := _t1594 + _t1595 := &pb.Type{} + _t1595.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type827} + _t1593 = _t1595 } else { - var _t1598 *pb.Type - if prediction823 == 3 { - _t1599 := p.parse_float_type() - float_type827 := _t1599 - _t1600 := &pb.Type{} - _t1600.Type = &pb.Type_FloatType{FloatType: float_type827} - _t1598 = _t1600 + var _t1596 *pb.Type + if prediction822 == 3 { + _t1597 := p.parse_float_type() + float_type826 := _t1597 + _t1598 := &pb.Type{} + _t1598.Type = &pb.Type_FloatType{FloatType: float_type826} + _t1596 = _t1598 } else { - var _t1601 *pb.Type - if prediction823 == 2 { - _t1602 := p.parse_int_type() - int_type826 := _t1602 - _t1603 := &pb.Type{} - _t1603.Type = &pb.Type_IntType{IntType: int_type826} - _t1601 = _t1603 + var _t1599 *pb.Type + if prediction822 == 2 { + _t1600 := p.parse_int_type() + int_type825 := _t1600 + _t1601 := &pb.Type{} + _t1601.Type = &pb.Type_IntType{IntType: int_type825} + _t1599 = _t1601 } else { - var _t1604 *pb.Type - if prediction823 == 1 { - _t1605 := p.parse_string_type() - string_type825 := _t1605 - _t1606 := &pb.Type{} - _t1606.Type = &pb.Type_StringType{StringType: string_type825} - _t1604 = _t1606 + var _t1602 *pb.Type + if prediction822 == 1 { + _t1603 := p.parse_string_type() + string_type824 := _t1603 + _t1604 := &pb.Type{} + _t1604.Type = &pb.Type_StringType{StringType: string_type824} + _t1602 = _t1604 } else { - var _t1607 *pb.Type - if prediction823 == 0 { - _t1608 := p.parse_unspecified_type() - unspecified_type824 := _t1608 - _t1609 := &pb.Type{} - _t1609.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type824} - _t1607 = _t1609 + var _t1605 *pb.Type + if prediction822 == 0 { + _t1606 := p.parse_unspecified_type() + unspecified_type823 := _t1606 + _t1607 := &pb.Type{} + _t1607.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type823} + _t1605 = _t1607 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1604 = _t1607 + _t1602 = _t1605 } - _t1601 = _t1604 + _t1599 = _t1602 } - _t1598 = _t1601 + _t1596 = _t1599 } - _t1595 = _t1598 + _t1593 = _t1596 } - _t1592 = _t1595 + _t1590 = _t1593 } - _t1589 = _t1592 + _t1587 = _t1590 } - _t1586 = _t1589 + _t1584 = _t1587 } - _t1583 = _t1586 + _t1581 = _t1584 } - _t1580 = _t1583 + _t1578 = _t1581 } - _t1577 = _t1580 + _t1575 = _t1578 } - _t1574 = _t1577 + _t1572 = _t1575 } - _t1571 = _t1574 + _t1569 = _t1572 } - _t1568 = _t1571 + _t1566 = _t1569 } - result839 := _t1568 - p.recordSpan(int(span_start838), "Type") - return result839 + result838 := _t1566 + p.recordSpan(int(span_start837), "Type") + return result838 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start840 := int64(p.spanStart()) + span_start839 := int64(p.spanStart()) p.consumeLiteral("UNKNOWN") - _t1610 := &pb.UnspecifiedType{} - result841 := _t1610 - p.recordSpan(int(span_start840), "UnspecifiedType") - return result841 + _t1608 := &pb.UnspecifiedType{} + result840 := _t1608 + p.recordSpan(int(span_start839), "UnspecifiedType") + return result840 } func (p *Parser) parse_string_type() *pb.StringType { - span_start842 := int64(p.spanStart()) + span_start841 := int64(p.spanStart()) p.consumeLiteral("STRING") - _t1611 := &pb.StringType{} - result843 := _t1611 - p.recordSpan(int(span_start842), "StringType") - return result843 + _t1609 := &pb.StringType{} + result842 := _t1609 + p.recordSpan(int(span_start841), "StringType") + return result842 } func (p *Parser) parse_int_type() *pb.IntType { - span_start844 := int64(p.spanStart()) + span_start843 := int64(p.spanStart()) p.consumeLiteral("INT") - _t1612 := &pb.IntType{} - result845 := _t1612 - p.recordSpan(int(span_start844), "IntType") - return result845 + _t1610 := &pb.IntType{} + result844 := _t1610 + p.recordSpan(int(span_start843), "IntType") + return result844 } func (p *Parser) parse_float_type() *pb.FloatType { - span_start846 := int64(p.spanStart()) + span_start845 := int64(p.spanStart()) p.consumeLiteral("FLOAT") - _t1613 := &pb.FloatType{} - result847 := _t1613 - p.recordSpan(int(span_start846), "FloatType") - return result847 + _t1611 := &pb.FloatType{} + result846 := _t1611 + p.recordSpan(int(span_start845), "FloatType") + return result846 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start848 := int64(p.spanStart()) + span_start847 := int64(p.spanStart()) p.consumeLiteral("UINT128") - _t1614 := &pb.UInt128Type{} - result849 := _t1614 - p.recordSpan(int(span_start848), "UInt128Type") - return result849 + _t1612 := &pb.UInt128Type{} + result848 := _t1612 + p.recordSpan(int(span_start847), "UInt128Type") + return result848 } func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start850 := int64(p.spanStart()) + span_start849 := int64(p.spanStart()) p.consumeLiteral("INT128") - _t1615 := &pb.Int128Type{} - result851 := _t1615 - p.recordSpan(int(span_start850), "Int128Type") - return result851 + _t1613 := &pb.Int128Type{} + result850 := _t1613 + p.recordSpan(int(span_start849), "Int128Type") + return result850 } func (p *Parser) parse_date_type() *pb.DateType { - span_start852 := int64(p.spanStart()) + span_start851 := int64(p.spanStart()) p.consumeLiteral("DATE") - _t1616 := &pb.DateType{} - result853 := _t1616 - p.recordSpan(int(span_start852), "DateType") - return result853 + _t1614 := &pb.DateType{} + result852 := _t1614 + p.recordSpan(int(span_start851), "DateType") + return result852 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start854 := int64(p.spanStart()) + span_start853 := int64(p.spanStart()) p.consumeLiteral("DATETIME") - _t1617 := &pb.DateTimeType{} - result855 := _t1617 - p.recordSpan(int(span_start854), "DateTimeType") - return result855 + _t1615 := &pb.DateTimeType{} + result854 := _t1615 + p.recordSpan(int(span_start853), "DateTimeType") + return result854 } func (p *Parser) parse_missing_type() *pb.MissingType { - span_start856 := int64(p.spanStart()) + span_start855 := int64(p.spanStart()) p.consumeLiteral("MISSING") - _t1618 := &pb.MissingType{} - result857 := _t1618 - p.recordSpan(int(span_start856), "MissingType") - return result857 + _t1616 := &pb.MissingType{} + result856 := _t1616 + p.recordSpan(int(span_start855), "MissingType") + return result856 } func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start860 := int64(p.spanStart()) + span_start859 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int858 := p.consumeTerminal("INT").Value.i64 - int_3859 := p.consumeTerminal("INT").Value.i64 + int857 := p.consumeTerminal("INT").Value.i64 + int_3858 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1619 := &pb.DecimalType{Precision: int32(int858), Scale: int32(int_3859)} - result861 := _t1619 - p.recordSpan(int(span_start860), "DecimalType") - return result861 + _t1617 := &pb.DecimalType{Precision: int32(int857), Scale: int32(int_3858)} + result860 := _t1617 + p.recordSpan(int(span_start859), "DecimalType") + return result860 } func (p *Parser) parse_boolean_type() *pb.BooleanType { - span_start862 := int64(p.spanStart()) + span_start861 := int64(p.spanStart()) p.consumeLiteral("BOOLEAN") - _t1620 := &pb.BooleanType{} - result863 := _t1620 - p.recordSpan(int(span_start862), "BooleanType") - return result863 + _t1618 := &pb.BooleanType{} + result862 := _t1618 + p.recordSpan(int(span_start861), "BooleanType") + return result862 } func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start864 := int64(p.spanStart()) + span_start863 := int64(p.spanStart()) p.consumeLiteral("INT32") - _t1621 := &pb.Int32Type{} - result865 := _t1621 - p.recordSpan(int(span_start864), "Int32Type") - return result865 + _t1619 := &pb.Int32Type{} + result864 := _t1619 + p.recordSpan(int(span_start863), "Int32Type") + return result864 } func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start866 := int64(p.spanStart()) + span_start865 := int64(p.spanStart()) p.consumeLiteral("FLOAT32") - _t1622 := &pb.Float32Type{} - result867 := _t1622 - p.recordSpan(int(span_start866), "Float32Type") - return result867 + _t1620 := &pb.Float32Type{} + result866 := _t1620 + p.recordSpan(int(span_start865), "Float32Type") + return result866 } func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start868 := int64(p.spanStart()) + span_start867 := int64(p.spanStart()) p.consumeLiteral("UINT32") - _t1623 := &pb.UInt32Type{} - result869 := _t1623 - p.recordSpan(int(span_start868), "UInt32Type") - return result869 + _t1621 := &pb.UInt32Type{} + result868 := _t1621 + p.recordSpan(int(span_start867), "UInt32Type") + return result868 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs870 := []*pb.Binding{} - cond871 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond871 { - _t1624 := p.parse_binding() - item872 := _t1624 - xs870 = append(xs870, item872) - cond871 = p.matchLookaheadTerminal("SYMBOL", 0) + xs869 := []*pb.Binding{} + cond870 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond870 { + _t1622 := p.parse_binding() + item871 := _t1622 + xs869 = append(xs869, item871) + cond870 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings873 := xs870 - return bindings873 + bindings872 := xs869 + return bindings872 } func (p *Parser) parse_formula() *pb.Formula { - span_start888 := int64(p.spanStart()) - var _t1625 int64 + span_start887 := int64(p.spanStart()) + var _t1623 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1626 int64 + var _t1624 int64 if p.matchLookaheadLiteral("true", 1) { - _t1626 = 0 + _t1624 = 0 } else { - var _t1627 int64 + var _t1625 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t1627 = 11 + _t1625 = 11 } else { - var _t1628 int64 + var _t1626 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t1628 = 3 + _t1626 = 3 } else { - var _t1629 int64 + var _t1627 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1629 = 10 + _t1627 = 10 } else { - var _t1630 int64 + var _t1628 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t1630 = 9 + _t1628 = 9 } else { - var _t1631 int64 + var _t1629 int64 if p.matchLookaheadLiteral("or", 1) { - _t1631 = 5 + _t1629 = 5 } else { - var _t1632 int64 + var _t1630 int64 if p.matchLookaheadLiteral("not", 1) { - _t1632 = 6 + _t1630 = 6 } else { - var _t1633 int64 + var _t1631 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t1633 = 7 + _t1631 = 7 } else { - var _t1634 int64 + var _t1632 int64 if p.matchLookaheadLiteral("false", 1) { - _t1634 = 1 + _t1632 = 1 } else { - var _t1635 int64 + var _t1633 int64 if p.matchLookaheadLiteral("exists", 1) { - _t1635 = 2 + _t1633 = 2 } else { - var _t1636 int64 + var _t1634 int64 if p.matchLookaheadLiteral("cast", 1) { - _t1636 = 12 + _t1634 = 12 } else { - var _t1637 int64 + var _t1635 int64 if p.matchLookaheadLiteral("atom", 1) { - _t1637 = 8 + _t1635 = 8 } else { - var _t1638 int64 + var _t1636 int64 if p.matchLookaheadLiteral("and", 1) { - _t1638 = 4 + _t1636 = 4 } else { - var _t1639 int64 + var _t1637 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1639 = 10 + _t1637 = 10 } else { - var _t1640 int64 + var _t1638 int64 if p.matchLookaheadLiteral(">", 1) { - _t1640 = 10 + _t1638 = 10 } else { - var _t1641 int64 + var _t1639 int64 if p.matchLookaheadLiteral("=", 1) { - _t1641 = 10 + _t1639 = 10 } else { - var _t1642 int64 + var _t1640 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1642 = 10 + _t1640 = 10 } else { - var _t1643 int64 + var _t1641 int64 if p.matchLookaheadLiteral("<", 1) { - _t1643 = 10 + _t1641 = 10 } else { - var _t1644 int64 + var _t1642 int64 if p.matchLookaheadLiteral("/", 1) { - _t1644 = 10 + _t1642 = 10 } else { - var _t1645 int64 + var _t1643 int64 if p.matchLookaheadLiteral("-", 1) { - _t1645 = 10 + _t1643 = 10 } else { - var _t1646 int64 + var _t1644 int64 if p.matchLookaheadLiteral("+", 1) { - _t1646 = 10 + _t1644 = 10 } else { - var _t1647 int64 + var _t1645 int64 if p.matchLookaheadLiteral("*", 1) { - _t1647 = 10 + _t1645 = 10 } else { - _t1647 = -1 + _t1645 = -1 } - _t1646 = _t1647 + _t1644 = _t1645 } - _t1645 = _t1646 + _t1643 = _t1644 } - _t1644 = _t1645 + _t1642 = _t1643 } - _t1643 = _t1644 + _t1641 = _t1642 } - _t1642 = _t1643 + _t1640 = _t1641 } - _t1641 = _t1642 + _t1639 = _t1640 } - _t1640 = _t1641 + _t1638 = _t1639 } - _t1639 = _t1640 + _t1637 = _t1638 } - _t1638 = _t1639 + _t1636 = _t1637 } - _t1637 = _t1638 + _t1635 = _t1636 } - _t1636 = _t1637 + _t1634 = _t1635 } - _t1635 = _t1636 + _t1633 = _t1634 } - _t1634 = _t1635 + _t1632 = _t1633 } - _t1633 = _t1634 + _t1631 = _t1632 } - _t1632 = _t1633 + _t1630 = _t1631 } - _t1631 = _t1632 + _t1629 = _t1630 } - _t1630 = _t1631 + _t1628 = _t1629 } - _t1629 = _t1630 + _t1627 = _t1628 } - _t1628 = _t1629 + _t1626 = _t1627 } - _t1627 = _t1628 + _t1625 = _t1626 } - _t1626 = _t1627 + _t1624 = _t1625 } - _t1625 = _t1626 + _t1623 = _t1624 } else { - _t1625 = -1 - } - prediction874 := _t1625 - var _t1648 *pb.Formula - if prediction874 == 12 { - _t1649 := p.parse_cast() - cast887 := _t1649 - _t1650 := &pb.Formula{} - _t1650.FormulaType = &pb.Formula_Cast{Cast: cast887} - _t1648 = _t1650 + _t1623 = -1 + } + prediction873 := _t1623 + var _t1646 *pb.Formula + if prediction873 == 12 { + _t1647 := p.parse_cast() + cast886 := _t1647 + _t1648 := &pb.Formula{} + _t1648.FormulaType = &pb.Formula_Cast{Cast: cast886} + _t1646 = _t1648 } else { - var _t1651 *pb.Formula - if prediction874 == 11 { - _t1652 := p.parse_rel_atom() - rel_atom886 := _t1652 - _t1653 := &pb.Formula{} - _t1653.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom886} - _t1651 = _t1653 + var _t1649 *pb.Formula + if prediction873 == 11 { + _t1650 := p.parse_rel_atom() + rel_atom885 := _t1650 + _t1651 := &pb.Formula{} + _t1651.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom885} + _t1649 = _t1651 } else { - var _t1654 *pb.Formula - if prediction874 == 10 { - _t1655 := p.parse_primitive() - primitive885 := _t1655 - _t1656 := &pb.Formula{} - _t1656.FormulaType = &pb.Formula_Primitive{Primitive: primitive885} - _t1654 = _t1656 + var _t1652 *pb.Formula + if prediction873 == 10 { + _t1653 := p.parse_primitive() + primitive884 := _t1653 + _t1654 := &pb.Formula{} + _t1654.FormulaType = &pb.Formula_Primitive{Primitive: primitive884} + _t1652 = _t1654 } else { - var _t1657 *pb.Formula - if prediction874 == 9 { - _t1658 := p.parse_pragma() - pragma884 := _t1658 - _t1659 := &pb.Formula{} - _t1659.FormulaType = &pb.Formula_Pragma{Pragma: pragma884} - _t1657 = _t1659 + var _t1655 *pb.Formula + if prediction873 == 9 { + _t1656 := p.parse_pragma() + pragma883 := _t1656 + _t1657 := &pb.Formula{} + _t1657.FormulaType = &pb.Formula_Pragma{Pragma: pragma883} + _t1655 = _t1657 } else { - var _t1660 *pb.Formula - if prediction874 == 8 { - _t1661 := p.parse_atom() - atom883 := _t1661 - _t1662 := &pb.Formula{} - _t1662.FormulaType = &pb.Formula_Atom{Atom: atom883} - _t1660 = _t1662 + var _t1658 *pb.Formula + if prediction873 == 8 { + _t1659 := p.parse_atom() + atom882 := _t1659 + _t1660 := &pb.Formula{} + _t1660.FormulaType = &pb.Formula_Atom{Atom: atom882} + _t1658 = _t1660 } else { - var _t1663 *pb.Formula - if prediction874 == 7 { - _t1664 := p.parse_ffi() - ffi882 := _t1664 - _t1665 := &pb.Formula{} - _t1665.FormulaType = &pb.Formula_Ffi{Ffi: ffi882} - _t1663 = _t1665 + var _t1661 *pb.Formula + if prediction873 == 7 { + _t1662 := p.parse_ffi() + ffi881 := _t1662 + _t1663 := &pb.Formula{} + _t1663.FormulaType = &pb.Formula_Ffi{Ffi: ffi881} + _t1661 = _t1663 } else { - var _t1666 *pb.Formula - if prediction874 == 6 { - _t1667 := p.parse_not() - not881 := _t1667 - _t1668 := &pb.Formula{} - _t1668.FormulaType = &pb.Formula_Not{Not: not881} - _t1666 = _t1668 + var _t1664 *pb.Formula + if prediction873 == 6 { + _t1665 := p.parse_not() + not880 := _t1665 + _t1666 := &pb.Formula{} + _t1666.FormulaType = &pb.Formula_Not{Not: not880} + _t1664 = _t1666 } else { - var _t1669 *pb.Formula - if prediction874 == 5 { - _t1670 := p.parse_disjunction() - disjunction880 := _t1670 - _t1671 := &pb.Formula{} - _t1671.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction880} - _t1669 = _t1671 + var _t1667 *pb.Formula + if prediction873 == 5 { + _t1668 := p.parse_disjunction() + disjunction879 := _t1668 + _t1669 := &pb.Formula{} + _t1669.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction879} + _t1667 = _t1669 } else { - var _t1672 *pb.Formula - if prediction874 == 4 { - _t1673 := p.parse_conjunction() - conjunction879 := _t1673 - _t1674 := &pb.Formula{} - _t1674.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction879} - _t1672 = _t1674 + var _t1670 *pb.Formula + if prediction873 == 4 { + _t1671 := p.parse_conjunction() + conjunction878 := _t1671 + _t1672 := &pb.Formula{} + _t1672.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction878} + _t1670 = _t1672 } else { - var _t1675 *pb.Formula - if prediction874 == 3 { - _t1676 := p.parse_reduce() - reduce878 := _t1676 - _t1677 := &pb.Formula{} - _t1677.FormulaType = &pb.Formula_Reduce{Reduce: reduce878} - _t1675 = _t1677 + var _t1673 *pb.Formula + if prediction873 == 3 { + _t1674 := p.parse_reduce() + reduce877 := _t1674 + _t1675 := &pb.Formula{} + _t1675.FormulaType = &pb.Formula_Reduce{Reduce: reduce877} + _t1673 = _t1675 } else { - var _t1678 *pb.Formula - if prediction874 == 2 { - _t1679 := p.parse_exists() - exists877 := _t1679 - _t1680 := &pb.Formula{} - _t1680.FormulaType = &pb.Formula_Exists{Exists: exists877} - _t1678 = _t1680 + var _t1676 *pb.Formula + if prediction873 == 2 { + _t1677 := p.parse_exists() + exists876 := _t1677 + _t1678 := &pb.Formula{} + _t1678.FormulaType = &pb.Formula_Exists{Exists: exists876} + _t1676 = _t1678 } else { - var _t1681 *pb.Formula - if prediction874 == 1 { - _t1682 := p.parse_false() - false876 := _t1682 - _t1683 := &pb.Formula{} - _t1683.FormulaType = &pb.Formula_Disjunction{Disjunction: false876} - _t1681 = _t1683 + var _t1679 *pb.Formula + if prediction873 == 1 { + _t1680 := p.parse_false() + false875 := _t1680 + _t1681 := &pb.Formula{} + _t1681.FormulaType = &pb.Formula_Disjunction{Disjunction: false875} + _t1679 = _t1681 } else { - var _t1684 *pb.Formula - if prediction874 == 0 { - _t1685 := p.parse_true() - true875 := _t1685 - _t1686 := &pb.Formula{} - _t1686.FormulaType = &pb.Formula_Conjunction{Conjunction: true875} - _t1684 = _t1686 + var _t1682 *pb.Formula + if prediction873 == 0 { + _t1683 := p.parse_true() + true874 := _t1683 + _t1684 := &pb.Formula{} + _t1684.FormulaType = &pb.Formula_Conjunction{Conjunction: true874} + _t1682 = _t1684 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1681 = _t1684 + _t1679 = _t1682 } - _t1678 = _t1681 + _t1676 = _t1679 } - _t1675 = _t1678 + _t1673 = _t1676 } - _t1672 = _t1675 + _t1670 = _t1673 } - _t1669 = _t1672 + _t1667 = _t1670 } - _t1666 = _t1669 + _t1664 = _t1667 } - _t1663 = _t1666 + _t1661 = _t1664 } - _t1660 = _t1663 + _t1658 = _t1661 } - _t1657 = _t1660 + _t1655 = _t1658 } - _t1654 = _t1657 + _t1652 = _t1655 } - _t1651 = _t1654 + _t1649 = _t1652 } - _t1648 = _t1651 + _t1646 = _t1649 } - result889 := _t1648 - p.recordSpan(int(span_start888), "Formula") - return result889 + result888 := _t1646 + p.recordSpan(int(span_start887), "Formula") + return result888 } func (p *Parser) parse_true() *pb.Conjunction { - span_start890 := int64(p.spanStart()) + span_start889 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t1687 := &pb.Conjunction{Args: []*pb.Formula{}} - result891 := _t1687 - p.recordSpan(int(span_start890), "Conjunction") - return result891 + _t1685 := &pb.Conjunction{Args: []*pb.Formula{}} + result890 := _t1685 + p.recordSpan(int(span_start889), "Conjunction") + return result890 } func (p *Parser) parse_false() *pb.Disjunction { - span_start892 := int64(p.spanStart()) + span_start891 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t1688 := &pb.Disjunction{Args: []*pb.Formula{}} - result893 := _t1688 - p.recordSpan(int(span_start892), "Disjunction") - return result893 + _t1686 := &pb.Disjunction{Args: []*pb.Formula{}} + result892 := _t1686 + p.recordSpan(int(span_start891), "Disjunction") + return result892 } func (p *Parser) parse_exists() *pb.Exists { - span_start896 := int64(p.spanStart()) + span_start895 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("exists") - _t1689 := p.parse_bindings() - bindings894 := _t1689 - _t1690 := p.parse_formula() - formula895 := _t1690 + _t1687 := p.parse_bindings() + bindings893 := _t1687 + _t1688 := p.parse_formula() + formula894 := _t1688 p.consumeLiteral(")") - _t1691 := &pb.Abstraction{Vars: listConcat(bindings894[0].([]*pb.Binding), bindings894[1].([]*pb.Binding)), Value: formula895} - _t1692 := &pb.Exists{Body: _t1691} - result897 := _t1692 - p.recordSpan(int(span_start896), "Exists") - return result897 + _t1689 := &pb.Abstraction{Vars: listConcat(bindings893[0].([]*pb.Binding), bindings893[1].([]*pb.Binding)), Value: formula894} + _t1690 := &pb.Exists{Body: _t1689} + result896 := _t1690 + p.recordSpan(int(span_start895), "Exists") + return result896 } func (p *Parser) parse_reduce() *pb.Reduce { - span_start901 := int64(p.spanStart()) + span_start900 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("reduce") - _t1693 := p.parse_abstraction() - abstraction898 := _t1693 - _t1694 := p.parse_abstraction() - abstraction_3899 := _t1694 - _t1695 := p.parse_terms() - terms900 := _t1695 + _t1691 := p.parse_abstraction() + abstraction897 := _t1691 + _t1692 := p.parse_abstraction() + abstraction_3898 := _t1692 + _t1693 := p.parse_terms() + terms899 := _t1693 p.consumeLiteral(")") - _t1696 := &pb.Reduce{Op: abstraction898, Body: abstraction_3899, Terms: terms900} - result902 := _t1696 - p.recordSpan(int(span_start901), "Reduce") - return result902 + _t1694 := &pb.Reduce{Op: abstraction897, Body: abstraction_3898, Terms: terms899} + result901 := _t1694 + p.recordSpan(int(span_start900), "Reduce") + return result901 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs903 := []*pb.Term{} - cond904 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond904 { - _t1697 := p.parse_term() - item905 := _t1697 - xs903 = append(xs903, item905) - cond904 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - terms906 := xs903 + xs902 := []*pb.Term{} + cond903 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond903 { + _t1695 := p.parse_term() + item904 := _t1695 + xs902 = append(xs902, item904) + cond903 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + } + terms905 := xs902 p.consumeLiteral(")") - return terms906 + return terms905 } func (p *Parser) parse_term() *pb.Term { - span_start910 := int64(p.spanStart()) - var _t1698 int64 + span_start909 := int64(p.spanStart()) + var _t1696 int64 if p.matchLookaheadLiteral("true", 0) { - _t1698 = 1 + _t1696 = 1 } else { - var _t1699 int64 + var _t1697 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1699 = 1 + _t1697 = 1 } else { - var _t1700 int64 + var _t1698 int64 if p.matchLookaheadLiteral("false", 0) { - _t1700 = 1 + _t1698 = 1 } else { - var _t1701 int64 + var _t1699 int64 if p.matchLookaheadLiteral("(", 0) { - _t1701 = 1 + _t1699 = 1 } else { - var _t1702 int64 + var _t1700 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1702 = 0 + _t1700 = 0 } else { - var _t1703 int64 + var _t1701 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1703 = 1 + _t1701 = 1 } else { - var _t1704 int64 + var _t1702 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1704 = 1 + _t1702 = 1 } else { - var _t1705 int64 + var _t1703 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1705 = 1 + _t1703 = 1 } else { - var _t1706 int64 + var _t1704 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1706 = 1 + _t1704 = 1 } else { - var _t1707 int64 + var _t1705 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1707 = 1 + _t1705 = 1 } else { - var _t1708 int64 + var _t1706 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1708 = 1 + _t1706 = 1 } else { - var _t1709 int64 + var _t1707 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1709 = 1 + _t1707 = 1 } else { - var _t1710 int64 + var _t1708 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1710 = 1 + _t1708 = 1 } else { - var _t1711 int64 + var _t1709 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1711 = 1 + _t1709 = 1 } else { - _t1711 = -1 + _t1709 = -1 } - _t1710 = _t1711 + _t1708 = _t1709 } - _t1709 = _t1710 + _t1707 = _t1708 } - _t1708 = _t1709 + _t1706 = _t1707 } - _t1707 = _t1708 + _t1705 = _t1706 } - _t1706 = _t1707 + _t1704 = _t1705 } - _t1705 = _t1706 + _t1703 = _t1704 } - _t1704 = _t1705 + _t1702 = _t1703 } - _t1703 = _t1704 + _t1701 = _t1702 } - _t1702 = _t1703 + _t1700 = _t1701 } - _t1701 = _t1702 + _t1699 = _t1700 } - _t1700 = _t1701 + _t1698 = _t1699 } - _t1699 = _t1700 + _t1697 = _t1698 } - _t1698 = _t1699 - } - prediction907 := _t1698 - var _t1712 *pb.Term - if prediction907 == 1 { - _t1713 := p.parse_value() - value909 := _t1713 - _t1714 := &pb.Term{} - _t1714.TermType = &pb.Term_Constant{Constant: value909} - _t1712 = _t1714 + _t1696 = _t1697 + } + prediction906 := _t1696 + var _t1710 *pb.Term + if prediction906 == 1 { + _t1711 := p.parse_value() + value908 := _t1711 + _t1712 := &pb.Term{} + _t1712.TermType = &pb.Term_Constant{Constant: value908} + _t1710 = _t1712 } else { - var _t1715 *pb.Term - if prediction907 == 0 { - _t1716 := p.parse_var() - var908 := _t1716 - _t1717 := &pb.Term{} - _t1717.TermType = &pb.Term_Var{Var: var908} - _t1715 = _t1717 + var _t1713 *pb.Term + if prediction906 == 0 { + _t1714 := p.parse_var() + var907 := _t1714 + _t1715 := &pb.Term{} + _t1715.TermType = &pb.Term_Var{Var: var907} + _t1713 = _t1715 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1712 = _t1715 + _t1710 = _t1713 } - result911 := _t1712 - p.recordSpan(int(span_start910), "Term") - return result911 + result910 := _t1710 + p.recordSpan(int(span_start909), "Term") + return result910 } func (p *Parser) parse_var() *pb.Var { - span_start913 := int64(p.spanStart()) - symbol912 := p.consumeTerminal("SYMBOL").Value.str - _t1718 := &pb.Var{Name: symbol912} - result914 := _t1718 - p.recordSpan(int(span_start913), "Var") - return result914 + span_start912 := int64(p.spanStart()) + symbol911 := p.consumeTerminal("SYMBOL").Value.str + _t1716 := &pb.Var{Name: symbol911} + result913 := _t1716 + p.recordSpan(int(span_start912), "Var") + return result913 } func (p *Parser) parse_value() *pb.Value { - span_start928 := int64(p.spanStart()) - var _t1719 int64 + span_start927 := int64(p.spanStart()) + var _t1717 int64 if p.matchLookaheadLiteral("true", 0) { - _t1719 = 12 + _t1717 = 12 } else { - var _t1720 int64 + var _t1718 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1720 = 11 + _t1718 = 11 } else { - var _t1721 int64 + var _t1719 int64 if p.matchLookaheadLiteral("false", 0) { - _t1721 = 12 + _t1719 = 12 } else { - var _t1722 int64 + var _t1720 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1723 int64 + var _t1721 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1723 = 1 + _t1721 = 1 } else { - var _t1724 int64 + var _t1722 int64 if p.matchLookaheadLiteral("date", 1) { - _t1724 = 0 + _t1722 = 0 } else { - _t1724 = -1 + _t1722 = -1 } - _t1723 = _t1724 + _t1721 = _t1722 } - _t1722 = _t1723 + _t1720 = _t1721 } else { - var _t1725 int64 + var _t1723 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1725 = 7 + _t1723 = 7 } else { - var _t1726 int64 + var _t1724 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1726 = 8 + _t1724 = 8 } else { - var _t1727 int64 + var _t1725 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1727 = 2 + _t1725 = 2 } else { - var _t1728 int64 + var _t1726 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1728 = 3 + _t1726 = 3 } else { - var _t1729 int64 + var _t1727 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1729 = 9 + _t1727 = 9 } else { - var _t1730 int64 + var _t1728 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1730 = 4 + _t1728 = 4 } else { - var _t1731 int64 + var _t1729 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1731 = 5 + _t1729 = 5 } else { - var _t1732 int64 + var _t1730 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1732 = 6 + _t1730 = 6 } else { - var _t1733 int64 + var _t1731 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1733 = 10 + _t1731 = 10 } else { - _t1733 = -1 + _t1731 = -1 } - _t1732 = _t1733 + _t1730 = _t1731 } - _t1731 = _t1732 + _t1729 = _t1730 } - _t1730 = _t1731 + _t1728 = _t1729 } - _t1729 = _t1730 + _t1727 = _t1728 } - _t1728 = _t1729 + _t1726 = _t1727 } - _t1727 = _t1728 + _t1725 = _t1726 } - _t1726 = _t1727 + _t1724 = _t1725 } - _t1725 = _t1726 + _t1723 = _t1724 } - _t1722 = _t1725 + _t1720 = _t1723 } - _t1721 = _t1722 + _t1719 = _t1720 } - _t1720 = _t1721 + _t1718 = _t1719 } - _t1719 = _t1720 - } - prediction915 := _t1719 - var _t1734 *pb.Value - if prediction915 == 12 { - _t1735 := p.parse_boolean_value() - boolean_value927 := _t1735 - _t1736 := &pb.Value{} - _t1736.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value927} - _t1734 = _t1736 + _t1717 = _t1718 + } + prediction914 := _t1717 + var _t1732 *pb.Value + if prediction914 == 12 { + _t1733 := p.parse_boolean_value() + boolean_value926 := _t1733 + _t1734 := &pb.Value{} + _t1734.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value926} + _t1732 = _t1734 } else { - var _t1737 *pb.Value - if prediction915 == 11 { + var _t1735 *pb.Value + if prediction914 == 11 { p.consumeLiteral("missing") - _t1738 := &pb.MissingValue{} - _t1739 := &pb.Value{} - _t1739.Value = &pb.Value_MissingValue{MissingValue: _t1738} - _t1737 = _t1739 + _t1736 := &pb.MissingValue{} + _t1737 := &pb.Value{} + _t1737.Value = &pb.Value_MissingValue{MissingValue: _t1736} + _t1735 = _t1737 } else { - var _t1740 *pb.Value - if prediction915 == 10 { - formatted_decimal926 := p.consumeTerminal("DECIMAL").Value.decimal - _t1741 := &pb.Value{} - _t1741.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal926} - _t1740 = _t1741 + var _t1738 *pb.Value + if prediction914 == 10 { + formatted_decimal925 := p.consumeTerminal("DECIMAL").Value.decimal + _t1739 := &pb.Value{} + _t1739.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal925} + _t1738 = _t1739 } else { - var _t1742 *pb.Value - if prediction915 == 9 { - formatted_int128925 := p.consumeTerminal("INT128").Value.int128 - _t1743 := &pb.Value{} - _t1743.Value = &pb.Value_Int128Value{Int128Value: formatted_int128925} - _t1742 = _t1743 + var _t1740 *pb.Value + if prediction914 == 9 { + formatted_int128924 := p.consumeTerminal("INT128").Value.int128 + _t1741 := &pb.Value{} + _t1741.Value = &pb.Value_Int128Value{Int128Value: formatted_int128924} + _t1740 = _t1741 } else { - var _t1744 *pb.Value - if prediction915 == 8 { - formatted_uint128924 := p.consumeTerminal("UINT128").Value.uint128 - _t1745 := &pb.Value{} - _t1745.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128924} - _t1744 = _t1745 + var _t1742 *pb.Value + if prediction914 == 8 { + formatted_uint128923 := p.consumeTerminal("UINT128").Value.uint128 + _t1743 := &pb.Value{} + _t1743.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128923} + _t1742 = _t1743 } else { - var _t1746 *pb.Value - if prediction915 == 7 { - formatted_uint32923 := p.consumeTerminal("UINT32").Value.u32 - _t1747 := &pb.Value{} - _t1747.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32923} - _t1746 = _t1747 + var _t1744 *pb.Value + if prediction914 == 7 { + formatted_uint32922 := p.consumeTerminal("UINT32").Value.u32 + _t1745 := &pb.Value{} + _t1745.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32922} + _t1744 = _t1745 } else { - var _t1748 *pb.Value - if prediction915 == 6 { - formatted_float922 := p.consumeTerminal("FLOAT").Value.f64 - _t1749 := &pb.Value{} - _t1749.Value = &pb.Value_FloatValue{FloatValue: formatted_float922} - _t1748 = _t1749 + var _t1746 *pb.Value + if prediction914 == 6 { + formatted_float921 := p.consumeTerminal("FLOAT").Value.f64 + _t1747 := &pb.Value{} + _t1747.Value = &pb.Value_FloatValue{FloatValue: formatted_float921} + _t1746 = _t1747 } else { - var _t1750 *pb.Value - if prediction915 == 5 { - formatted_float32921 := p.consumeTerminal("FLOAT32").Value.f32 - _t1751 := &pb.Value{} - _t1751.Value = &pb.Value_Float32Value{Float32Value: formatted_float32921} - _t1750 = _t1751 + var _t1748 *pb.Value + if prediction914 == 5 { + formatted_float32920 := p.consumeTerminal("FLOAT32").Value.f32 + _t1749 := &pb.Value{} + _t1749.Value = &pb.Value_Float32Value{Float32Value: formatted_float32920} + _t1748 = _t1749 } else { - var _t1752 *pb.Value - if prediction915 == 4 { - formatted_int920 := p.consumeTerminal("INT").Value.i64 - _t1753 := &pb.Value{} - _t1753.Value = &pb.Value_IntValue{IntValue: formatted_int920} - _t1752 = _t1753 + var _t1750 *pb.Value + if prediction914 == 4 { + formatted_int919 := p.consumeTerminal("INT").Value.i64 + _t1751 := &pb.Value{} + _t1751.Value = &pb.Value_IntValue{IntValue: formatted_int919} + _t1750 = _t1751 } else { - var _t1754 *pb.Value - if prediction915 == 3 { - formatted_int32919 := p.consumeTerminal("INT32").Value.i32 - _t1755 := &pb.Value{} - _t1755.Value = &pb.Value_Int32Value{Int32Value: formatted_int32919} - _t1754 = _t1755 + var _t1752 *pb.Value + if prediction914 == 3 { + formatted_int32918 := p.consumeTerminal("INT32").Value.i32 + _t1753 := &pb.Value{} + _t1753.Value = &pb.Value_Int32Value{Int32Value: formatted_int32918} + _t1752 = _t1753 } else { - var _t1756 *pb.Value - if prediction915 == 2 { - formatted_string918 := p.consumeTerminal("STRING").Value.str - _t1757 := &pb.Value{} - _t1757.Value = &pb.Value_StringValue{StringValue: formatted_string918} - _t1756 = _t1757 + var _t1754 *pb.Value + if prediction914 == 2 { + formatted_string917 := p.consumeTerminal("STRING").Value.str + _t1755 := &pb.Value{} + _t1755.Value = &pb.Value_StringValue{StringValue: formatted_string917} + _t1754 = _t1755 } else { - var _t1758 *pb.Value - if prediction915 == 1 { - _t1759 := p.parse_datetime() - datetime917 := _t1759 - _t1760 := &pb.Value{} - _t1760.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime917} - _t1758 = _t1760 + var _t1756 *pb.Value + if prediction914 == 1 { + _t1757 := p.parse_datetime() + datetime916 := _t1757 + _t1758 := &pb.Value{} + _t1758.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime916} + _t1756 = _t1758 } else { - var _t1761 *pb.Value - if prediction915 == 0 { - _t1762 := p.parse_date() - date916 := _t1762 - _t1763 := &pb.Value{} - _t1763.Value = &pb.Value_DateValue{DateValue: date916} - _t1761 = _t1763 + var _t1759 *pb.Value + if prediction914 == 0 { + _t1760 := p.parse_date() + date915 := _t1760 + _t1761 := &pb.Value{} + _t1761.Value = &pb.Value_DateValue{DateValue: date915} + _t1759 = _t1761 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1758 = _t1761 + _t1756 = _t1759 } - _t1756 = _t1758 + _t1754 = _t1756 } - _t1754 = _t1756 + _t1752 = _t1754 } - _t1752 = _t1754 + _t1750 = _t1752 } - _t1750 = _t1752 + _t1748 = _t1750 } - _t1748 = _t1750 + _t1746 = _t1748 } - _t1746 = _t1748 + _t1744 = _t1746 } - _t1744 = _t1746 + _t1742 = _t1744 } - _t1742 = _t1744 + _t1740 = _t1742 } - _t1740 = _t1742 + _t1738 = _t1740 } - _t1737 = _t1740 + _t1735 = _t1738 } - _t1734 = _t1737 + _t1732 = _t1735 } - result929 := _t1734 - p.recordSpan(int(span_start928), "Value") - return result929 + result928 := _t1732 + p.recordSpan(int(span_start927), "Value") + return result928 } func (p *Parser) parse_date() *pb.DateValue { - span_start933 := int64(p.spanStart()) + span_start932 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - formatted_int930 := p.consumeTerminal("INT").Value.i64 - formatted_int_3931 := p.consumeTerminal("INT").Value.i64 - formatted_int_4932 := p.consumeTerminal("INT").Value.i64 + formatted_int929 := p.consumeTerminal("INT").Value.i64 + formatted_int_3930 := p.consumeTerminal("INT").Value.i64 + formatted_int_4931 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1764 := &pb.DateValue{Year: int32(formatted_int930), Month: int32(formatted_int_3931), Day: int32(formatted_int_4932)} - result934 := _t1764 - p.recordSpan(int(span_start933), "DateValue") - return result934 + _t1762 := &pb.DateValue{Year: int32(formatted_int929), Month: int32(formatted_int_3930), Day: int32(formatted_int_4931)} + result933 := _t1762 + p.recordSpan(int(span_start932), "DateValue") + return result933 } func (p *Parser) parse_datetime() *pb.DateTimeValue { - span_start942 := int64(p.spanStart()) + span_start941 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - formatted_int935 := p.consumeTerminal("INT").Value.i64 - formatted_int_3936 := p.consumeTerminal("INT").Value.i64 - formatted_int_4937 := p.consumeTerminal("INT").Value.i64 - formatted_int_5938 := p.consumeTerminal("INT").Value.i64 - formatted_int_6939 := p.consumeTerminal("INT").Value.i64 - formatted_int_7940 := p.consumeTerminal("INT").Value.i64 - var _t1765 *int64 + formatted_int934 := p.consumeTerminal("INT").Value.i64 + formatted_int_3935 := p.consumeTerminal("INT").Value.i64 + formatted_int_4936 := p.consumeTerminal("INT").Value.i64 + formatted_int_5937 := p.consumeTerminal("INT").Value.i64 + formatted_int_6938 := p.consumeTerminal("INT").Value.i64 + formatted_int_7939 := p.consumeTerminal("INT").Value.i64 + var _t1763 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1765 = ptr(p.consumeTerminal("INT").Value.i64) + _t1763 = ptr(p.consumeTerminal("INT").Value.i64) } - formatted_int_8941 := _t1765 + formatted_int_8940 := _t1763 p.consumeLiteral(")") - _t1766 := &pb.DateTimeValue{Year: int32(formatted_int935), Month: int32(formatted_int_3936), Day: int32(formatted_int_4937), Hour: int32(formatted_int_5938), Minute: int32(formatted_int_6939), Second: int32(formatted_int_7940), Microsecond: int32(deref(formatted_int_8941, 0))} - result943 := _t1766 - p.recordSpan(int(span_start942), "DateTimeValue") - return result943 + _t1764 := &pb.DateTimeValue{Year: int32(formatted_int934), Month: int32(formatted_int_3935), Day: int32(formatted_int_4936), Hour: int32(formatted_int_5937), Minute: int32(formatted_int_6938), Second: int32(formatted_int_7939), Microsecond: int32(deref(formatted_int_8940, 0))} + result942 := _t1764 + p.recordSpan(int(span_start941), "DateTimeValue") + return result942 } func (p *Parser) parse_conjunction() *pb.Conjunction { - span_start948 := int64(p.spanStart()) + span_start947 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("and") - xs944 := []*pb.Formula{} - cond945 := p.matchLookaheadLiteral("(", 0) - for cond945 { - _t1767 := p.parse_formula() - item946 := _t1767 - xs944 = append(xs944, item946) - cond945 = p.matchLookaheadLiteral("(", 0) - } - formulas947 := xs944 + xs943 := []*pb.Formula{} + cond944 := p.matchLookaheadLiteral("(", 0) + for cond944 { + _t1765 := p.parse_formula() + item945 := _t1765 + xs943 = append(xs943, item945) + cond944 = p.matchLookaheadLiteral("(", 0) + } + formulas946 := xs943 p.consumeLiteral(")") - _t1768 := &pb.Conjunction{Args: formulas947} - result949 := _t1768 - p.recordSpan(int(span_start948), "Conjunction") - return result949 + _t1766 := &pb.Conjunction{Args: formulas946} + result948 := _t1766 + p.recordSpan(int(span_start947), "Conjunction") + return result948 } func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start954 := int64(p.spanStart()) + span_start953 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") - xs950 := []*pb.Formula{} - cond951 := p.matchLookaheadLiteral("(", 0) - for cond951 { - _t1769 := p.parse_formula() - item952 := _t1769 - xs950 = append(xs950, item952) - cond951 = p.matchLookaheadLiteral("(", 0) - } - formulas953 := xs950 + xs949 := []*pb.Formula{} + cond950 := p.matchLookaheadLiteral("(", 0) + for cond950 { + _t1767 := p.parse_formula() + item951 := _t1767 + xs949 = append(xs949, item951) + cond950 = p.matchLookaheadLiteral("(", 0) + } + formulas952 := xs949 p.consumeLiteral(")") - _t1770 := &pb.Disjunction{Args: formulas953} - result955 := _t1770 - p.recordSpan(int(span_start954), "Disjunction") - return result955 + _t1768 := &pb.Disjunction{Args: formulas952} + result954 := _t1768 + p.recordSpan(int(span_start953), "Disjunction") + return result954 } func (p *Parser) parse_not() *pb.Not { - span_start957 := int64(p.spanStart()) + span_start956 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("not") - _t1771 := p.parse_formula() - formula956 := _t1771 + _t1769 := p.parse_formula() + formula955 := _t1769 p.consumeLiteral(")") - _t1772 := &pb.Not{Arg: formula956} - result958 := _t1772 - p.recordSpan(int(span_start957), "Not") - return result958 + _t1770 := &pb.Not{Arg: formula955} + result957 := _t1770 + p.recordSpan(int(span_start956), "Not") + return result957 } func (p *Parser) parse_ffi() *pb.FFI { - span_start962 := int64(p.spanStart()) + span_start961 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("ffi") - _t1773 := p.parse_name() - name959 := _t1773 - _t1774 := p.parse_ffi_args() - ffi_args960 := _t1774 - _t1775 := p.parse_terms() - terms961 := _t1775 + _t1771 := p.parse_name() + name958 := _t1771 + _t1772 := p.parse_ffi_args() + ffi_args959 := _t1772 + _t1773 := p.parse_terms() + terms960 := _t1773 p.consumeLiteral(")") - _t1776 := &pb.FFI{Name: name959, Args: ffi_args960, Terms: terms961} - result963 := _t1776 - p.recordSpan(int(span_start962), "FFI") - return result963 + _t1774 := &pb.FFI{Name: name958, Args: ffi_args959, Terms: terms960} + result962 := _t1774 + p.recordSpan(int(span_start961), "FFI") + return result962 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol964 := p.consumeTerminal("SYMBOL").Value.str - return symbol964 + symbol963 := p.consumeTerminal("SYMBOL").Value.str + return symbol963 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs965 := []*pb.Abstraction{} - cond966 := p.matchLookaheadLiteral("(", 0) - for cond966 { - _t1777 := p.parse_abstraction() - item967 := _t1777 - xs965 = append(xs965, item967) - cond966 = p.matchLookaheadLiteral("(", 0) - } - abstractions968 := xs965 + xs964 := []*pb.Abstraction{} + cond965 := p.matchLookaheadLiteral("(", 0) + for cond965 { + _t1775 := p.parse_abstraction() + item966 := _t1775 + xs964 = append(xs964, item966) + cond965 = p.matchLookaheadLiteral("(", 0) + } + abstractions967 := xs964 p.consumeLiteral(")") - return abstractions968 + return abstractions967 } func (p *Parser) parse_atom() *pb.Atom { - span_start974 := int64(p.spanStart()) + span_start973 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("atom") - _t1778 := p.parse_relation_id() - relation_id969 := _t1778 - xs970 := []*pb.Term{} - cond971 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond971 { - _t1779 := p.parse_term() - item972 := _t1779 - xs970 = append(xs970, item972) - cond971 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - terms973 := xs970 + _t1776 := p.parse_relation_id() + relation_id968 := _t1776 + xs969 := []*pb.Term{} + cond970 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond970 { + _t1777 := p.parse_term() + item971 := _t1777 + xs969 = append(xs969, item971) + cond970 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + } + terms972 := xs969 p.consumeLiteral(")") - _t1780 := &pb.Atom{Name: relation_id969, Terms: terms973} - result975 := _t1780 - p.recordSpan(int(span_start974), "Atom") - return result975 + _t1778 := &pb.Atom{Name: relation_id968, Terms: terms972} + result974 := _t1778 + p.recordSpan(int(span_start973), "Atom") + return result974 } func (p *Parser) parse_pragma() *pb.Pragma { - span_start981 := int64(p.spanStart()) + span_start980 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1781 := p.parse_name() - name976 := _t1781 - xs977 := []*pb.Term{} - cond978 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond978 { - _t1782 := p.parse_term() - item979 := _t1782 - xs977 = append(xs977, item979) - cond978 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - terms980 := xs977 + _t1779 := p.parse_name() + name975 := _t1779 + xs976 := []*pb.Term{} + cond977 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond977 { + _t1780 := p.parse_term() + item978 := _t1780 + xs976 = append(xs976, item978) + cond977 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + } + terms979 := xs976 p.consumeLiteral(")") - _t1783 := &pb.Pragma{Name: name976, Terms: terms980} - result982 := _t1783 - p.recordSpan(int(span_start981), "Pragma") - return result982 + _t1781 := &pb.Pragma{Name: name975, Terms: terms979} + result981 := _t1781 + p.recordSpan(int(span_start980), "Pragma") + return result981 } func (p *Parser) parse_primitive() *pb.Primitive { - span_start998 := int64(p.spanStart()) - var _t1784 int64 + span_start997 := int64(p.spanStart()) + var _t1782 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1785 int64 + var _t1783 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1785 = 9 + _t1783 = 9 } else { - var _t1786 int64 + var _t1784 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1786 = 4 + _t1784 = 4 } else { - var _t1787 int64 + var _t1785 int64 if p.matchLookaheadLiteral(">", 1) { - _t1787 = 3 + _t1785 = 3 } else { - var _t1788 int64 + var _t1786 int64 if p.matchLookaheadLiteral("=", 1) { - _t1788 = 0 + _t1786 = 0 } else { - var _t1789 int64 + var _t1787 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1789 = 2 + _t1787 = 2 } else { - var _t1790 int64 + var _t1788 int64 if p.matchLookaheadLiteral("<", 1) { - _t1790 = 1 + _t1788 = 1 } else { - var _t1791 int64 + var _t1789 int64 if p.matchLookaheadLiteral("/", 1) { - _t1791 = 8 + _t1789 = 8 } else { - var _t1792 int64 + var _t1790 int64 if p.matchLookaheadLiteral("-", 1) { - _t1792 = 6 + _t1790 = 6 } else { - var _t1793 int64 + var _t1791 int64 if p.matchLookaheadLiteral("+", 1) { - _t1793 = 5 + _t1791 = 5 } else { - var _t1794 int64 + var _t1792 int64 if p.matchLookaheadLiteral("*", 1) { - _t1794 = 7 + _t1792 = 7 } else { - _t1794 = -1 + _t1792 = -1 } - _t1793 = _t1794 + _t1791 = _t1792 } - _t1792 = _t1793 + _t1790 = _t1791 } - _t1791 = _t1792 + _t1789 = _t1790 } - _t1790 = _t1791 + _t1788 = _t1789 } - _t1789 = _t1790 + _t1787 = _t1788 } - _t1788 = _t1789 + _t1786 = _t1787 } - _t1787 = _t1788 + _t1785 = _t1786 } - _t1786 = _t1787 + _t1784 = _t1785 } - _t1785 = _t1786 + _t1783 = _t1784 } - _t1784 = _t1785 + _t1782 = _t1783 } else { - _t1784 = -1 + _t1782 = -1 } - prediction983 := _t1784 - var _t1795 *pb.Primitive - if prediction983 == 9 { + prediction982 := _t1782 + var _t1793 *pb.Primitive + if prediction982 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1796 := p.parse_name() - name993 := _t1796 - xs994 := []*pb.RelTerm{} - cond995 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond995 { - _t1797 := p.parse_rel_term() - item996 := _t1797 - xs994 = append(xs994, item996) - cond995 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + _t1794 := p.parse_name() + name992 := _t1794 + xs993 := []*pb.RelTerm{} + cond994 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond994 { + _t1795 := p.parse_rel_term() + item995 := _t1795 + xs993 = append(xs993, item995) + cond994 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) } - rel_terms997 := xs994 + rel_terms996 := xs993 p.consumeLiteral(")") - _t1798 := &pb.Primitive{Name: name993, Terms: rel_terms997} - _t1795 = _t1798 + _t1796 := &pb.Primitive{Name: name992, Terms: rel_terms996} + _t1793 = _t1796 } else { - var _t1799 *pb.Primitive - if prediction983 == 8 { - _t1800 := p.parse_divide() - divide992 := _t1800 - _t1799 = divide992 + var _t1797 *pb.Primitive + if prediction982 == 8 { + _t1798 := p.parse_divide() + divide991 := _t1798 + _t1797 = divide991 } else { - var _t1801 *pb.Primitive - if prediction983 == 7 { - _t1802 := p.parse_multiply() - multiply991 := _t1802 - _t1801 = multiply991 + var _t1799 *pb.Primitive + if prediction982 == 7 { + _t1800 := p.parse_multiply() + multiply990 := _t1800 + _t1799 = multiply990 } else { - var _t1803 *pb.Primitive - if prediction983 == 6 { - _t1804 := p.parse_minus() - minus990 := _t1804 - _t1803 = minus990 + var _t1801 *pb.Primitive + if prediction982 == 6 { + _t1802 := p.parse_minus() + minus989 := _t1802 + _t1801 = minus989 } else { - var _t1805 *pb.Primitive - if prediction983 == 5 { - _t1806 := p.parse_add() - add989 := _t1806 - _t1805 = add989 + var _t1803 *pb.Primitive + if prediction982 == 5 { + _t1804 := p.parse_add() + add988 := _t1804 + _t1803 = add988 } else { - var _t1807 *pb.Primitive - if prediction983 == 4 { - _t1808 := p.parse_gt_eq() - gt_eq988 := _t1808 - _t1807 = gt_eq988 + var _t1805 *pb.Primitive + if prediction982 == 4 { + _t1806 := p.parse_gt_eq() + gt_eq987 := _t1806 + _t1805 = gt_eq987 } else { - var _t1809 *pb.Primitive - if prediction983 == 3 { - _t1810 := p.parse_gt() - gt987 := _t1810 - _t1809 = gt987 + var _t1807 *pb.Primitive + if prediction982 == 3 { + _t1808 := p.parse_gt() + gt986 := _t1808 + _t1807 = gt986 } else { - var _t1811 *pb.Primitive - if prediction983 == 2 { - _t1812 := p.parse_lt_eq() - lt_eq986 := _t1812 - _t1811 = lt_eq986 + var _t1809 *pb.Primitive + if prediction982 == 2 { + _t1810 := p.parse_lt_eq() + lt_eq985 := _t1810 + _t1809 = lt_eq985 } else { - var _t1813 *pb.Primitive - if prediction983 == 1 { - _t1814 := p.parse_lt() - lt985 := _t1814 - _t1813 = lt985 + var _t1811 *pb.Primitive + if prediction982 == 1 { + _t1812 := p.parse_lt() + lt984 := _t1812 + _t1811 = lt984 } else { - var _t1815 *pb.Primitive - if prediction983 == 0 { - _t1816 := p.parse_eq() - eq984 := _t1816 - _t1815 = eq984 + var _t1813 *pb.Primitive + if prediction982 == 0 { + _t1814 := p.parse_eq() + eq983 := _t1814 + _t1813 = eq983 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1813 = _t1815 + _t1811 = _t1813 } - _t1811 = _t1813 + _t1809 = _t1811 } - _t1809 = _t1811 + _t1807 = _t1809 } - _t1807 = _t1809 + _t1805 = _t1807 } - _t1805 = _t1807 + _t1803 = _t1805 } - _t1803 = _t1805 + _t1801 = _t1803 } - _t1801 = _t1803 + _t1799 = _t1801 } - _t1799 = _t1801 + _t1797 = _t1799 } - _t1795 = _t1799 + _t1793 = _t1797 } - result999 := _t1795 - p.recordSpan(int(span_start998), "Primitive") - return result999 + result998 := _t1793 + p.recordSpan(int(span_start997), "Primitive") + return result998 } func (p *Parser) parse_eq() *pb.Primitive { - span_start1002 := int64(p.spanStart()) + span_start1001 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("=") - _t1817 := p.parse_term() - term1000 := _t1817 - _t1818 := p.parse_term() - term_31001 := _t1818 + _t1815 := p.parse_term() + term999 := _t1815 + _t1816 := p.parse_term() + term_31000 := _t1816 p.consumeLiteral(")") - _t1819 := &pb.RelTerm{} - _t1819.RelTermType = &pb.RelTerm_Term{Term: term1000} - _t1820 := &pb.RelTerm{} - _t1820.RelTermType = &pb.RelTerm_Term{Term: term_31001} - _t1821 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1819, _t1820}} - result1003 := _t1821 - p.recordSpan(int(span_start1002), "Primitive") - return result1003 + _t1817 := &pb.RelTerm{} + _t1817.RelTermType = &pb.RelTerm_Term{Term: term999} + _t1818 := &pb.RelTerm{} + _t1818.RelTermType = &pb.RelTerm_Term{Term: term_31000} + _t1819 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1817, _t1818}} + result1002 := _t1819 + p.recordSpan(int(span_start1001), "Primitive") + return result1002 } func (p *Parser) parse_lt() *pb.Primitive { - span_start1006 := int64(p.spanStart()) + span_start1005 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<") - _t1822 := p.parse_term() - term1004 := _t1822 - _t1823 := p.parse_term() - term_31005 := _t1823 + _t1820 := p.parse_term() + term1003 := _t1820 + _t1821 := p.parse_term() + term_31004 := _t1821 p.consumeLiteral(")") - _t1824 := &pb.RelTerm{} - _t1824.RelTermType = &pb.RelTerm_Term{Term: term1004} - _t1825 := &pb.RelTerm{} - _t1825.RelTermType = &pb.RelTerm_Term{Term: term_31005} - _t1826 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1824, _t1825}} - result1007 := _t1826 - p.recordSpan(int(span_start1006), "Primitive") - return result1007 + _t1822 := &pb.RelTerm{} + _t1822.RelTermType = &pb.RelTerm_Term{Term: term1003} + _t1823 := &pb.RelTerm{} + _t1823.RelTermType = &pb.RelTerm_Term{Term: term_31004} + _t1824 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1822, _t1823}} + result1006 := _t1824 + p.recordSpan(int(span_start1005), "Primitive") + return result1006 } func (p *Parser) parse_lt_eq() *pb.Primitive { - span_start1010 := int64(p.spanStart()) + span_start1009 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("<=") - _t1827 := p.parse_term() - term1008 := _t1827 - _t1828 := p.parse_term() - term_31009 := _t1828 + _t1825 := p.parse_term() + term1007 := _t1825 + _t1826 := p.parse_term() + term_31008 := _t1826 p.consumeLiteral(")") - _t1829 := &pb.RelTerm{} - _t1829.RelTermType = &pb.RelTerm_Term{Term: term1008} - _t1830 := &pb.RelTerm{} - _t1830.RelTermType = &pb.RelTerm_Term{Term: term_31009} - _t1831 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1829, _t1830}} - result1011 := _t1831 - p.recordSpan(int(span_start1010), "Primitive") - return result1011 + _t1827 := &pb.RelTerm{} + _t1827.RelTermType = &pb.RelTerm_Term{Term: term1007} + _t1828 := &pb.RelTerm{} + _t1828.RelTermType = &pb.RelTerm_Term{Term: term_31008} + _t1829 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1827, _t1828}} + result1010 := _t1829 + p.recordSpan(int(span_start1009), "Primitive") + return result1010 } func (p *Parser) parse_gt() *pb.Primitive { - span_start1014 := int64(p.spanStart()) + span_start1013 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">") - _t1832 := p.parse_term() - term1012 := _t1832 - _t1833 := p.parse_term() - term_31013 := _t1833 + _t1830 := p.parse_term() + term1011 := _t1830 + _t1831 := p.parse_term() + term_31012 := _t1831 p.consumeLiteral(")") - _t1834 := &pb.RelTerm{} - _t1834.RelTermType = &pb.RelTerm_Term{Term: term1012} - _t1835 := &pb.RelTerm{} - _t1835.RelTermType = &pb.RelTerm_Term{Term: term_31013} - _t1836 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1834, _t1835}} - result1015 := _t1836 - p.recordSpan(int(span_start1014), "Primitive") - return result1015 + _t1832 := &pb.RelTerm{} + _t1832.RelTermType = &pb.RelTerm_Term{Term: term1011} + _t1833 := &pb.RelTerm{} + _t1833.RelTermType = &pb.RelTerm_Term{Term: term_31012} + _t1834 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1832, _t1833}} + result1014 := _t1834 + p.recordSpan(int(span_start1013), "Primitive") + return result1014 } func (p *Parser) parse_gt_eq() *pb.Primitive { - span_start1018 := int64(p.spanStart()) + span_start1017 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral(">=") - _t1837 := p.parse_term() - term1016 := _t1837 - _t1838 := p.parse_term() - term_31017 := _t1838 + _t1835 := p.parse_term() + term1015 := _t1835 + _t1836 := p.parse_term() + term_31016 := _t1836 p.consumeLiteral(")") - _t1839 := &pb.RelTerm{} - _t1839.RelTermType = &pb.RelTerm_Term{Term: term1016} - _t1840 := &pb.RelTerm{} - _t1840.RelTermType = &pb.RelTerm_Term{Term: term_31017} - _t1841 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1839, _t1840}} - result1019 := _t1841 - p.recordSpan(int(span_start1018), "Primitive") - return result1019 + _t1837 := &pb.RelTerm{} + _t1837.RelTermType = &pb.RelTerm_Term{Term: term1015} + _t1838 := &pb.RelTerm{} + _t1838.RelTermType = &pb.RelTerm_Term{Term: term_31016} + _t1839 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1837, _t1838}} + result1018 := _t1839 + p.recordSpan(int(span_start1017), "Primitive") + return result1018 } func (p *Parser) parse_add() *pb.Primitive { - span_start1023 := int64(p.spanStart()) + span_start1022 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("+") + _t1840 := p.parse_term() + term1019 := _t1840 + _t1841 := p.parse_term() + term_31020 := _t1841 _t1842 := p.parse_term() - term1020 := _t1842 - _t1843 := p.parse_term() - term_31021 := _t1843 - _t1844 := p.parse_term() - term_41022 := _t1844 + term_41021 := _t1842 p.consumeLiteral(")") + _t1843 := &pb.RelTerm{} + _t1843.RelTermType = &pb.RelTerm_Term{Term: term1019} + _t1844 := &pb.RelTerm{} + _t1844.RelTermType = &pb.RelTerm_Term{Term: term_31020} _t1845 := &pb.RelTerm{} - _t1845.RelTermType = &pb.RelTerm_Term{Term: term1020} - _t1846 := &pb.RelTerm{} - _t1846.RelTermType = &pb.RelTerm_Term{Term: term_31021} - _t1847 := &pb.RelTerm{} - _t1847.RelTermType = &pb.RelTerm_Term{Term: term_41022} - _t1848 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1845, _t1846, _t1847}} - result1024 := _t1848 - p.recordSpan(int(span_start1023), "Primitive") - return result1024 + _t1845.RelTermType = &pb.RelTerm_Term{Term: term_41021} + _t1846 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1843, _t1844, _t1845}} + result1023 := _t1846 + p.recordSpan(int(span_start1022), "Primitive") + return result1023 } func (p *Parser) parse_minus() *pb.Primitive { - span_start1028 := int64(p.spanStart()) + span_start1027 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("-") + _t1847 := p.parse_term() + term1024 := _t1847 + _t1848 := p.parse_term() + term_31025 := _t1848 _t1849 := p.parse_term() - term1025 := _t1849 - _t1850 := p.parse_term() - term_31026 := _t1850 - _t1851 := p.parse_term() - term_41027 := _t1851 + term_41026 := _t1849 p.consumeLiteral(")") + _t1850 := &pb.RelTerm{} + _t1850.RelTermType = &pb.RelTerm_Term{Term: term1024} + _t1851 := &pb.RelTerm{} + _t1851.RelTermType = &pb.RelTerm_Term{Term: term_31025} _t1852 := &pb.RelTerm{} - _t1852.RelTermType = &pb.RelTerm_Term{Term: term1025} - _t1853 := &pb.RelTerm{} - _t1853.RelTermType = &pb.RelTerm_Term{Term: term_31026} - _t1854 := &pb.RelTerm{} - _t1854.RelTermType = &pb.RelTerm_Term{Term: term_41027} - _t1855 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1852, _t1853, _t1854}} - result1029 := _t1855 - p.recordSpan(int(span_start1028), "Primitive") - return result1029 + _t1852.RelTermType = &pb.RelTerm_Term{Term: term_41026} + _t1853 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1850, _t1851, _t1852}} + result1028 := _t1853 + p.recordSpan(int(span_start1027), "Primitive") + return result1028 } func (p *Parser) parse_multiply() *pb.Primitive { - span_start1033 := int64(p.spanStart()) + span_start1032 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("*") + _t1854 := p.parse_term() + term1029 := _t1854 + _t1855 := p.parse_term() + term_31030 := _t1855 _t1856 := p.parse_term() - term1030 := _t1856 - _t1857 := p.parse_term() - term_31031 := _t1857 - _t1858 := p.parse_term() - term_41032 := _t1858 + term_41031 := _t1856 p.consumeLiteral(")") + _t1857 := &pb.RelTerm{} + _t1857.RelTermType = &pb.RelTerm_Term{Term: term1029} + _t1858 := &pb.RelTerm{} + _t1858.RelTermType = &pb.RelTerm_Term{Term: term_31030} _t1859 := &pb.RelTerm{} - _t1859.RelTermType = &pb.RelTerm_Term{Term: term1030} - _t1860 := &pb.RelTerm{} - _t1860.RelTermType = &pb.RelTerm_Term{Term: term_31031} - _t1861 := &pb.RelTerm{} - _t1861.RelTermType = &pb.RelTerm_Term{Term: term_41032} - _t1862 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1859, _t1860, _t1861}} - result1034 := _t1862 - p.recordSpan(int(span_start1033), "Primitive") - return result1034 + _t1859.RelTermType = &pb.RelTerm_Term{Term: term_41031} + _t1860 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1857, _t1858, _t1859}} + result1033 := _t1860 + p.recordSpan(int(span_start1032), "Primitive") + return result1033 } func (p *Parser) parse_divide() *pb.Primitive { - span_start1038 := int64(p.spanStart()) + span_start1037 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("/") + _t1861 := p.parse_term() + term1034 := _t1861 + _t1862 := p.parse_term() + term_31035 := _t1862 _t1863 := p.parse_term() - term1035 := _t1863 - _t1864 := p.parse_term() - term_31036 := _t1864 - _t1865 := p.parse_term() - term_41037 := _t1865 + term_41036 := _t1863 p.consumeLiteral(")") + _t1864 := &pb.RelTerm{} + _t1864.RelTermType = &pb.RelTerm_Term{Term: term1034} + _t1865 := &pb.RelTerm{} + _t1865.RelTermType = &pb.RelTerm_Term{Term: term_31035} _t1866 := &pb.RelTerm{} - _t1866.RelTermType = &pb.RelTerm_Term{Term: term1035} - _t1867 := &pb.RelTerm{} - _t1867.RelTermType = &pb.RelTerm_Term{Term: term_31036} - _t1868 := &pb.RelTerm{} - _t1868.RelTermType = &pb.RelTerm_Term{Term: term_41037} - _t1869 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1866, _t1867, _t1868}} - result1039 := _t1869 - p.recordSpan(int(span_start1038), "Primitive") - return result1039 + _t1866.RelTermType = &pb.RelTerm_Term{Term: term_41036} + _t1867 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1864, _t1865, _t1866}} + result1038 := _t1867 + p.recordSpan(int(span_start1037), "Primitive") + return result1038 } func (p *Parser) parse_rel_term() *pb.RelTerm { - span_start1043 := int64(p.spanStart()) - var _t1870 int64 + span_start1042 := int64(p.spanStart()) + var _t1868 int64 if p.matchLookaheadLiteral("true", 0) { - _t1870 = 1 + _t1868 = 1 } else { - var _t1871 int64 + var _t1869 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1871 = 1 + _t1869 = 1 } else { - var _t1872 int64 + var _t1870 int64 if p.matchLookaheadLiteral("false", 0) { - _t1872 = 1 + _t1870 = 1 } else { - var _t1873 int64 + var _t1871 int64 if p.matchLookaheadLiteral("(", 0) { - _t1873 = 1 + _t1871 = 1 } else { - var _t1874 int64 + var _t1872 int64 if p.matchLookaheadLiteral("#", 0) { - _t1874 = 0 + _t1872 = 0 } else { - var _t1875 int64 + var _t1873 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1875 = 1 + _t1873 = 1 } else { - var _t1876 int64 + var _t1874 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1876 = 1 + _t1874 = 1 } else { - var _t1877 int64 + var _t1875 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1877 = 1 + _t1875 = 1 } else { - var _t1878 int64 + var _t1876 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1878 = 1 + _t1876 = 1 } else { - var _t1879 int64 + var _t1877 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1879 = 1 + _t1877 = 1 } else { - var _t1880 int64 + var _t1878 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1880 = 1 + _t1878 = 1 } else { - var _t1881 int64 + var _t1879 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1881 = 1 + _t1879 = 1 } else { - var _t1882 int64 + var _t1880 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1882 = 1 + _t1880 = 1 } else { - var _t1883 int64 + var _t1881 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1883 = 1 + _t1881 = 1 } else { - var _t1884 int64 + var _t1882 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1884 = 1 + _t1882 = 1 } else { - _t1884 = -1 + _t1882 = -1 } - _t1883 = _t1884 + _t1881 = _t1882 } - _t1882 = _t1883 + _t1880 = _t1881 } - _t1881 = _t1882 + _t1879 = _t1880 } - _t1880 = _t1881 + _t1878 = _t1879 } - _t1879 = _t1880 + _t1877 = _t1878 } - _t1878 = _t1879 + _t1876 = _t1877 } - _t1877 = _t1878 + _t1875 = _t1876 } - _t1876 = _t1877 + _t1874 = _t1875 } - _t1875 = _t1876 + _t1873 = _t1874 } - _t1874 = _t1875 + _t1872 = _t1873 } - _t1873 = _t1874 + _t1871 = _t1872 } - _t1872 = _t1873 + _t1870 = _t1871 } - _t1871 = _t1872 + _t1869 = _t1870 } - _t1870 = _t1871 - } - prediction1040 := _t1870 - var _t1885 *pb.RelTerm - if prediction1040 == 1 { - _t1886 := p.parse_term() - term1042 := _t1886 - _t1887 := &pb.RelTerm{} - _t1887.RelTermType = &pb.RelTerm_Term{Term: term1042} - _t1885 = _t1887 + _t1868 = _t1869 + } + prediction1039 := _t1868 + var _t1883 *pb.RelTerm + if prediction1039 == 1 { + _t1884 := p.parse_term() + term1041 := _t1884 + _t1885 := &pb.RelTerm{} + _t1885.RelTermType = &pb.RelTerm_Term{Term: term1041} + _t1883 = _t1885 } else { - var _t1888 *pb.RelTerm - if prediction1040 == 0 { - _t1889 := p.parse_specialized_value() - specialized_value1041 := _t1889 - _t1890 := &pb.RelTerm{} - _t1890.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1041} - _t1888 = _t1890 + var _t1886 *pb.RelTerm + if prediction1039 == 0 { + _t1887 := p.parse_specialized_value() + specialized_value1040 := _t1887 + _t1888 := &pb.RelTerm{} + _t1888.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1040} + _t1886 = _t1888 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1885 = _t1888 + _t1883 = _t1886 } - result1044 := _t1885 - p.recordSpan(int(span_start1043), "RelTerm") - return result1044 + result1043 := _t1883 + p.recordSpan(int(span_start1042), "RelTerm") + return result1043 } func (p *Parser) parse_specialized_value() *pb.Value { - span_start1046 := int64(p.spanStart()) + span_start1045 := int64(p.spanStart()) p.consumeLiteral("#") - _t1891 := p.parse_raw_value() - raw_value1045 := _t1891 - result1047 := raw_value1045 - p.recordSpan(int(span_start1046), "Value") - return result1047 + _t1889 := p.parse_raw_value() + raw_value1044 := _t1889 + result1046 := raw_value1044 + p.recordSpan(int(span_start1045), "Value") + return result1046 } func (p *Parser) parse_rel_atom() *pb.RelAtom { - span_start1053 := int64(p.spanStart()) + span_start1052 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1892 := p.parse_name() - name1048 := _t1892 - xs1049 := []*pb.RelTerm{} - cond1050 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - for cond1050 { - _t1893 := p.parse_rel_term() - item1051 := _t1893 - xs1049 = append(xs1049, item1051) - cond1050 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) - } - rel_terms1052 := xs1049 + _t1890 := p.parse_name() + name1047 := _t1890 + xs1048 := []*pb.RelTerm{} + cond1049 := ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + for cond1049 { + _t1891 := p.parse_rel_term() + item1050 := _t1891 + xs1048 = append(xs1048, item1050) + cond1049 = ((((((((((((((p.matchLookaheadLiteral("#", 0) || p.matchLookaheadLiteral("(", 0)) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) || p.matchLookaheadTerminal("SYMBOL", 0)) + } + rel_terms1051 := xs1048 p.consumeLiteral(")") - _t1894 := &pb.RelAtom{Name: name1048, Terms: rel_terms1052} - result1054 := _t1894 - p.recordSpan(int(span_start1053), "RelAtom") - return result1054 + _t1892 := &pb.RelAtom{Name: name1047, Terms: rel_terms1051} + result1053 := _t1892 + p.recordSpan(int(span_start1052), "RelAtom") + return result1053 } func (p *Parser) parse_cast() *pb.Cast { - span_start1057 := int64(p.spanStart()) + span_start1056 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("cast") - _t1895 := p.parse_term() - term1055 := _t1895 - _t1896 := p.parse_term() - term_31056 := _t1896 + _t1893 := p.parse_term() + term1054 := _t1893 + _t1894 := p.parse_term() + term_31055 := _t1894 p.consumeLiteral(")") - _t1897 := &pb.Cast{Input: term1055, Result: term_31056} - result1058 := _t1897 - p.recordSpan(int(span_start1057), "Cast") - return result1058 + _t1895 := &pb.Cast{Input: term1054, Result: term_31055} + result1057 := _t1895 + p.recordSpan(int(span_start1056), "Cast") + return result1057 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs1059 := []*pb.Attribute{} - cond1060 := p.matchLookaheadLiteral("(", 0) - for cond1060 { - _t1898 := p.parse_attribute() - item1061 := _t1898 - xs1059 = append(xs1059, item1061) - cond1060 = p.matchLookaheadLiteral("(", 0) - } - attributes1062 := xs1059 + xs1058 := []*pb.Attribute{} + cond1059 := p.matchLookaheadLiteral("(", 0) + for cond1059 { + _t1896 := p.parse_attribute() + item1060 := _t1896 + xs1058 = append(xs1058, item1060) + cond1059 = p.matchLookaheadLiteral("(", 0) + } + attributes1061 := xs1058 p.consumeLiteral(")") - return attributes1062 + return attributes1061 } func (p *Parser) parse_attribute() *pb.Attribute { - span_start1068 := int64(p.spanStart()) + span_start1067 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1899 := p.parse_name() - name1063 := _t1899 - xs1064 := []*pb.Value{} - cond1065 := ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) - for cond1065 { - _t1900 := p.parse_raw_value() - item1066 := _t1900 - xs1064 = append(xs1064, item1066) - cond1065 = ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) - } - raw_values1067 := xs1064 + _t1897 := p.parse_name() + name1062 := _t1897 + xs1063 := []*pb.Value{} + cond1064 := ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) + for cond1064 { + _t1898 := p.parse_raw_value() + item1065 := _t1898 + xs1063 = append(xs1063, item1065) + cond1064 = ((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("false", 0)) || p.matchLookaheadLiteral("missing", 0)) || p.matchLookaheadLiteral("true", 0)) || p.matchLookaheadTerminal("DECIMAL", 0)) || p.matchLookaheadTerminal("FLOAT", 0)) || p.matchLookaheadTerminal("FLOAT32", 0)) || p.matchLookaheadTerminal("INT", 0)) || p.matchLookaheadTerminal("INT128", 0)) || p.matchLookaheadTerminal("INT32", 0)) || p.matchLookaheadTerminal("STRING", 0)) || p.matchLookaheadTerminal("UINT128", 0)) || p.matchLookaheadTerminal("UINT32", 0)) + } + raw_values1066 := xs1063 p.consumeLiteral(")") - _t1901 := &pb.Attribute{Name: name1063, Args: raw_values1067} - result1069 := _t1901 - p.recordSpan(int(span_start1068), "Attribute") - return result1069 + _t1899 := &pb.Attribute{Name: name1062, Args: raw_values1066} + result1068 := _t1899 + p.recordSpan(int(span_start1067), "Attribute") + return result1068 } func (p *Parser) parse_algorithm() *pb.Algorithm { - span_start1076 := int64(p.spanStart()) + span_start1075 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs1070 := []*pb.RelationId{} - cond1071 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1071 { - _t1902 := p.parse_relation_id() - item1072 := _t1902 - xs1070 = append(xs1070, item1072) - cond1071 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1073 := xs1070 - _t1903 := p.parse_script() - script1074 := _t1903 - var _t1904 []*pb.Attribute + xs1069 := []*pb.RelationId{} + cond1070 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1070 { + _t1900 := p.parse_relation_id() + item1071 := _t1900 + xs1069 = append(xs1069, item1071) + cond1070 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1072 := xs1069 + _t1901 := p.parse_script() + script1073 := _t1901 + var _t1902 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1905 := p.parse_attrs() - _t1904 = _t1905 + _t1903 := p.parse_attrs() + _t1902 = _t1903 } - attrs1075 := _t1904 + attrs1074 := _t1902 p.consumeLiteral(")") - _t1906 := attrs1075 - if attrs1075 == nil { - _t1906 = []*pb.Attribute{} + _t1904 := attrs1074 + if attrs1074 == nil { + _t1904 = []*pb.Attribute{} } - _t1907 := &pb.Algorithm{Global: relation_ids1073, Body: script1074, Attrs: _t1906} - result1077 := _t1907 - p.recordSpan(int(span_start1076), "Algorithm") - return result1077 + _t1905 := &pb.Algorithm{Global: relation_ids1072, Body: script1073, Attrs: _t1904} + result1076 := _t1905 + p.recordSpan(int(span_start1075), "Algorithm") + return result1076 } func (p *Parser) parse_script() *pb.Script { - span_start1082 := int64(p.spanStart()) + span_start1081 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("script") - xs1078 := []*pb.Construct{} - cond1079 := p.matchLookaheadLiteral("(", 0) - for cond1079 { - _t1908 := p.parse_construct() - item1080 := _t1908 - xs1078 = append(xs1078, item1080) - cond1079 = p.matchLookaheadLiteral("(", 0) - } - constructs1081 := xs1078 + xs1077 := []*pb.Construct{} + cond1078 := p.matchLookaheadLiteral("(", 0) + for cond1078 { + _t1906 := p.parse_construct() + item1079 := _t1906 + xs1077 = append(xs1077, item1079) + cond1078 = p.matchLookaheadLiteral("(", 0) + } + constructs1080 := xs1077 p.consumeLiteral(")") - _t1909 := &pb.Script{Constructs: constructs1081} - result1083 := _t1909 - p.recordSpan(int(span_start1082), "Script") - return result1083 + _t1907 := &pb.Script{Constructs: constructs1080} + result1082 := _t1907 + p.recordSpan(int(span_start1081), "Script") + return result1082 } func (p *Parser) parse_construct() *pb.Construct { - span_start1087 := int64(p.spanStart()) - var _t1910 int64 + span_start1086 := int64(p.spanStart()) + var _t1908 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1911 int64 + var _t1909 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1911 = 1 + _t1909 = 1 } else { - var _t1912 int64 + var _t1910 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1912 = 1 + _t1910 = 1 } else { - var _t1913 int64 + var _t1911 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1913 = 1 + _t1911 = 1 } else { - var _t1914 int64 + var _t1912 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1914 = 0 + _t1912 = 0 } else { - var _t1915 int64 + var _t1913 int64 if p.matchLookaheadLiteral("break", 1) { - _t1915 = 1 + _t1913 = 1 } else { - var _t1916 int64 + var _t1914 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1916 = 1 + _t1914 = 1 } else { - _t1916 = -1 + _t1914 = -1 } - _t1915 = _t1916 + _t1913 = _t1914 } - _t1914 = _t1915 + _t1912 = _t1913 } - _t1913 = _t1914 + _t1911 = _t1912 } - _t1912 = _t1913 + _t1910 = _t1911 } - _t1911 = _t1912 + _t1909 = _t1910 } - _t1910 = _t1911 + _t1908 = _t1909 } else { - _t1910 = -1 - } - prediction1084 := _t1910 - var _t1917 *pb.Construct - if prediction1084 == 1 { - _t1918 := p.parse_instruction() - instruction1086 := _t1918 - _t1919 := &pb.Construct{} - _t1919.ConstructType = &pb.Construct_Instruction{Instruction: instruction1086} - _t1917 = _t1919 + _t1908 = -1 + } + prediction1083 := _t1908 + var _t1915 *pb.Construct + if prediction1083 == 1 { + _t1916 := p.parse_instruction() + instruction1085 := _t1916 + _t1917 := &pb.Construct{} + _t1917.ConstructType = &pb.Construct_Instruction{Instruction: instruction1085} + _t1915 = _t1917 } else { - var _t1920 *pb.Construct - if prediction1084 == 0 { - _t1921 := p.parse_loop() - loop1085 := _t1921 - _t1922 := &pb.Construct{} - _t1922.ConstructType = &pb.Construct_Loop{Loop: loop1085} - _t1920 = _t1922 + var _t1918 *pb.Construct + if prediction1083 == 0 { + _t1919 := p.parse_loop() + loop1084 := _t1919 + _t1920 := &pb.Construct{} + _t1920.ConstructType = &pb.Construct_Loop{Loop: loop1084} + _t1918 = _t1920 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1917 = _t1920 + _t1915 = _t1918 } - result1088 := _t1917 - p.recordSpan(int(span_start1087), "Construct") - return result1088 + result1087 := _t1915 + p.recordSpan(int(span_start1086), "Construct") + return result1087 } func (p *Parser) parse_loop() *pb.Loop { - span_start1092 := int64(p.spanStart()) + span_start1091 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("loop") - _t1923 := p.parse_init() - init1089 := _t1923 - _t1924 := p.parse_script() - script1090 := _t1924 - var _t1925 []*pb.Attribute + _t1921 := p.parse_init() + init1088 := _t1921 + _t1922 := p.parse_script() + script1089 := _t1922 + var _t1923 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1926 := p.parse_attrs() - _t1925 = _t1926 + _t1924 := p.parse_attrs() + _t1923 = _t1924 } - attrs1091 := _t1925 + attrs1090 := _t1923 p.consumeLiteral(")") - _t1927 := attrs1091 - if attrs1091 == nil { - _t1927 = []*pb.Attribute{} + _t1925 := attrs1090 + if attrs1090 == nil { + _t1925 = []*pb.Attribute{} } - _t1928 := &pb.Loop{Init: init1089, Body: script1090, Attrs: _t1927} - result1093 := _t1928 - p.recordSpan(int(span_start1092), "Loop") - return result1093 + _t1926 := &pb.Loop{Init: init1088, Body: script1089, Attrs: _t1925} + result1092 := _t1926 + p.recordSpan(int(span_start1091), "Loop") + return result1092 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs1094 := []*pb.Instruction{} - cond1095 := p.matchLookaheadLiteral("(", 0) - for cond1095 { - _t1929 := p.parse_instruction() - item1096 := _t1929 - xs1094 = append(xs1094, item1096) - cond1095 = p.matchLookaheadLiteral("(", 0) - } - instructions1097 := xs1094 + xs1093 := []*pb.Instruction{} + cond1094 := p.matchLookaheadLiteral("(", 0) + for cond1094 { + _t1927 := p.parse_instruction() + item1095 := _t1927 + xs1093 = append(xs1093, item1095) + cond1094 = p.matchLookaheadLiteral("(", 0) + } + instructions1096 := xs1093 p.consumeLiteral(")") - return instructions1097 + return instructions1096 } func (p *Parser) parse_instruction() *pb.Instruction { - span_start1104 := int64(p.spanStart()) - var _t1930 int64 + span_start1103 := int64(p.spanStart()) + var _t1928 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1931 int64 + var _t1929 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1931 = 1 + _t1929 = 1 } else { - var _t1932 int64 + var _t1930 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1932 = 4 + _t1930 = 4 } else { - var _t1933 int64 + var _t1931 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1933 = 3 + _t1931 = 3 } else { - var _t1934 int64 + var _t1932 int64 if p.matchLookaheadLiteral("break", 1) { - _t1934 = 2 + _t1932 = 2 } else { - var _t1935 int64 + var _t1933 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1935 = 0 + _t1933 = 0 } else { - _t1935 = -1 + _t1933 = -1 } - _t1934 = _t1935 + _t1932 = _t1933 } - _t1933 = _t1934 + _t1931 = _t1932 } - _t1932 = _t1933 + _t1930 = _t1931 } - _t1931 = _t1932 + _t1929 = _t1930 } - _t1930 = _t1931 + _t1928 = _t1929 } else { - _t1930 = -1 - } - prediction1098 := _t1930 - var _t1936 *pb.Instruction - if prediction1098 == 4 { - _t1937 := p.parse_monus_def() - monus_def1103 := _t1937 - _t1938 := &pb.Instruction{} - _t1938.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1103} - _t1936 = _t1938 + _t1928 = -1 + } + prediction1097 := _t1928 + var _t1934 *pb.Instruction + if prediction1097 == 4 { + _t1935 := p.parse_monus_def() + monus_def1102 := _t1935 + _t1936 := &pb.Instruction{} + _t1936.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1102} + _t1934 = _t1936 } else { - var _t1939 *pb.Instruction - if prediction1098 == 3 { - _t1940 := p.parse_monoid_def() - monoid_def1102 := _t1940 - _t1941 := &pb.Instruction{} - _t1941.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1102} - _t1939 = _t1941 + var _t1937 *pb.Instruction + if prediction1097 == 3 { + _t1938 := p.parse_monoid_def() + monoid_def1101 := _t1938 + _t1939 := &pb.Instruction{} + _t1939.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1101} + _t1937 = _t1939 } else { - var _t1942 *pb.Instruction - if prediction1098 == 2 { - _t1943 := p.parse_break() - break1101 := _t1943 - _t1944 := &pb.Instruction{} - _t1944.InstrType = &pb.Instruction_Break{Break: break1101} - _t1942 = _t1944 + var _t1940 *pb.Instruction + if prediction1097 == 2 { + _t1941 := p.parse_break() + break1100 := _t1941 + _t1942 := &pb.Instruction{} + _t1942.InstrType = &pb.Instruction_Break{Break: break1100} + _t1940 = _t1942 } else { - var _t1945 *pb.Instruction - if prediction1098 == 1 { - _t1946 := p.parse_upsert() - upsert1100 := _t1946 - _t1947 := &pb.Instruction{} - _t1947.InstrType = &pb.Instruction_Upsert{Upsert: upsert1100} - _t1945 = _t1947 + var _t1943 *pb.Instruction + if prediction1097 == 1 { + _t1944 := p.parse_upsert() + upsert1099 := _t1944 + _t1945 := &pb.Instruction{} + _t1945.InstrType = &pb.Instruction_Upsert{Upsert: upsert1099} + _t1943 = _t1945 } else { - var _t1948 *pb.Instruction - if prediction1098 == 0 { - _t1949 := p.parse_assign() - assign1099 := _t1949 - _t1950 := &pb.Instruction{} - _t1950.InstrType = &pb.Instruction_Assign{Assign: assign1099} - _t1948 = _t1950 + var _t1946 *pb.Instruction + if prediction1097 == 0 { + _t1947 := p.parse_assign() + assign1098 := _t1947 + _t1948 := &pb.Instruction{} + _t1948.InstrType = &pb.Instruction_Assign{Assign: assign1098} + _t1946 = _t1948 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1945 = _t1948 + _t1943 = _t1946 } - _t1942 = _t1945 + _t1940 = _t1943 } - _t1939 = _t1942 + _t1937 = _t1940 } - _t1936 = _t1939 + _t1934 = _t1937 } - result1105 := _t1936 - p.recordSpan(int(span_start1104), "Instruction") - return result1105 + result1104 := _t1934 + p.recordSpan(int(span_start1103), "Instruction") + return result1104 } func (p *Parser) parse_assign() *pb.Assign { - span_start1109 := int64(p.spanStart()) + span_start1108 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("assign") - _t1951 := p.parse_relation_id() - relation_id1106 := _t1951 - _t1952 := p.parse_abstraction() - abstraction1107 := _t1952 - var _t1953 []*pb.Attribute + _t1949 := p.parse_relation_id() + relation_id1105 := _t1949 + _t1950 := p.parse_abstraction() + abstraction1106 := _t1950 + var _t1951 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1954 := p.parse_attrs() - _t1953 = _t1954 + _t1952 := p.parse_attrs() + _t1951 = _t1952 } - attrs1108 := _t1953 + attrs1107 := _t1951 p.consumeLiteral(")") - _t1955 := attrs1108 - if attrs1108 == nil { - _t1955 = []*pb.Attribute{} + _t1953 := attrs1107 + if attrs1107 == nil { + _t1953 = []*pb.Attribute{} } - _t1956 := &pb.Assign{Name: relation_id1106, Body: abstraction1107, Attrs: _t1955} - result1110 := _t1956 - p.recordSpan(int(span_start1109), "Assign") - return result1110 + _t1954 := &pb.Assign{Name: relation_id1105, Body: abstraction1106, Attrs: _t1953} + result1109 := _t1954 + p.recordSpan(int(span_start1108), "Assign") + return result1109 } func (p *Parser) parse_upsert() *pb.Upsert { - span_start1114 := int64(p.spanStart()) + span_start1113 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1957 := p.parse_relation_id() - relation_id1111 := _t1957 - _t1958 := p.parse_abstraction_with_arity() - abstraction_with_arity1112 := _t1958 - var _t1959 []*pb.Attribute + _t1955 := p.parse_relation_id() + relation_id1110 := _t1955 + _t1956 := p.parse_abstraction_with_arity() + abstraction_with_arity1111 := _t1956 + var _t1957 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1960 := p.parse_attrs() - _t1959 = _t1960 + _t1958 := p.parse_attrs() + _t1957 = _t1958 } - attrs1113 := _t1959 + attrs1112 := _t1957 p.consumeLiteral(")") - _t1961 := attrs1113 - if attrs1113 == nil { - _t1961 = []*pb.Attribute{} + _t1959 := attrs1112 + if attrs1112 == nil { + _t1959 = []*pb.Attribute{} } - _t1962 := &pb.Upsert{Name: relation_id1111, Body: abstraction_with_arity1112[0].(*pb.Abstraction), Attrs: _t1961, ValueArity: abstraction_with_arity1112[1].(int64)} - result1115 := _t1962 - p.recordSpan(int(span_start1114), "Upsert") - return result1115 + _t1960 := &pb.Upsert{Name: relation_id1110, Body: abstraction_with_arity1111[0].(*pb.Abstraction), Attrs: _t1959, ValueArity: abstraction_with_arity1111[1].(int64)} + result1114 := _t1960 + p.recordSpan(int(span_start1113), "Upsert") + return result1114 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1963 := p.parse_bindings() - bindings1116 := _t1963 - _t1964 := p.parse_formula() - formula1117 := _t1964 + _t1961 := p.parse_bindings() + bindings1115 := _t1961 + _t1962 := p.parse_formula() + formula1116 := _t1962 p.consumeLiteral(")") - _t1965 := &pb.Abstraction{Vars: listConcat(bindings1116[0].([]*pb.Binding), bindings1116[1].([]*pb.Binding)), Value: formula1117} - return []interface{}{_t1965, int64(len(bindings1116[1].([]*pb.Binding)))} + _t1963 := &pb.Abstraction{Vars: listConcat(bindings1115[0].([]*pb.Binding), bindings1115[1].([]*pb.Binding)), Value: formula1116} + return []interface{}{_t1963, int64(len(bindings1115[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { - span_start1121 := int64(p.spanStart()) + span_start1120 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("break") - _t1966 := p.parse_relation_id() - relation_id1118 := _t1966 - _t1967 := p.parse_abstraction() - abstraction1119 := _t1967 - var _t1968 []*pb.Attribute + _t1964 := p.parse_relation_id() + relation_id1117 := _t1964 + _t1965 := p.parse_abstraction() + abstraction1118 := _t1965 + var _t1966 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1969 := p.parse_attrs() - _t1968 = _t1969 + _t1967 := p.parse_attrs() + _t1966 = _t1967 } - attrs1120 := _t1968 + attrs1119 := _t1966 p.consumeLiteral(")") - _t1970 := attrs1120 - if attrs1120 == nil { - _t1970 = []*pb.Attribute{} + _t1968 := attrs1119 + if attrs1119 == nil { + _t1968 = []*pb.Attribute{} } - _t1971 := &pb.Break{Name: relation_id1118, Body: abstraction1119, Attrs: _t1970} - result1122 := _t1971 - p.recordSpan(int(span_start1121), "Break") - return result1122 + _t1969 := &pb.Break{Name: relation_id1117, Body: abstraction1118, Attrs: _t1968} + result1121 := _t1969 + p.recordSpan(int(span_start1120), "Break") + return result1121 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { - span_start1127 := int64(p.spanStart()) + span_start1126 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1972 := p.parse_monoid() - monoid1123 := _t1972 - _t1973 := p.parse_relation_id() - relation_id1124 := _t1973 - _t1974 := p.parse_abstraction_with_arity() - abstraction_with_arity1125 := _t1974 - var _t1975 []*pb.Attribute + _t1970 := p.parse_monoid() + monoid1122 := _t1970 + _t1971 := p.parse_relation_id() + relation_id1123 := _t1971 + _t1972 := p.parse_abstraction_with_arity() + abstraction_with_arity1124 := _t1972 + var _t1973 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1976 := p.parse_attrs() - _t1975 = _t1976 + _t1974 := p.parse_attrs() + _t1973 = _t1974 } - attrs1126 := _t1975 + attrs1125 := _t1973 p.consumeLiteral(")") - _t1977 := attrs1126 - if attrs1126 == nil { - _t1977 = []*pb.Attribute{} + _t1975 := attrs1125 + if attrs1125 == nil { + _t1975 = []*pb.Attribute{} } - _t1978 := &pb.MonoidDef{Monoid: monoid1123, Name: relation_id1124, Body: abstraction_with_arity1125[0].(*pb.Abstraction), Attrs: _t1977, ValueArity: abstraction_with_arity1125[1].(int64)} - result1128 := _t1978 - p.recordSpan(int(span_start1127), "MonoidDef") - return result1128 + _t1976 := &pb.MonoidDef{Monoid: monoid1122, Name: relation_id1123, Body: abstraction_with_arity1124[0].(*pb.Abstraction), Attrs: _t1975, ValueArity: abstraction_with_arity1124[1].(int64)} + result1127 := _t1976 + p.recordSpan(int(span_start1126), "MonoidDef") + return result1127 } func (p *Parser) parse_monoid() *pb.Monoid { - span_start1134 := int64(p.spanStart()) - var _t1979 int64 + span_start1133 := int64(p.spanStart()) + var _t1977 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1980 int64 + var _t1978 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1980 = 3 + _t1978 = 3 } else { - var _t1981 int64 + var _t1979 int64 if p.matchLookaheadLiteral("or", 1) { - _t1981 = 0 + _t1979 = 0 } else { - var _t1982 int64 + var _t1980 int64 if p.matchLookaheadLiteral("min", 1) { - _t1982 = 1 + _t1980 = 1 } else { - var _t1983 int64 + var _t1981 int64 if p.matchLookaheadLiteral("max", 1) { - _t1983 = 2 + _t1981 = 2 } else { - _t1983 = -1 + _t1981 = -1 } - _t1982 = _t1983 + _t1980 = _t1981 } - _t1981 = _t1982 + _t1979 = _t1980 } - _t1980 = _t1981 + _t1978 = _t1979 } - _t1979 = _t1980 + _t1977 = _t1978 } else { - _t1979 = -1 - } - prediction1129 := _t1979 - var _t1984 *pb.Monoid - if prediction1129 == 3 { - _t1985 := p.parse_sum_monoid() - sum_monoid1133 := _t1985 - _t1986 := &pb.Monoid{} - _t1986.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1133} - _t1984 = _t1986 + _t1977 = -1 + } + prediction1128 := _t1977 + var _t1982 *pb.Monoid + if prediction1128 == 3 { + _t1983 := p.parse_sum_monoid() + sum_monoid1132 := _t1983 + _t1984 := &pb.Monoid{} + _t1984.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1132} + _t1982 = _t1984 } else { - var _t1987 *pb.Monoid - if prediction1129 == 2 { - _t1988 := p.parse_max_monoid() - max_monoid1132 := _t1988 - _t1989 := &pb.Monoid{} - _t1989.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1132} - _t1987 = _t1989 + var _t1985 *pb.Monoid + if prediction1128 == 2 { + _t1986 := p.parse_max_monoid() + max_monoid1131 := _t1986 + _t1987 := &pb.Monoid{} + _t1987.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1131} + _t1985 = _t1987 } else { - var _t1990 *pb.Monoid - if prediction1129 == 1 { - _t1991 := p.parse_min_monoid() - min_monoid1131 := _t1991 - _t1992 := &pb.Monoid{} - _t1992.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1131} - _t1990 = _t1992 + var _t1988 *pb.Monoid + if prediction1128 == 1 { + _t1989 := p.parse_min_monoid() + min_monoid1130 := _t1989 + _t1990 := &pb.Monoid{} + _t1990.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1130} + _t1988 = _t1990 } else { - var _t1993 *pb.Monoid - if prediction1129 == 0 { - _t1994 := p.parse_or_monoid() - or_monoid1130 := _t1994 - _t1995 := &pb.Monoid{} - _t1995.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1130} - _t1993 = _t1995 + var _t1991 *pb.Monoid + if prediction1128 == 0 { + _t1992 := p.parse_or_monoid() + or_monoid1129 := _t1992 + _t1993 := &pb.Monoid{} + _t1993.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1129} + _t1991 = _t1993 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1990 = _t1993 + _t1988 = _t1991 } - _t1987 = _t1990 + _t1985 = _t1988 } - _t1984 = _t1987 + _t1982 = _t1985 } - result1135 := _t1984 - p.recordSpan(int(span_start1134), "Monoid") - return result1135 + result1134 := _t1982 + p.recordSpan(int(span_start1133), "Monoid") + return result1134 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { - span_start1136 := int64(p.spanStart()) + span_start1135 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1996 := &pb.OrMonoid{} - result1137 := _t1996 - p.recordSpan(int(span_start1136), "OrMonoid") - return result1137 + _t1994 := &pb.OrMonoid{} + result1136 := _t1994 + p.recordSpan(int(span_start1135), "OrMonoid") + return result1136 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { - span_start1139 := int64(p.spanStart()) + span_start1138 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("min") - _t1997 := p.parse_type() - type1138 := _t1997 + _t1995 := p.parse_type() + type1137 := _t1995 p.consumeLiteral(")") - _t1998 := &pb.MinMonoid{Type: type1138} - result1140 := _t1998 - p.recordSpan(int(span_start1139), "MinMonoid") - return result1140 + _t1996 := &pb.MinMonoid{Type: type1137} + result1139 := _t1996 + p.recordSpan(int(span_start1138), "MinMonoid") + return result1139 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { - span_start1142 := int64(p.spanStart()) + span_start1141 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("max") - _t1999 := p.parse_type() - type1141 := _t1999 + _t1997 := p.parse_type() + type1140 := _t1997 p.consumeLiteral(")") - _t2000 := &pb.MaxMonoid{Type: type1141} - result1143 := _t2000 - p.recordSpan(int(span_start1142), "MaxMonoid") - return result1143 + _t1998 := &pb.MaxMonoid{Type: type1140} + result1142 := _t1998 + p.recordSpan(int(span_start1141), "MaxMonoid") + return result1142 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { - span_start1145 := int64(p.spanStart()) + span_start1144 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sum") - _t2001 := p.parse_type() - type1144 := _t2001 + _t1999 := p.parse_type() + type1143 := _t1999 p.consumeLiteral(")") - _t2002 := &pb.SumMonoid{Type: type1144} - result1146 := _t2002 - p.recordSpan(int(span_start1145), "SumMonoid") - return result1146 + _t2000 := &pb.SumMonoid{Type: type1143} + result1145 := _t2000 + p.recordSpan(int(span_start1144), "SumMonoid") + return result1145 } func (p *Parser) parse_monus_def() *pb.MonusDef { - span_start1151 := int64(p.spanStart()) + span_start1150 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monus") - _t2003 := p.parse_monoid() - monoid1147 := _t2003 - _t2004 := p.parse_relation_id() - relation_id1148 := _t2004 - _t2005 := p.parse_abstraction_with_arity() - abstraction_with_arity1149 := _t2005 - var _t2006 []*pb.Attribute + _t2001 := p.parse_monoid() + monoid1146 := _t2001 + _t2002 := p.parse_relation_id() + relation_id1147 := _t2002 + _t2003 := p.parse_abstraction_with_arity() + abstraction_with_arity1148 := _t2003 + var _t2004 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t2007 := p.parse_attrs() - _t2006 = _t2007 + _t2005 := p.parse_attrs() + _t2004 = _t2005 } - attrs1150 := _t2006 + attrs1149 := _t2004 p.consumeLiteral(")") - _t2008 := attrs1150 - if attrs1150 == nil { - _t2008 = []*pb.Attribute{} + _t2006 := attrs1149 + if attrs1149 == nil { + _t2006 = []*pb.Attribute{} } - _t2009 := &pb.MonusDef{Monoid: monoid1147, Name: relation_id1148, Body: abstraction_with_arity1149[0].(*pb.Abstraction), Attrs: _t2008, ValueArity: abstraction_with_arity1149[1].(int64)} - result1152 := _t2009 - p.recordSpan(int(span_start1151), "MonusDef") - return result1152 + _t2007 := &pb.MonusDef{Monoid: monoid1146, Name: relation_id1147, Body: abstraction_with_arity1148[0].(*pb.Abstraction), Attrs: _t2006, ValueArity: abstraction_with_arity1148[1].(int64)} + result1151 := _t2007 + p.recordSpan(int(span_start1150), "MonusDef") + return result1151 } func (p *Parser) parse_constraint() *pb.Constraint { - span_start1157 := int64(p.spanStart()) + span_start1156 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t2010 := p.parse_relation_id() - relation_id1153 := _t2010 - _t2011 := p.parse_abstraction() - abstraction1154 := _t2011 - _t2012 := p.parse_functional_dependency_keys() - functional_dependency_keys1155 := _t2012 - _t2013 := p.parse_functional_dependency_values() - functional_dependency_values1156 := _t2013 + _t2008 := p.parse_relation_id() + relation_id1152 := _t2008 + _t2009 := p.parse_abstraction() + abstraction1153 := _t2009 + _t2010 := p.parse_functional_dependency_keys() + functional_dependency_keys1154 := _t2010 + _t2011 := p.parse_functional_dependency_values() + functional_dependency_values1155 := _t2011 p.consumeLiteral(")") - _t2014 := &pb.FunctionalDependency{Guard: abstraction1154, Keys: functional_dependency_keys1155, Values: functional_dependency_values1156} - _t2015 := &pb.Constraint{Name: relation_id1153} - _t2015.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t2014} - result1158 := _t2015 - p.recordSpan(int(span_start1157), "Constraint") - return result1158 + _t2012 := &pb.FunctionalDependency{Guard: abstraction1153, Keys: functional_dependency_keys1154, Values: functional_dependency_values1155} + _t2013 := &pb.Constraint{Name: relation_id1152} + _t2013.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t2012} + result1157 := _t2013 + p.recordSpan(int(span_start1156), "Constraint") + return result1157 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1159 := []*pb.Var{} - cond1160 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1160 { - _t2016 := p.parse_var() - item1161 := _t2016 - xs1159 = append(xs1159, item1161) - cond1160 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1162 := xs1159 + xs1158 := []*pb.Var{} + cond1159 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1159 { + _t2014 := p.parse_var() + item1160 := _t2014 + xs1158 = append(xs1158, item1160) + cond1159 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1161 := xs1158 p.consumeLiteral(")") - return vars1162 + return vars1161 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - xs1163 := []*pb.Var{} - cond1164 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1164 { - _t2017 := p.parse_var() - item1165 := _t2017 - xs1163 = append(xs1163, item1165) - cond1164 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1166 := xs1163 + xs1162 := []*pb.Var{} + cond1163 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1163 { + _t2015 := p.parse_var() + item1164 := _t2015 + xs1162 = append(xs1162, item1164) + cond1163 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1165 := xs1162 p.consumeLiteral(")") - return vars1166 + return vars1165 } func (p *Parser) parse_data() *pb.Data { - span_start1172 := int64(p.spanStart()) - var _t2018 int64 + span_start1171 := int64(p.spanStart()) + var _t2016 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2019 int64 + var _t2017 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t2019 = 3 + _t2017 = 3 } else { - var _t2020 int64 + var _t2018 int64 if p.matchLookaheadLiteral("edb", 1) { - _t2020 = 0 + _t2018 = 0 } else { - var _t2021 int64 + var _t2019 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t2021 = 2 + _t2019 = 2 } else { - var _t2022 int64 + var _t2020 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t2022 = 1 + _t2020 = 1 } else { - _t2022 = -1 + _t2020 = -1 } - _t2021 = _t2022 + _t2019 = _t2020 } - _t2020 = _t2021 + _t2018 = _t2019 } - _t2019 = _t2020 + _t2017 = _t2018 } - _t2018 = _t2019 + _t2016 = _t2017 } else { - _t2018 = -1 - } - prediction1167 := _t2018 - var _t2023 *pb.Data - if prediction1167 == 3 { - _t2024 := p.parse_iceberg_data() - iceberg_data1171 := _t2024 - _t2025 := &pb.Data{} - _t2025.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1171} - _t2023 = _t2025 + _t2016 = -1 + } + prediction1166 := _t2016 + var _t2021 *pb.Data + if prediction1166 == 3 { + _t2022 := p.parse_iceberg_data() + iceberg_data1170 := _t2022 + _t2023 := &pb.Data{} + _t2023.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1170} + _t2021 = _t2023 } else { - var _t2026 *pb.Data - if prediction1167 == 2 { - _t2027 := p.parse_csv_data() - csv_data1170 := _t2027 - _t2028 := &pb.Data{} - _t2028.DataType = &pb.Data_CsvData{CsvData: csv_data1170} - _t2026 = _t2028 + var _t2024 *pb.Data + if prediction1166 == 2 { + _t2025 := p.parse_csv_data() + csv_data1169 := _t2025 + _t2026 := &pb.Data{} + _t2026.DataType = &pb.Data_CsvData{CsvData: csv_data1169} + _t2024 = _t2026 } else { - var _t2029 *pb.Data - if prediction1167 == 1 { - _t2030 := p.parse_betree_relation() - betree_relation1169 := _t2030 - _t2031 := &pb.Data{} - _t2031.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1169} - _t2029 = _t2031 + var _t2027 *pb.Data + if prediction1166 == 1 { + _t2028 := p.parse_betree_relation() + betree_relation1168 := _t2028 + _t2029 := &pb.Data{} + _t2029.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1168} + _t2027 = _t2029 } else { - var _t2032 *pb.Data - if prediction1167 == 0 { - _t2033 := p.parse_edb() - edb1168 := _t2033 - _t2034 := &pb.Data{} - _t2034.DataType = &pb.Data_Edb{Edb: edb1168} - _t2032 = _t2034 + var _t2030 *pb.Data + if prediction1166 == 0 { + _t2031 := p.parse_edb() + edb1167 := _t2031 + _t2032 := &pb.Data{} + _t2032.DataType = &pb.Data_Edb{Edb: edb1167} + _t2030 = _t2032 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2029 = _t2032 + _t2027 = _t2030 } - _t2026 = _t2029 + _t2024 = _t2027 } - _t2023 = _t2026 + _t2021 = _t2024 } - result1173 := _t2023 - p.recordSpan(int(span_start1172), "Data") - return result1173 + result1172 := _t2021 + p.recordSpan(int(span_start1171), "Data") + return result1172 } func (p *Parser) parse_edb() *pb.EDB { - span_start1177 := int64(p.spanStart()) + span_start1176 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("edb") - _t2035 := p.parse_relation_id() - relation_id1174 := _t2035 - _t2036 := p.parse_edb_path() - edb_path1175 := _t2036 - _t2037 := p.parse_edb_types() - edb_types1176 := _t2037 + _t2033 := p.parse_relation_id() + relation_id1173 := _t2033 + _t2034 := p.parse_edb_path() + edb_path1174 := _t2034 + _t2035 := p.parse_edb_types() + edb_types1175 := _t2035 p.consumeLiteral(")") - _t2038 := &pb.EDB{TargetId: relation_id1174, Path: edb_path1175, Types: edb_types1176} - result1178 := _t2038 - p.recordSpan(int(span_start1177), "EDB") - return result1178 + _t2036 := &pb.EDB{TargetId: relation_id1173, Path: edb_path1174, Types: edb_types1175} + result1177 := _t2036 + p.recordSpan(int(span_start1176), "EDB") + return result1177 } func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") - xs1179 := []string{} - cond1180 := p.matchLookaheadTerminal("STRING", 0) - for cond1180 { - item1181 := p.consumeTerminal("STRING").Value.str - xs1179 = append(xs1179, item1181) - cond1180 = p.matchLookaheadTerminal("STRING", 0) - } - strings1182 := xs1179 + xs1178 := []string{} + cond1179 := p.matchLookaheadTerminal("STRING", 0) + for cond1179 { + item1180 := p.consumeTerminal("STRING").Value.str + xs1178 = append(xs1178, item1180) + cond1179 = p.matchLookaheadTerminal("STRING", 0) + } + strings1181 := xs1178 p.consumeLiteral("]") - return strings1182 + return strings1181 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - xs1183 := []*pb.Type{} - cond1184 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1184 { - _t2039 := p.parse_type() - item1185 := _t2039 - xs1183 = append(xs1183, item1185) - cond1184 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1186 := xs1183 + xs1182 := []*pb.Type{} + cond1183 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1183 { + _t2037 := p.parse_type() + item1184 := _t2037 + xs1182 = append(xs1182, item1184) + cond1183 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1185 := xs1182 p.consumeLiteral("]") - return types1186 + return types1185 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { - span_start1189 := int64(p.spanStart()) + span_start1188 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t2040 := p.parse_relation_id() - relation_id1187 := _t2040 - _t2041 := p.parse_betree_info() - betree_info1188 := _t2041 + _t2038 := p.parse_relation_id() + relation_id1186 := _t2038 + _t2039 := p.parse_betree_info() + betree_info1187 := _t2039 p.consumeLiteral(")") - _t2042 := &pb.BeTreeRelation{Name: relation_id1187, RelationInfo: betree_info1188} - result1190 := _t2042 - p.recordSpan(int(span_start1189), "BeTreeRelation") - return result1190 + _t2040 := &pb.BeTreeRelation{Name: relation_id1186, RelationInfo: betree_info1187} + result1189 := _t2040 + p.recordSpan(int(span_start1188), "BeTreeRelation") + return result1189 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { - span_start1194 := int64(p.spanStart()) + span_start1193 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t2043 := p.parse_betree_info_key_types() - betree_info_key_types1191 := _t2043 - _t2044 := p.parse_betree_info_value_types() - betree_info_value_types1192 := _t2044 - _t2045 := p.parse_config_dict() - config_dict1193 := _t2045 + _t2041 := p.parse_betree_info_key_types() + betree_info_key_types1190 := _t2041 + _t2042 := p.parse_betree_info_value_types() + betree_info_value_types1191 := _t2042 + _t2043 := p.parse_config_dict() + config_dict1192 := _t2043 p.consumeLiteral(")") - _t2046 := p.construct_betree_info(betree_info_key_types1191, betree_info_value_types1192, config_dict1193) - result1195 := _t2046 - p.recordSpan(int(span_start1194), "BeTreeInfo") - return result1195 + _t2044 := p.construct_betree_info(betree_info_key_types1190, betree_info_value_types1191, config_dict1192) + result1194 := _t2044 + p.recordSpan(int(span_start1193), "BeTreeInfo") + return result1194 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs1196 := []*pb.Type{} - cond1197 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1197 { - _t2047 := p.parse_type() - item1198 := _t2047 - xs1196 = append(xs1196, item1198) - cond1197 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1199 := xs1196 + xs1195 := []*pb.Type{} + cond1196 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1196 { + _t2045 := p.parse_type() + item1197 := _t2045 + xs1195 = append(xs1195, item1197) + cond1196 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1198 := xs1195 p.consumeLiteral(")") - return types1199 + return types1198 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - xs1200 := []*pb.Type{} - cond1201 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1201 { - _t2048 := p.parse_type() - item1202 := _t2048 - xs1200 = append(xs1200, item1202) - cond1201 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1203 := xs1200 + xs1199 := []*pb.Type{} + cond1200 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1200 { + _t2046 := p.parse_type() + item1201 := _t2046 + xs1199 = append(xs1199, item1201) + cond1200 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1202 := xs1199 p.consumeLiteral(")") - return types1203 + return types1202 } func (p *Parser) parse_csv_data() *pb.CSVData { - span_start1209 := int64(p.spanStart()) + span_start1208 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t2049 := p.parse_csvlocator() - csvlocator1204 := _t2049 - _t2050 := p.parse_csv_config() - csv_config1205 := _t2050 - var _t2051 []*pb.GNFColumn + _t2047 := p.parse_csvlocator() + csvlocator1203 := _t2047 + _t2048 := p.parse_csv_config() + csv_config1204 := _t2048 + var _t2049 []*pb.GNFColumn if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("columns", 1)) { - _t2052 := p.parse_gnf_columns() - _t2051 = _t2052 + _t2050 := p.parse_gnf_columns() + _t2049 = _t2050 } - gnf_columns1206 := _t2051 - var _t2053 *pb.TargetRelations + gnf_columns1205 := _t2049 + var _t2051 *pb.TargetRelations if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("relations", 1)) { - _t2054 := p.parse_target_relations() - _t2053 = _t2054 + _t2052 := p.parse_target_relations() + _t2051 = _t2052 } - target_relations1207 := _t2053 - _t2055 := p.parse_csv_asof() - csv_asof1208 := _t2055 + target_relations1206 := _t2051 + _t2053 := p.parse_csv_asof() + csv_asof1207 := _t2053 p.consumeLiteral(")") - _t2056 := p.construct_csv_data(csvlocator1204, csv_config1205, gnf_columns1206, target_relations1207, csv_asof1208) - result1210 := _t2056 - p.recordSpan(int(span_start1209), "CSVData") - return result1210 + _t2054 := p.construct_csv_data(csvlocator1203, csv_config1204, gnf_columns1205, target_relations1206, csv_asof1207) + result1209 := _t2054 + p.recordSpan(int(span_start1208), "CSVData") + return result1209 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { - span_start1213 := int64(p.spanStart()) + span_start1212 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t2057 []string + var _t2055 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t2058 := p.parse_csv_locator_paths() - _t2057 = _t2058 + _t2056 := p.parse_csv_locator_paths() + _t2055 = _t2056 } - csv_locator_paths1211 := _t2057 - var _t2059 *string + csv_locator_paths1210 := _t2055 + var _t2057 *string if p.matchLookaheadLiteral("(", 0) { - _t2060 := p.parse_csv_locator_inline_data() - _t2059 = ptr(_t2060) + _t2058 := p.parse_csv_locator_inline_data() + _t2057 = ptr(_t2058) } - csv_locator_inline_data1212 := _t2059 + csv_locator_inline_data1211 := _t2057 p.consumeLiteral(")") - _t2061 := csv_locator_paths1211 - if csv_locator_paths1211 == nil { - _t2061 = []string{} + _t2059 := csv_locator_paths1210 + if csv_locator_paths1210 == nil { + _t2059 = []string{} } - _t2062 := &pb.CSVLocator{Paths: _t2061, InlineData: []byte(deref(csv_locator_inline_data1212, ""))} - result1214 := _t2062 - p.recordSpan(int(span_start1213), "CSVLocator") - return result1214 + _t2060 := &pb.CSVLocator{Paths: _t2059, InlineData: []byte(deref(csv_locator_inline_data1211, ""))} + result1213 := _t2060 + p.recordSpan(int(span_start1212), "CSVLocator") + return result1213 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs1215 := []string{} - cond1216 := p.matchLookaheadTerminal("STRING", 0) - for cond1216 { - item1217 := p.consumeTerminal("STRING").Value.str - xs1215 = append(xs1215, item1217) - cond1216 = p.matchLookaheadTerminal("STRING", 0) - } - strings1218 := xs1215 + xs1214 := []string{} + cond1215 := p.matchLookaheadTerminal("STRING", 0) + for cond1215 { + item1216 := p.consumeTerminal("STRING").Value.str + xs1214 = append(xs1214, item1216) + cond1215 = p.matchLookaheadTerminal("STRING", 0) + } + strings1217 := xs1214 p.consumeLiteral(")") - return strings1218 + return strings1217 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - formatted_string1219 := p.consumeTerminal("STRING").Value.str + formatted_string1218 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return formatted_string1219 + return formatted_string1218 } func (p *Parser) parse_csv_config() *pb.CSVConfig { - span_start1222 := int64(p.spanStart()) + span_start1221 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t2063 := p.parse_config_dict() - config_dict1220 := _t2063 - var _t2064 [][]interface{} + _t2061 := p.parse_config_dict() + config_dict1219 := _t2061 + var _t2062 [][]interface{} if p.matchLookaheadLiteral("(", 0) { - _t2065 := p.parse__storage_integration() - _t2064 = _t2065 + _t2063 := p.parse__storage_integration() + _t2062 = _t2063 } - _storage_integration1221 := _t2064 + _storage_integration1220 := _t2062 p.consumeLiteral(")") - _t2066 := p.construct_csv_config(config_dict1220, _storage_integration1221) - result1223 := _t2066 - p.recordSpan(int(span_start1222), "CSVConfig") - return result1223 + _t2064 := p.construct_csv_config(config_dict1219, _storage_integration1220) + result1222 := _t2064 + p.recordSpan(int(span_start1221), "CSVConfig") + return result1222 } func (p *Parser) parse__storage_integration() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("storage_integration") - _t2067 := p.parse_config_dict() - config_dict1224 := _t2067 + _t2065 := p.parse_config_dict() + config_dict1223 := _t2065 p.consumeLiteral(")") - return config_dict1224 + return config_dict1223 } func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1225 := []*pb.GNFColumn{} - cond1226 := p.matchLookaheadLiteral("(", 0) - for cond1226 { - _t2068 := p.parse_gnf_column() - item1227 := _t2068 - xs1225 = append(xs1225, item1227) - cond1226 = p.matchLookaheadLiteral("(", 0) - } - gnf_columns1228 := xs1225 + xs1224 := []*pb.GNFColumn{} + cond1225 := p.matchLookaheadLiteral("(", 0) + for cond1225 { + _t2066 := p.parse_gnf_column() + item1226 := _t2066 + xs1224 = append(xs1224, item1226) + cond1225 = p.matchLookaheadLiteral("(", 0) + } + gnf_columns1227 := xs1224 p.consumeLiteral(")") - return gnf_columns1228 + return gnf_columns1227 } func (p *Parser) parse_gnf_column() *pb.GNFColumn { - span_start1235 := int64(p.spanStart()) + span_start1234 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - _t2069 := p.parse_gnf_column_path() - gnf_column_path1229 := _t2069 - var _t2070 *pb.RelationId + _t2067 := p.parse_gnf_column_path() + gnf_column_path1228 := _t2067 + var _t2068 *pb.RelationId if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t2071 := p.parse_relation_id() - _t2070 = _t2071 + _t2069 := p.parse_relation_id() + _t2068 = _t2069 } - relation_id1230 := _t2070 + relation_id1229 := _t2068 p.consumeLiteral("[") - xs1231 := []*pb.Type{} - cond1232 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - for cond1232 { - _t2072 := p.parse_type() - item1233 := _t2072 - xs1231 = append(xs1231, item1233) - cond1232 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) - } - types1234 := xs1231 + xs1230 := []*pb.Type{} + cond1231 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1231 { + _t2070 := p.parse_type() + item1232 := _t2070 + xs1230 = append(xs1230, item1232) + cond1231 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1233 := xs1230 p.consumeLiteral("]") p.consumeLiteral(")") - _t2073 := &pb.GNFColumn{ColumnPath: gnf_column_path1229, TargetId: relation_id1230, Types: types1234} - result1236 := _t2073 - p.recordSpan(int(span_start1235), "GNFColumn") - return result1236 + _t2071 := &pb.GNFColumn{ColumnPath: gnf_column_path1228, TargetId: relation_id1229, Types: types1233} + result1235 := _t2071 + p.recordSpan(int(span_start1234), "GNFColumn") + return result1235 } func (p *Parser) parse_gnf_column_path() []string { - var _t2074 int64 + var _t2072 int64 if p.matchLookaheadLiteral("[", 0) { - _t2074 = 1 + _t2072 = 1 } else { - var _t2075 int64 + var _t2073 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t2075 = 0 + _t2073 = 0 } else { - _t2075 = -1 + _t2073 = -1 } - _t2074 = _t2075 + _t2072 = _t2073 } - prediction1237 := _t2074 - var _t2076 []string - if prediction1237 == 1 { + prediction1236 := _t2072 + var _t2074 []string + if prediction1236 == 1 { p.consumeLiteral("[") - xs1239 := []string{} - cond1240 := p.matchLookaheadTerminal("STRING", 0) - for cond1240 { - item1241 := p.consumeTerminal("STRING").Value.str - xs1239 = append(xs1239, item1241) - cond1240 = p.matchLookaheadTerminal("STRING", 0) + xs1238 := []string{} + cond1239 := p.matchLookaheadTerminal("STRING", 0) + for cond1239 { + item1240 := p.consumeTerminal("STRING").Value.str + xs1238 = append(xs1238, item1240) + cond1239 = p.matchLookaheadTerminal("STRING", 0) } - strings1242 := xs1239 + strings1241 := xs1238 p.consumeLiteral("]") - _t2076 = strings1242 + _t2074 = strings1241 } else { - var _t2077 []string - if prediction1237 == 0 { - string1238 := p.consumeTerminal("STRING").Value.str - _ = string1238 - _t2077 = []string{string1238} + var _t2075 []string + if prediction1236 == 0 { + string1237 := p.consumeTerminal("STRING").Value.str + _ = string1237 + _t2075 = []string{string1237} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2076 = _t2077 + _t2074 = _t2075 } - return _t2076 + return _t2074 } func (p *Parser) parse_target_relations() *pb.TargetRelations { - span_start1245 := int64(p.spanStart()) + span_start1244 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relations") - _t2078 := p.parse_relation_keys() - relation_keys1243 := _t2078 - _t2079 := p.parse_relation_body() - relation_body1244 := _t2079 + _t2076 := p.parse_relation_keys() + relation_keys1242 := _t2076 + _t2077 := p.parse_relation_body() + relation_body1243 := _t2077 p.consumeLiteral(")") - _t2080 := p.construct_relations(relation_keys1243, relation_body1244) - result1246 := _t2080 - p.recordSpan(int(span_start1245), "TargetRelations") - return result1246 + _t2078 := p.construct_relations(relation_keys1242, relation_body1243) + result1245 := _t2078 + p.recordSpan(int(span_start1244), "TargetRelations") + return result1245 } func (p *Parser) parse_relation_keys() []interface{} { - var _t2081 int64 + var _t2079 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2082 int64 + var _t2080 int64 if p.matchLookaheadLiteral("keys", 1) { - var _t2083 int64 - if p.matchLookaheadLiteral(":", 2) { - _t2083 = 1 + var _t2081 int64 + if p.matchLookaheadLiteral("synthetic", 2) { + _t2081 = 1 } else { - var _t2084 int64 + var _t2082 int64 if p.matchLookaheadLiteral(")", 2) { - _t2084 = 0 + _t2082 = 0 } else { - var _t2085 int64 + var _t2083 int64 if p.matchLookaheadLiteral("(", 2) { - _t2085 = 0 + _t2083 = 0 } else { - _t2085 = -1 + _t2083 = -1 } - _t2084 = _t2085 + _t2082 = _t2083 } - _t2083 = _t2084 + _t2081 = _t2082 } - _t2082 = _t2083 + _t2080 = _t2081 } else { - _t2082 = -1 + _t2080 = -1 } - _t2081 = _t2082 + _t2079 = _t2080 } else { - _t2081 = -1 + _t2079 = -1 } - prediction1247 := _t2081 - var _t2086 []interface{} - if prediction1247 == 1 { + prediction1246 := _t2079 + var _t2084 []interface{} + if prediction1246 == 1 { p.consumeLiteral("(") p.consumeLiteral("keys") - p.consumeLiteral(":") - symbol1252 := p.consumeTerminal("SYMBOL").Value.str + p.consumeLiteral("synthetic") p.consumeLiteral(")") - _t2087 := p.construct_synthetic_keys(symbol1252) - _t2086 = _t2087 + _t2084 = []interface{}{[]*pb.NamedColumn{}, true} } else { - var _t2088 []interface{} - if prediction1247 == 0 { + var _t2085 []interface{} + if prediction1246 == 0 { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1248 := []*pb.NamedColumn{} - cond1249 := p.matchLookaheadLiteral("(", 0) - for cond1249 { - _t2089 := p.parse_named_column() - item1250 := _t2089 - xs1248 = append(xs1248, item1250) - cond1249 = p.matchLookaheadLiteral("(", 0) + xs1247 := []*pb.NamedColumn{} + cond1248 := p.matchLookaheadLiteral("(", 0) + for cond1248 { + _t2086 := p.parse_named_column() + item1249 := _t2086 + xs1247 = append(xs1247, item1249) + cond1248 = p.matchLookaheadLiteral("(", 0) } - named_columns1251 := xs1248 + named_columns1250 := xs1247 p.consumeLiteral(")") - _t2088 = []interface{}{named_columns1251, false} + _t2085 = []interface{}{named_columns1250, false} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_keys", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2086 = _t2088 + _t2084 = _t2085 } - return _t2086 + return _t2084 } func (p *Parser) parse_named_column() *pb.NamedColumn { - span_start1255 := int64(p.spanStart()) + span_start1253 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1253 := p.consumeTerminal("STRING").Value.str - _t2090 := p.parse_type() - type1254 := _t2090 + string1251 := p.consumeTerminal("STRING").Value.str + _t2087 := p.parse_type() + type1252 := _t2087 p.consumeLiteral(")") - _t2091 := &pb.NamedColumn{Name: string1253, Type: type1254} - result1256 := _t2091 - p.recordSpan(int(span_start1255), "NamedColumn") - return result1256 + _t2088 := &pb.NamedColumn{Name: string1251, Type: type1252} + result1254 := _t2088 + p.recordSpan(int(span_start1253), "NamedColumn") + return result1254 } func (p *Parser) parse_relation_body() *pb.TargetRelations { - span_start1261 := int64(p.spanStart()) - var _t2092 int64 + span_start1259 := int64(p.spanStart()) + var _t2089 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2093 int64 + var _t2090 int64 if p.matchLookaheadLiteral("relation", 1) { - _t2093 = 0 + _t2090 = 0 } else { - var _t2094 int64 + var _t2091 int64 if p.matchLookaheadLiteral("inserts", 1) { - _t2094 = 1 + _t2091 = 1 } else { - _t2094 = 0 + _t2091 = 0 } - _t2093 = _t2094 + _t2090 = _t2091 } - _t2092 = _t2093 + _t2089 = _t2090 } else { - _t2092 = 0 - } - prediction1257 := _t2092 - var _t2095 *pb.TargetRelations - if prediction1257 == 1 { - _t2096 := p.parse_cdc_inserts() - cdc_inserts1259 := _t2096 - _t2097 := p.parse_cdc_deletes() - cdc_deletes1260 := _t2097 - _t2098 := p.construct_cdc_relations(cdc_inserts1259, cdc_deletes1260) - _t2095 = _t2098 + _t2089 = 0 + } + prediction1255 := _t2089 + var _t2092 *pb.TargetRelations + if prediction1255 == 1 { + _t2093 := p.parse_cdc_inserts() + cdc_inserts1257 := _t2093 + _t2094 := p.parse_cdc_deletes() + cdc_deletes1258 := _t2094 + _t2095 := p.construct_cdc_relations(cdc_inserts1257, cdc_deletes1258) + _t2092 = _t2095 } else { - var _t2099 *pb.TargetRelations - if prediction1257 == 0 { - _t2100 := p.parse_non_cdc_relations() - non_cdc_relations1258 := _t2100 - _t2101 := p.construct_non_cdc_relations(non_cdc_relations1258) - _t2099 = _t2101 + var _t2096 *pb.TargetRelations + if prediction1255 == 0 { + _t2097 := p.parse_non_cdc_relations() + non_cdc_relations1256 := _t2097 + _t2098 := p.construct_non_cdc_relations(non_cdc_relations1256) + _t2096 = _t2098 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_body", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2095 = _t2099 + _t2092 = _t2096 } - result1262 := _t2095 - p.recordSpan(int(span_start1261), "TargetRelations") - return result1262 + result1260 := _t2092 + p.recordSpan(int(span_start1259), "TargetRelations") + return result1260 } func (p *Parser) parse_non_cdc_relations() []*pb.TargetRelation { - xs1263 := []*pb.TargetRelation{} - cond1264 := p.matchLookaheadLiteral("(", 0) - for cond1264 { - _t2102 := p.parse_target_relation() - item1265 := _t2102 - xs1263 = append(xs1263, item1265) - cond1264 = p.matchLookaheadLiteral("(", 0) + xs1261 := []*pb.TargetRelation{} + cond1262 := p.matchLookaheadLiteral("(", 0) + for cond1262 { + _t2099 := p.parse_target_relation() + item1263 := _t2099 + xs1261 = append(xs1261, item1263) + cond1262 = p.matchLookaheadLiteral("(", 0) } - return xs1263 + return xs1261 } func (p *Parser) parse_target_relation() *pb.TargetRelation { - span_start1271 := int64(p.spanStart()) + span_start1269 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relation") - _t2103 := p.parse_relation_id() - relation_id1266 := _t2103 - xs1267 := []*pb.NamedColumn{} - cond1268 := p.matchLookaheadLiteral("(", 0) - for cond1268 { - _t2104 := p.parse_named_column() - item1269 := _t2104 - xs1267 = append(xs1267, item1269) - cond1268 = p.matchLookaheadLiteral("(", 0) - } - named_columns1270 := xs1267 + _t2100 := p.parse_relation_id() + relation_id1264 := _t2100 + xs1265 := []*pb.NamedColumn{} + cond1266 := p.matchLookaheadLiteral("(", 0) + for cond1266 { + _t2101 := p.parse_named_column() + item1267 := _t2101 + xs1265 = append(xs1265, item1267) + cond1266 = p.matchLookaheadLiteral("(", 0) + } + named_columns1268 := xs1265 p.consumeLiteral(")") - _t2105 := &pb.TargetRelation{TargetId: relation_id1266, Values: named_columns1270} - result1272 := _t2105 - p.recordSpan(int(span_start1271), "TargetRelation") - return result1272 + _t2102 := &pb.TargetRelation{TargetId: relation_id1264, Values: named_columns1268} + result1270 := _t2102 + p.recordSpan(int(span_start1269), "TargetRelation") + return result1270 } func (p *Parser) parse_cdc_inserts() []*pb.TargetRelation { p.consumeLiteral("(") p.consumeLiteral("inserts") - xs1273 := []*pb.TargetRelation{} - cond1274 := p.matchLookaheadLiteral("(", 0) - for cond1274 { - _t2106 := p.parse_target_relation() - item1275 := _t2106 - xs1273 = append(xs1273, item1275) - cond1274 = p.matchLookaheadLiteral("(", 0) - } - target_relations1276 := xs1273 + xs1271 := []*pb.TargetRelation{} + cond1272 := p.matchLookaheadLiteral("(", 0) + for cond1272 { + _t2103 := p.parse_target_relation() + item1273 := _t2103 + xs1271 = append(xs1271, item1273) + cond1272 = p.matchLookaheadLiteral("(", 0) + } + target_relations1274 := xs1271 p.consumeLiteral(")") - return target_relations1276 + return target_relations1274 } func (p *Parser) parse_cdc_deletes() []*pb.TargetRelation { p.consumeLiteral("(") p.consumeLiteral("deletes") - xs1277 := []*pb.TargetRelation{} - cond1278 := p.matchLookaheadLiteral("(", 0) - for cond1278 { - _t2107 := p.parse_target_relation() - item1279 := _t2107 - xs1277 = append(xs1277, item1279) - cond1278 = p.matchLookaheadLiteral("(", 0) - } - target_relations1280 := xs1277 + xs1275 := []*pb.TargetRelation{} + cond1276 := p.matchLookaheadLiteral("(", 0) + for cond1276 { + _t2104 := p.parse_target_relation() + item1277 := _t2104 + xs1275 = append(xs1275, item1277) + cond1276 = p.matchLookaheadLiteral("(", 0) + } + target_relations1278 := xs1275 p.consumeLiteral(")") - return target_relations1280 + return target_relations1278 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string1281 := p.consumeTerminal("STRING").Value.str + string1279 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1281 + return string1279 } func (p *Parser) parse_iceberg_data() *pb.IcebergData { - span_start1288 := int64(p.spanStart()) + span_start1286 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_data") - _t2108 := p.parse_iceberg_locator() - iceberg_locator1282 := _t2108 - _t2109 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1283 := _t2109 - _t2110 := p.parse_gnf_columns() - gnf_columns1284 := _t2110 - var _t2111 *string + _t2105 := p.parse_iceberg_locator() + iceberg_locator1280 := _t2105 + _t2106 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1281 := _t2106 + _t2107 := p.parse_gnf_columns() + gnf_columns1282 := _t2107 + var _t2108 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("from_snapshot", 1)) { - _t2112 := p.parse_iceberg_from_snapshot() - _t2111 = ptr(_t2112) + _t2109 := p.parse_iceberg_from_snapshot() + _t2108 = ptr(_t2109) } - iceberg_from_snapshot1285 := _t2111 - var _t2113 *string + iceberg_from_snapshot1283 := _t2108 + var _t2110 *string if p.matchLookaheadLiteral("(", 0) { - _t2114 := p.parse_iceberg_to_snapshot() - _t2113 = ptr(_t2114) + _t2111 := p.parse_iceberg_to_snapshot() + _t2110 = ptr(_t2111) } - iceberg_to_snapshot1286 := _t2113 - _t2115 := p.parse_boolean_value() - boolean_value1287 := _t2115 + iceberg_to_snapshot1284 := _t2110 + _t2112 := p.parse_boolean_value() + boolean_value1285 := _t2112 p.consumeLiteral(")") - _t2116 := p.construct_iceberg_data(iceberg_locator1282, iceberg_catalog_config1283, gnf_columns1284, iceberg_from_snapshot1285, iceberg_to_snapshot1286, boolean_value1287) - result1289 := _t2116 - p.recordSpan(int(span_start1288), "IcebergData") - return result1289 + _t2113 := p.construct_iceberg_data(iceberg_locator1280, iceberg_catalog_config1281, gnf_columns1282, iceberg_from_snapshot1283, iceberg_to_snapshot1284, boolean_value1285) + result1287 := _t2113 + p.recordSpan(int(span_start1286), "IcebergData") + return result1287 } func (p *Parser) parse_iceberg_locator() *pb.IcebergLocator { - span_start1293 := int64(p.spanStart()) + span_start1291 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_locator") - _t2117 := p.parse_iceberg_locator_table_name() - iceberg_locator_table_name1290 := _t2117 - _t2118 := p.parse_iceberg_locator_namespace() - iceberg_locator_namespace1291 := _t2118 - _t2119 := p.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1292 := _t2119 + _t2114 := p.parse_iceberg_locator_table_name() + iceberg_locator_table_name1288 := _t2114 + _t2115 := p.parse_iceberg_locator_namespace() + iceberg_locator_namespace1289 := _t2115 + _t2116 := p.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1290 := _t2116 p.consumeLiteral(")") - _t2120 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1290, Namespace: iceberg_locator_namespace1291, Warehouse: iceberg_locator_warehouse1292} - result1294 := _t2120 - p.recordSpan(int(span_start1293), "IcebergLocator") - return result1294 + _t2117 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1288, Namespace: iceberg_locator_namespace1289, Warehouse: iceberg_locator_warehouse1290} + result1292 := _t2117 + p.recordSpan(int(span_start1291), "IcebergLocator") + return result1292 } func (p *Parser) parse_iceberg_locator_table_name() string { p.consumeLiteral("(") p.consumeLiteral("table_name") - string1295 := p.consumeTerminal("STRING").Value.str + string1293 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1295 + return string1293 } func (p *Parser) parse_iceberg_locator_namespace() []string { p.consumeLiteral("(") p.consumeLiteral("namespace") - xs1296 := []string{} - cond1297 := p.matchLookaheadTerminal("STRING", 0) - for cond1297 { - item1298 := p.consumeTerminal("STRING").Value.str - xs1296 = append(xs1296, item1298) - cond1297 = p.matchLookaheadTerminal("STRING", 0) - } - strings1299 := xs1296 + xs1294 := []string{} + cond1295 := p.matchLookaheadTerminal("STRING", 0) + for cond1295 { + item1296 := p.consumeTerminal("STRING").Value.str + xs1294 = append(xs1294, item1296) + cond1295 = p.matchLookaheadTerminal("STRING", 0) + } + strings1297 := xs1294 p.consumeLiteral(")") - return strings1299 + return strings1297 } func (p *Parser) parse_iceberg_locator_warehouse() string { p.consumeLiteral("(") p.consumeLiteral("warehouse") - string1300 := p.consumeTerminal("STRING").Value.str + string1298 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1300 + return string1298 } func (p *Parser) parse_iceberg_catalog_config() *pb.IcebergCatalogConfig { - span_start1305 := int64(p.spanStart()) + span_start1303 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_catalog_config") - _t2121 := p.parse_iceberg_catalog_uri() - iceberg_catalog_uri1301 := _t2121 - var _t2122 *string + _t2118 := p.parse_iceberg_catalog_uri() + iceberg_catalog_uri1299 := _t2118 + var _t2119 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("scope", 1)) { - _t2123 := p.parse_iceberg_catalog_config_scope() - _t2122 = ptr(_t2123) - } - iceberg_catalog_config_scope1302 := _t2122 - _t2124 := p.parse_iceberg_properties() - iceberg_properties1303 := _t2124 - _t2125 := p.parse_iceberg_auth_properties() - iceberg_auth_properties1304 := _t2125 + _t2120 := p.parse_iceberg_catalog_config_scope() + _t2119 = ptr(_t2120) + } + iceberg_catalog_config_scope1300 := _t2119 + _t2121 := p.parse_iceberg_properties() + iceberg_properties1301 := _t2121 + _t2122 := p.parse_iceberg_auth_properties() + iceberg_auth_properties1302 := _t2122 p.consumeLiteral(")") - _t2126 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1301, iceberg_catalog_config_scope1302, iceberg_properties1303, iceberg_auth_properties1304) - result1306 := _t2126 - p.recordSpan(int(span_start1305), "IcebergCatalogConfig") - return result1306 + _t2123 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1299, iceberg_catalog_config_scope1300, iceberg_properties1301, iceberg_auth_properties1302) + result1304 := _t2123 + p.recordSpan(int(span_start1303), "IcebergCatalogConfig") + return result1304 } func (p *Parser) parse_iceberg_catalog_uri() string { p.consumeLiteral("(") p.consumeLiteral("catalog_uri") - string1307 := p.consumeTerminal("STRING").Value.str + string1305 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1307 + return string1305 } func (p *Parser) parse_iceberg_catalog_config_scope() string { p.consumeLiteral("(") p.consumeLiteral("scope") - string1308 := p.consumeTerminal("STRING").Value.str + string1306 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1308 + return string1306 } func (p *Parser) parse_iceberg_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("properties") - xs1309 := [][]interface{}{} - cond1310 := p.matchLookaheadLiteral("(", 0) - for cond1310 { - _t2127 := p.parse_iceberg_property_entry() - item1311 := _t2127 - xs1309 = append(xs1309, item1311) - cond1310 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1312 := xs1309 + xs1307 := [][]interface{}{} + cond1308 := p.matchLookaheadLiteral("(", 0) + for cond1308 { + _t2124 := p.parse_iceberg_property_entry() + item1309 := _t2124 + xs1307 = append(xs1307, item1309) + cond1308 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1310 := xs1307 p.consumeLiteral(")") - return iceberg_property_entrys1312 + return iceberg_property_entrys1310 } func (p *Parser) parse_iceberg_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1313 := p.consumeTerminal("STRING").Value.str - string_31314 := p.consumeTerminal("STRING").Value.str + string1311 := p.consumeTerminal("STRING").Value.str + string_31312 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1313, string_31314} + return []interface{}{string1311, string_31312} } func (p *Parser) parse_iceberg_auth_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("auth_properties") - xs1315 := [][]interface{}{} - cond1316 := p.matchLookaheadLiteral("(", 0) - for cond1316 { - _t2128 := p.parse_iceberg_masked_property_entry() - item1317 := _t2128 - xs1315 = append(xs1315, item1317) - cond1316 = p.matchLookaheadLiteral("(", 0) - } - iceberg_masked_property_entrys1318 := xs1315 + xs1313 := [][]interface{}{} + cond1314 := p.matchLookaheadLiteral("(", 0) + for cond1314 { + _t2125 := p.parse_iceberg_masked_property_entry() + item1315 := _t2125 + xs1313 = append(xs1313, item1315) + cond1314 = p.matchLookaheadLiteral("(", 0) + } + iceberg_masked_property_entrys1316 := xs1313 p.consumeLiteral(")") - return iceberg_masked_property_entrys1318 + return iceberg_masked_property_entrys1316 } func (p *Parser) parse_iceberg_masked_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1319 := p.consumeTerminal("STRING").Value.str - string_31320 := p.consumeTerminal("STRING").Value.str + string1317 := p.consumeTerminal("STRING").Value.str + string_31318 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1319, string_31320} + return []interface{}{string1317, string_31318} } func (p *Parser) parse_iceberg_from_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("from_snapshot") - string1321 := p.consumeTerminal("STRING").Value.str + string1319 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1321 + return string1319 } func (p *Parser) parse_iceberg_to_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("to_snapshot") - string1322 := p.consumeTerminal("STRING").Value.str + string1320 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1322 + return string1320 } func (p *Parser) parse_undefine() *pb.Undefine { - span_start1324 := int64(p.spanStart()) + span_start1322 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("undefine") - _t2129 := p.parse_fragment_id() - fragment_id1323 := _t2129 + _t2126 := p.parse_fragment_id() + fragment_id1321 := _t2126 p.consumeLiteral(")") - _t2130 := &pb.Undefine{FragmentId: fragment_id1323} - result1325 := _t2130 - p.recordSpan(int(span_start1324), "Undefine") - return result1325 + _t2127 := &pb.Undefine{FragmentId: fragment_id1321} + result1323 := _t2127 + p.recordSpan(int(span_start1322), "Undefine") + return result1323 } func (p *Parser) parse_context() *pb.Context { - span_start1330 := int64(p.spanStart()) + span_start1328 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("context") - xs1326 := []*pb.RelationId{} - cond1327 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1327 { - _t2131 := p.parse_relation_id() - item1328 := _t2131 - xs1326 = append(xs1326, item1328) - cond1327 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1329 := xs1326 + xs1324 := []*pb.RelationId{} + cond1325 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1325 { + _t2128 := p.parse_relation_id() + item1326 := _t2128 + xs1324 = append(xs1324, item1326) + cond1325 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1327 := xs1324 p.consumeLiteral(")") - _t2132 := &pb.Context{Relations: relation_ids1329} - result1331 := _t2132 - p.recordSpan(int(span_start1330), "Context") - return result1331 + _t2129 := &pb.Context{Relations: relation_ids1327} + result1329 := _t2129 + p.recordSpan(int(span_start1328), "Context") + return result1329 } func (p *Parser) parse_snapshot() *pb.Snapshot { - span_start1337 := int64(p.spanStart()) + span_start1335 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t2133 := p.parse_edb_path() - edb_path1332 := _t2133 - xs1333 := []*pb.SnapshotMapping{} - cond1334 := p.matchLookaheadLiteral("[", 0) - for cond1334 { - _t2134 := p.parse_snapshot_mapping() - item1335 := _t2134 - xs1333 = append(xs1333, item1335) - cond1334 = p.matchLookaheadLiteral("[", 0) - } - snapshot_mappings1336 := xs1333 + _t2130 := p.parse_edb_path() + edb_path1330 := _t2130 + xs1331 := []*pb.SnapshotMapping{} + cond1332 := p.matchLookaheadLiteral("[", 0) + for cond1332 { + _t2131 := p.parse_snapshot_mapping() + item1333 := _t2131 + xs1331 = append(xs1331, item1333) + cond1332 = p.matchLookaheadLiteral("[", 0) + } + snapshot_mappings1334 := xs1331 p.consumeLiteral(")") - _t2135 := &pb.Snapshot{Prefix: edb_path1332, Mappings: snapshot_mappings1336} - result1338 := _t2135 - p.recordSpan(int(span_start1337), "Snapshot") - return result1338 + _t2132 := &pb.Snapshot{Prefix: edb_path1330, Mappings: snapshot_mappings1334} + result1336 := _t2132 + p.recordSpan(int(span_start1335), "Snapshot") + return result1336 } func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { - span_start1341 := int64(p.spanStart()) - _t2136 := p.parse_edb_path() - edb_path1339 := _t2136 - _t2137 := p.parse_relation_id() - relation_id1340 := _t2137 - _t2138 := &pb.SnapshotMapping{DestinationPath: edb_path1339, SourceRelation: relation_id1340} - result1342 := _t2138 - p.recordSpan(int(span_start1341), "SnapshotMapping") - return result1342 + span_start1339 := int64(p.spanStart()) + _t2133 := p.parse_edb_path() + edb_path1337 := _t2133 + _t2134 := p.parse_relation_id() + relation_id1338 := _t2134 + _t2135 := &pb.SnapshotMapping{DestinationPath: edb_path1337, SourceRelation: relation_id1338} + result1340 := _t2135 + p.recordSpan(int(span_start1339), "SnapshotMapping") + return result1340 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs1343 := []*pb.Read{} - cond1344 := p.matchLookaheadLiteral("(", 0) - for cond1344 { - _t2139 := p.parse_read() - item1345 := _t2139 - xs1343 = append(xs1343, item1345) - cond1344 = p.matchLookaheadLiteral("(", 0) - } - reads1346 := xs1343 + xs1341 := []*pb.Read{} + cond1342 := p.matchLookaheadLiteral("(", 0) + for cond1342 { + _t2136 := p.parse_read() + item1343 := _t2136 + xs1341 = append(xs1341, item1343) + cond1342 = p.matchLookaheadLiteral("(", 0) + } + reads1344 := xs1341 p.consumeLiteral(")") - return reads1346 + return reads1344 } func (p *Parser) parse_read() *pb.Read { - span_start1353 := int64(p.spanStart()) - var _t2140 int64 + span_start1351 := int64(p.spanStart()) + var _t2137 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2141 int64 + var _t2138 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t2141 = 2 + _t2138 = 2 } else { - var _t2142 int64 + var _t2139 int64 if p.matchLookaheadLiteral("output", 1) { - _t2142 = 1 + _t2139 = 1 } else { - var _t2143 int64 + var _t2140 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2143 = 4 + _t2140 = 4 } else { - var _t2144 int64 + var _t2141 int64 if p.matchLookaheadLiteral("export", 1) { - _t2144 = 4 + _t2141 = 4 } else { - var _t2145 int64 + var _t2142 int64 if p.matchLookaheadLiteral("demand", 1) { - _t2145 = 0 + _t2142 = 0 } else { - var _t2146 int64 + var _t2143 int64 if p.matchLookaheadLiteral("abort", 1) { - _t2146 = 3 + _t2143 = 3 } else { - _t2146 = -1 + _t2143 = -1 } - _t2145 = _t2146 + _t2142 = _t2143 } - _t2144 = _t2145 + _t2141 = _t2142 } - _t2143 = _t2144 + _t2140 = _t2141 } - _t2142 = _t2143 + _t2139 = _t2140 } - _t2141 = _t2142 + _t2138 = _t2139 } - _t2140 = _t2141 + _t2137 = _t2138 } else { - _t2140 = -1 - } - prediction1347 := _t2140 - var _t2147 *pb.Read - if prediction1347 == 4 { - _t2148 := p.parse_export() - export1352 := _t2148 - _t2149 := &pb.Read{} - _t2149.ReadType = &pb.Read_Export{Export: export1352} - _t2147 = _t2149 + _t2137 = -1 + } + prediction1345 := _t2137 + var _t2144 *pb.Read + if prediction1345 == 4 { + _t2145 := p.parse_export() + export1350 := _t2145 + _t2146 := &pb.Read{} + _t2146.ReadType = &pb.Read_Export{Export: export1350} + _t2144 = _t2146 } else { - var _t2150 *pb.Read - if prediction1347 == 3 { - _t2151 := p.parse_abort() - abort1351 := _t2151 - _t2152 := &pb.Read{} - _t2152.ReadType = &pb.Read_Abort{Abort: abort1351} - _t2150 = _t2152 + var _t2147 *pb.Read + if prediction1345 == 3 { + _t2148 := p.parse_abort() + abort1349 := _t2148 + _t2149 := &pb.Read{} + _t2149.ReadType = &pb.Read_Abort{Abort: abort1349} + _t2147 = _t2149 } else { - var _t2153 *pb.Read - if prediction1347 == 2 { - _t2154 := p.parse_what_if() - what_if1350 := _t2154 - _t2155 := &pb.Read{} - _t2155.ReadType = &pb.Read_WhatIf{WhatIf: what_if1350} - _t2153 = _t2155 + var _t2150 *pb.Read + if prediction1345 == 2 { + _t2151 := p.parse_what_if() + what_if1348 := _t2151 + _t2152 := &pb.Read{} + _t2152.ReadType = &pb.Read_WhatIf{WhatIf: what_if1348} + _t2150 = _t2152 } else { - var _t2156 *pb.Read - if prediction1347 == 1 { - _t2157 := p.parse_output() - output1349 := _t2157 - _t2158 := &pb.Read{} - _t2158.ReadType = &pb.Read_Output{Output: output1349} - _t2156 = _t2158 + var _t2153 *pb.Read + if prediction1345 == 1 { + _t2154 := p.parse_output() + output1347 := _t2154 + _t2155 := &pb.Read{} + _t2155.ReadType = &pb.Read_Output{Output: output1347} + _t2153 = _t2155 } else { - var _t2159 *pb.Read - if prediction1347 == 0 { - _t2160 := p.parse_demand() - demand1348 := _t2160 - _t2161 := &pb.Read{} - _t2161.ReadType = &pb.Read_Demand{Demand: demand1348} - _t2159 = _t2161 + var _t2156 *pb.Read + if prediction1345 == 0 { + _t2157 := p.parse_demand() + demand1346 := _t2157 + _t2158 := &pb.Read{} + _t2158.ReadType = &pb.Read_Demand{Demand: demand1346} + _t2156 = _t2158 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2156 = _t2159 + _t2153 = _t2156 } - _t2153 = _t2156 + _t2150 = _t2153 } - _t2150 = _t2153 + _t2147 = _t2150 } - _t2147 = _t2150 + _t2144 = _t2147 } - result1354 := _t2147 - p.recordSpan(int(span_start1353), "Read") - return result1354 + result1352 := _t2144 + p.recordSpan(int(span_start1351), "Read") + return result1352 } func (p *Parser) parse_demand() *pb.Demand { - span_start1356 := int64(p.spanStart()) + span_start1354 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("demand") - _t2162 := p.parse_relation_id() - relation_id1355 := _t2162 + _t2159 := p.parse_relation_id() + relation_id1353 := _t2159 p.consumeLiteral(")") - _t2163 := &pb.Demand{RelationId: relation_id1355} - result1357 := _t2163 - p.recordSpan(int(span_start1356), "Demand") - return result1357 + _t2160 := &pb.Demand{RelationId: relation_id1353} + result1355 := _t2160 + p.recordSpan(int(span_start1354), "Demand") + return result1355 } func (p *Parser) parse_output() *pb.Output { - span_start1360 := int64(p.spanStart()) + span_start1358 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("output") - _t2164 := p.parse_name() - name1358 := _t2164 - _t2165 := p.parse_relation_id() - relation_id1359 := _t2165 + _t2161 := p.parse_name() + name1356 := _t2161 + _t2162 := p.parse_relation_id() + relation_id1357 := _t2162 p.consumeLiteral(")") - _t2166 := &pb.Output{Name: name1358, RelationId: relation_id1359} - result1361 := _t2166 - p.recordSpan(int(span_start1360), "Output") - return result1361 + _t2163 := &pb.Output{Name: name1356, RelationId: relation_id1357} + result1359 := _t2163 + p.recordSpan(int(span_start1358), "Output") + return result1359 } func (p *Parser) parse_what_if() *pb.WhatIf { - span_start1364 := int64(p.spanStart()) + span_start1362 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("what_if") - _t2167 := p.parse_name() - name1362 := _t2167 - _t2168 := p.parse_epoch() - epoch1363 := _t2168 + _t2164 := p.parse_name() + name1360 := _t2164 + _t2165 := p.parse_epoch() + epoch1361 := _t2165 p.consumeLiteral(")") - _t2169 := &pb.WhatIf{Branch: name1362, Epoch: epoch1363} - result1365 := _t2169 - p.recordSpan(int(span_start1364), "WhatIf") - return result1365 + _t2166 := &pb.WhatIf{Branch: name1360, Epoch: epoch1361} + result1363 := _t2166 + p.recordSpan(int(span_start1362), "WhatIf") + return result1363 } func (p *Parser) parse_abort() *pb.Abort { - span_start1368 := int64(p.spanStart()) + span_start1366 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("abort") - var _t2170 *string + var _t2167 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2171 := p.parse_name() - _t2170 = ptr(_t2171) + _t2168 := p.parse_name() + _t2167 = ptr(_t2168) } - name1366 := _t2170 - _t2172 := p.parse_relation_id() - relation_id1367 := _t2172 + name1364 := _t2167 + _t2169 := p.parse_relation_id() + relation_id1365 := _t2169 p.consumeLiteral(")") - _t2173 := &pb.Abort{Name: deref(name1366, "abort"), RelationId: relation_id1367} - result1369 := _t2173 - p.recordSpan(int(span_start1368), "Abort") - return result1369 + _t2170 := &pb.Abort{Name: deref(name1364, "abort"), RelationId: relation_id1365} + result1367 := _t2170 + p.recordSpan(int(span_start1366), "Abort") + return result1367 } func (p *Parser) parse_export() *pb.Export { - span_start1373 := int64(p.spanStart()) - var _t2174 int64 + span_start1371 := int64(p.spanStart()) + var _t2171 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2175 int64 + var _t2172 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2175 = 1 + _t2172 = 1 } else { - var _t2176 int64 + var _t2173 int64 if p.matchLookaheadLiteral("export", 1) { - _t2176 = 0 + _t2173 = 0 } else { - _t2176 = -1 + _t2173 = -1 } - _t2175 = _t2176 + _t2172 = _t2173 } - _t2174 = _t2175 + _t2171 = _t2172 } else { - _t2174 = -1 + _t2171 = -1 } - prediction1370 := _t2174 - var _t2177 *pb.Export - if prediction1370 == 1 { + prediction1368 := _t2171 + var _t2174 *pb.Export + if prediction1368 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_iceberg") - _t2178 := p.parse_export_iceberg_config() - export_iceberg_config1372 := _t2178 + _t2175 := p.parse_export_iceberg_config() + export_iceberg_config1370 := _t2175 p.consumeLiteral(")") - _t2179 := &pb.Export{} - _t2179.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1372} - _t2177 = _t2179 + _t2176 := &pb.Export{} + _t2176.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1370} + _t2174 = _t2176 } else { - var _t2180 *pb.Export - if prediction1370 == 0 { + var _t2177 *pb.Export + if prediction1368 == 0 { p.consumeLiteral("(") p.consumeLiteral("export") - _t2181 := p.parse_export_csv_config() - export_csv_config1371 := _t2181 + _t2178 := p.parse_export_csv_config() + export_csv_config1369 := _t2178 p.consumeLiteral(")") - _t2182 := &pb.Export{} - _t2182.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1371} - _t2180 = _t2182 + _t2179 := &pb.Export{} + _t2179.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1369} + _t2177 = _t2179 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2177 = _t2180 + _t2174 = _t2177 } - result1374 := _t2177 - p.recordSpan(int(span_start1373), "Export") - return result1374 + result1372 := _t2174 + p.recordSpan(int(span_start1371), "Export") + return result1372 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1382 := int64(p.spanStart()) - var _t2183 int64 + span_start1380 := int64(p.spanStart()) + var _t2180 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2184 int64 + var _t2181 int64 if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2184 = 0 + _t2181 = 0 } else { - var _t2185 int64 + var _t2182 int64 if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2185 = 1 + _t2182 = 1 } else { - _t2185 = -1 + _t2182 = -1 } - _t2184 = _t2185 + _t2181 = _t2182 } - _t2183 = _t2184 + _t2180 = _t2181 } else { - _t2183 = -1 + _t2180 = -1 } - prediction1375 := _t2183 - var _t2186 *pb.ExportCSVConfig - if prediction1375 == 1 { + prediction1373 := _t2180 + var _t2183 *pb.ExportCSVConfig + if prediction1373 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t2187 := p.parse_export_csv_path() - export_csv_path1379 := _t2187 - _t2188 := p.parse_export_csv_columns_list() - export_csv_columns_list1380 := _t2188 - _t2189 := p.parse_config_dict() - config_dict1381 := _t2189 + _t2184 := p.parse_export_csv_path() + export_csv_path1377 := _t2184 + _t2185 := p.parse_export_csv_columns_list() + export_csv_columns_list1378 := _t2185 + _t2186 := p.parse_config_dict() + config_dict1379 := _t2186 p.consumeLiteral(")") - _t2190 := p.construct_export_csv_config(export_csv_path1379, export_csv_columns_list1380, config_dict1381) - _t2186 = _t2190 + _t2187 := p.construct_export_csv_config(export_csv_path1377, export_csv_columns_list1378, config_dict1379) + _t2183 = _t2187 } else { - var _t2191 *pb.ExportCSVConfig - if prediction1375 == 0 { + var _t2188 *pb.ExportCSVConfig + if prediction1373 == 0 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config_v2") - _t2192 := p.parse_export_csv_output_location() - export_csv_output_location1376 := _t2192 - _t2193 := p.parse_export_csv_source() - export_csv_source1377 := _t2193 - _t2194 := p.parse_csv_config() - csv_config1378 := _t2194 + _t2189 := p.parse_export_csv_output_location() + export_csv_output_location1374 := _t2189 + _t2190 := p.parse_export_csv_source() + export_csv_source1375 := _t2190 + _t2191 := p.parse_csv_config() + csv_config1376 := _t2191 p.consumeLiteral(")") - _t2195 := p.construct_export_csv_config_with_location(export_csv_output_location1376, export_csv_source1377, csv_config1378) - _t2191 = _t2195 + _t2192 := p.construct_export_csv_config_with_location(export_csv_output_location1374, export_csv_source1375, csv_config1376) + _t2188 = _t2192 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_config", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2186 = _t2191 + _t2183 = _t2188 } - result1383 := _t2186 - p.recordSpan(int(span_start1382), "ExportCSVConfig") - return result1383 + result1381 := _t2183 + p.recordSpan(int(span_start1380), "ExportCSVConfig") + return result1381 } func (p *Parser) parse_export_csv_output_location() []interface{} { - var _t2196 int64 + var _t2193 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2197 int64 + var _t2194 int64 if p.matchLookaheadLiteral("transaction_output_name", 1) { - _t2197 = 1 + _t2194 = 1 } else { - var _t2198 int64 + var _t2195 int64 if p.matchLookaheadLiteral("path", 1) { - _t2198 = 0 + _t2195 = 0 } else { - _t2198 = -1 + _t2195 = -1 } - _t2197 = _t2198 + _t2194 = _t2195 } - _t2196 = _t2197 + _t2193 = _t2194 } else { - _t2196 = -1 + _t2193 = -1 } - prediction1384 := _t2196 - var _t2199 []interface{} - if prediction1384 == 1 { + prediction1382 := _t2193 + var _t2196 []interface{} + if prediction1382 == 1 { p.consumeLiteral("(") p.consumeLiteral("transaction_output_name") - _t2200 := p.parse_name() - name1386 := _t2200 + _t2197 := p.parse_name() + name1384 := _t2197 p.consumeLiteral(")") - _t2199 = []interface{}{"", name1386} + _t2196 = []interface{}{"", name1384} } else { - var _t2201 []interface{} - if prediction1384 == 0 { + var _t2198 []interface{} + if prediction1382 == 0 { p.consumeLiteral("(") p.consumeLiteral("path") - string1385 := p.consumeTerminal("STRING").Value.str + string1383 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - _t2201 = []interface{}{string1385, ""} + _t2198 = []interface{}{string1383, ""} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_output_location", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2199 = _t2201 + _t2196 = _t2198 } - return _t2199 + return _t2196 } func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1393 := int64(p.spanStart()) - var _t2202 int64 + span_start1391 := int64(p.spanStart()) + var _t2199 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2203 int64 + var _t2200 int64 if p.matchLookaheadLiteral("table_def", 1) { - _t2203 = 1 + _t2200 = 1 } else { - var _t2204 int64 + var _t2201 int64 if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2204 = 0 + _t2201 = 0 } else { - _t2204 = -1 + _t2201 = -1 } - _t2203 = _t2204 + _t2200 = _t2201 } - _t2202 = _t2203 + _t2199 = _t2200 } else { - _t2202 = -1 + _t2199 = -1 } - prediction1387 := _t2202 - var _t2205 *pb.ExportCSVSource - if prediction1387 == 1 { + prediction1385 := _t2199 + var _t2202 *pb.ExportCSVSource + if prediction1385 == 1 { p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2206 := p.parse_relation_id() - relation_id1392 := _t2206 + _t2203 := p.parse_relation_id() + relation_id1390 := _t2203 p.consumeLiteral(")") - _t2207 := &pb.ExportCSVSource{} - _t2207.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1392} - _t2205 = _t2207 + _t2204 := &pb.ExportCSVSource{} + _t2204.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1390} + _t2202 = _t2204 } else { - var _t2208 *pb.ExportCSVSource - if prediction1387 == 0 { + var _t2205 *pb.ExportCSVSource + if prediction1385 == 0 { p.consumeLiteral("(") p.consumeLiteral("gnf_columns") - xs1388 := []*pb.ExportCSVColumn{} - cond1389 := p.matchLookaheadLiteral("(", 0) - for cond1389 { - _t2209 := p.parse_export_csv_column() - item1390 := _t2209 - xs1388 = append(xs1388, item1390) - cond1389 = p.matchLookaheadLiteral("(", 0) + xs1386 := []*pb.ExportCSVColumn{} + cond1387 := p.matchLookaheadLiteral("(", 0) + for cond1387 { + _t2206 := p.parse_export_csv_column() + item1388 := _t2206 + xs1386 = append(xs1386, item1388) + cond1387 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns1391 := xs1388 + export_csv_columns1389 := xs1386 p.consumeLiteral(")") - _t2210 := &pb.ExportCSVColumns{Columns: export_csv_columns1391} - _t2211 := &pb.ExportCSVSource{} - _t2211.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2210} - _t2208 = _t2211 + _t2207 := &pb.ExportCSVColumns{Columns: export_csv_columns1389} + _t2208 := &pb.ExportCSVSource{} + _t2208.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2207} + _t2205 = _t2208 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_source", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2205 = _t2208 + _t2202 = _t2205 } - result1394 := _t2205 - p.recordSpan(int(span_start1393), "ExportCSVSource") - return result1394 + result1392 := _t2202 + p.recordSpan(int(span_start1391), "ExportCSVSource") + return result1392 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1397 := int64(p.spanStart()) + span_start1395 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1395 := p.consumeTerminal("STRING").Value.str - _t2212 := p.parse_relation_id() - relation_id1396 := _t2212 + string1393 := p.consumeTerminal("STRING").Value.str + _t2209 := p.parse_relation_id() + relation_id1394 := _t2209 p.consumeLiteral(")") - _t2213 := &pb.ExportCSVColumn{ColumnName: string1395, ColumnData: relation_id1396} - result1398 := _t2213 - p.recordSpan(int(span_start1397), "ExportCSVColumn") - return result1398 + _t2210 := &pb.ExportCSVColumn{ColumnName: string1393, ColumnData: relation_id1394} + result1396 := _t2210 + p.recordSpan(int(span_start1395), "ExportCSVColumn") + return result1396 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") - string1399 := p.consumeTerminal("STRING").Value.str + string1397 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1399 + return string1397 } func (p *Parser) parse_export_csv_columns_list() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1400 := []*pb.ExportCSVColumn{} - cond1401 := p.matchLookaheadLiteral("(", 0) - for cond1401 { - _t2214 := p.parse_export_csv_column() - item1402 := _t2214 - xs1400 = append(xs1400, item1402) - cond1401 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1403 := xs1400 + xs1398 := []*pb.ExportCSVColumn{} + cond1399 := p.matchLookaheadLiteral("(", 0) + for cond1399 { + _t2211 := p.parse_export_csv_column() + item1400 := _t2211 + xs1398 = append(xs1398, item1400) + cond1399 = p.matchLookaheadLiteral("(", 0) + } + export_csv_columns1401 := xs1398 p.consumeLiteral(")") - return export_csv_columns1403 + return export_csv_columns1401 } func (p *Parser) parse_export_iceberg_config() *pb.ExportIcebergConfig { - span_start1409 := int64(p.spanStart()) + span_start1407 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("export_iceberg_config") - _t2215 := p.parse_iceberg_locator() - iceberg_locator1404 := _t2215 - _t2216 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1405 := _t2216 - _t2217 := p.parse_export_iceberg_table_def() - export_iceberg_table_def1406 := _t2217 - _t2218 := p.parse_iceberg_table_properties() - iceberg_table_properties1407 := _t2218 - var _t2219 [][]interface{} + _t2212 := p.parse_iceberg_locator() + iceberg_locator1402 := _t2212 + _t2213 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1403 := _t2213 + _t2214 := p.parse_export_iceberg_table_def() + export_iceberg_table_def1404 := _t2214 + _t2215 := p.parse_iceberg_table_properties() + iceberg_table_properties1405 := _t2215 + var _t2216 [][]interface{} if p.matchLookaheadLiteral("{", 0) { - _t2220 := p.parse_config_dict() - _t2219 = _t2220 + _t2217 := p.parse_config_dict() + _t2216 = _t2217 } - config_dict1408 := _t2219 + config_dict1406 := _t2216 p.consumeLiteral(")") - _t2221 := p.construct_export_iceberg_config_full(iceberg_locator1404, iceberg_catalog_config1405, export_iceberg_table_def1406, iceberg_table_properties1407, config_dict1408) - result1410 := _t2221 - p.recordSpan(int(span_start1409), "ExportIcebergConfig") - return result1410 + _t2218 := p.construct_export_iceberg_config_full(iceberg_locator1402, iceberg_catalog_config1403, export_iceberg_table_def1404, iceberg_table_properties1405, config_dict1406) + result1408 := _t2218 + p.recordSpan(int(span_start1407), "ExportIcebergConfig") + return result1408 } func (p *Parser) parse_export_iceberg_table_def() *pb.RelationId { - span_start1412 := int64(p.spanStart()) + span_start1410 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2222 := p.parse_relation_id() - relation_id1411 := _t2222 + _t2219 := p.parse_relation_id() + relation_id1409 := _t2219 p.consumeLiteral(")") - result1413 := relation_id1411 - p.recordSpan(int(span_start1412), "RelationId") - return result1413 + result1411 := relation_id1409 + p.recordSpan(int(span_start1410), "RelationId") + return result1411 } func (p *Parser) parse_iceberg_table_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("table_properties") - xs1414 := [][]interface{}{} - cond1415 := p.matchLookaheadLiteral("(", 0) - for cond1415 { - _t2223 := p.parse_iceberg_property_entry() - item1416 := _t2223 - xs1414 = append(xs1414, item1416) - cond1415 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1417 := xs1414 + xs1412 := [][]interface{}{} + cond1413 := p.matchLookaheadLiteral("(", 0) + for cond1413 { + _t2220 := p.parse_iceberg_property_entry() + item1414 := _t2220 + xs1412 = append(xs1412, item1414) + cond1413 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1415 := xs1412 p.consumeLiteral(")") - return iceberg_property_entrys1417 + return iceberg_property_entrys1415 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index 8c9f8fd5..efc5bc90 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -4152,20 +4152,18 @@ func (p *PrettyPrinter) pretty_relation_keys(msg []interface{}) interface{} { p.write(")") } else { _dollar_dollar := msg - var _t1830 *string + var _t1830 []interface{} if _dollar_dollar[1].(bool) { - _t1830 = ptr("synthetic_key") + _t1830 = []interface{}{} } deconstruct_result1493 := _t1830 if deconstruct_result1493 != nil { - unwrapped1494 := *deconstruct_result1493 + unwrapped1494 := deconstruct_result1493 + _ = unwrapped1494 p.write("(") p.write("keys") - p.indentSexp() p.newline() - p.write(":") - p.write(unwrapped1494) - p.dedent() + p.write("synthetic") p.write(")") } else { panic(ParseError{msg: "No matching rule for relation_keys"}) diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index a7450ae6..fdc700bc 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -372,12 +372,12 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V if isnothing(value) return Int32(default) else - _t2211 = nothing + _t2208 = nothing end if _has_proto_field(value, Symbol("int32_value")) return _get_oneof_field(value, :int32_value) else - _t2212 = nothing + _t2209 = nothing end throw(ParseError("expected an int32 value (e.g. `1i32`) for this config field")) end @@ -386,7 +386,7 @@ function _extract_value_int64(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2213 = nothing + _t2210 = nothing end return default end @@ -395,7 +395,7 @@ function _extract_value_string(parser::ParserState, value::Union{Nothing, Proto. if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return _get_oneof_field(value, :string_value) else - _t2214 = nothing + _t2211 = nothing end return default end @@ -404,7 +404,7 @@ function _extract_value_boolean(parser::ParserState, value::Union{Nothing, Proto if (!isnothing(value) && _has_proto_field(value, Symbol("boolean_value"))) return _get_oneof_field(value, :boolean_value) else - _t2215 = nothing + _t2212 = nothing end return default end @@ -413,7 +413,7 @@ function _extract_value_string_list(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return String[_get_oneof_field(value, :string_value)] else - _t2216 = nothing + _t2213 = nothing end return default end @@ -422,7 +422,7 @@ function _try_extract_value_int64(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("int_value"))) return _get_oneof_field(value, :int_value) else - _t2217 = nothing + _t2214 = nothing end return nothing end @@ -431,7 +431,7 @@ function _try_extract_value_float64(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("float_value"))) return _get_oneof_field(value, :float_value) else - _t2218 = nothing + _t2215 = nothing end return nothing end @@ -440,7 +440,7 @@ function _try_extract_value_bytes(parser::ParserState, value::Union{Nothing, Pro if (!isnothing(value) && _has_proto_field(value, Symbol("string_value"))) return Vector{UInt8}(_get_oneof_field(value, :string_value)) else - _t2219 = nothing + _t2216 = nothing end return nothing end @@ -449,127 +449,118 @@ function _try_extract_value_uint128(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("uint128_value"))) return _get_oneof_field(value, :uint128_value) else - _t2220 = nothing + _t2217 = nothing end return nothing end function construct_non_cdc_relations(parser::ParserState, targets::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2221 = Proto.PlainTargets(targets=targets) - _t2222 = Proto.TargetRelations(body=OneOf(:plain, _t2221), keys=Proto.NamedColumn[]) - return _t2222 + _t2218 = Proto.PlainTargets(targets=targets) + _t2219 = Proto.TargetRelations(body=OneOf(:plain, _t2218), keys=Proto.NamedColumn[]) + return _t2219 end function construct_cdc_relations(parser::ParserState, inserts::Vector{Proto.TargetRelation}, deletes::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2223 = Proto.CDCTargets(inserts=inserts, deletes=deletes) - _t2224 = Proto.TargetRelations(body=OneOf(:cdc, _t2223), keys=Proto.NamedColumn[]) - return _t2224 -end - -function construct_synthetic_keys(parser::ParserState, marker::String)::Tuple{Vector{Proto.NamedColumn}, Bool} - if marker != "synthetic_key" - throw(ParseError("expected the `:synthetic_key` marker in the relation keys clause")) - else - _t2225 = nothing - end - return (Proto.NamedColumn[], true,) + _t2220 = Proto.CDCTargets(inserts=inserts, deletes=deletes) + _t2221 = Proto.TargetRelations(body=OneOf(:cdc, _t2220), keys=Proto.NamedColumn[]) + return _t2221 end function construct_relations(parser::ParserState, keys::Tuple{Vector{Proto.NamedColumn}, Bool}, body::Proto.TargetRelations)::Proto.TargetRelations if _has_proto_field(body, Symbol("plain")) - _t2227 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys[1], synthetic_key=keys[2]) - return _t2227 + _t2223 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys[1], synthetic_key=keys[2]) + return _t2223 else - _t2226 = nothing + _t2222 = nothing end - _t2228 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys[1], synthetic_key=keys[2]) - return _t2228 + _t2224 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys[1], synthetic_key=keys[2]) + return _t2224 end function construct_csv_data(parser::ParserState, locator::Proto.CSVLocator, config::Proto.CSVConfig, columns_opt::Union{Nothing, Vector{Proto.GNFColumn}}, relations_opt::Union{Nothing, Proto.TargetRelations}, asof::String)::Proto.CSVData - _t2229 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) - return _t2229 + _t2225 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) + return _t2225 end function construct_csv_config(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}}, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.CSVConfig config = Dict(config_dict) - _t2230 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t2230 - _t2231 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t2231 - _t2232 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t2232 - _t2233 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t2233 - _t2234 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t2234 - _t2235 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t2235 - _t2236 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t2236 - _t2237 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t2237 - _t2238 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t2238 - _t2239 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t2239 - _t2240 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") - compression = _t2240 - _t2241 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) - partition_size_mb = _t2241 - _t2242 = construct_csv_storage_integration(parser, storage_integration_opt) - storage_integration = _t2242 - _t2243 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2243 + _t2226 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t2226 + _t2227 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t2227 + _t2228 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t2228 + _t2229 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t2229 + _t2230 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t2230 + _t2231 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t2231 + _t2232 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t2232 + _t2233 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t2233 + _t2234 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t2234 + _t2235 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t2235 + _t2236 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") + compression = _t2236 + _t2237 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) + partition_size_mb = _t2237 + _t2238 = construct_csv_storage_integration(parser, storage_integration_opt) + storage_integration = _t2238 + _t2239 = Proto.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) + return _t2239 end function construct_csv_storage_integration(parser::ParserState, storage_integration_opt::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Union{Nothing, Proto.StorageIntegration} if isnothing(storage_integration_opt) return nothing else - _t2244 = nothing + _t2240 = nothing end config = Dict(storage_integration_opt) - _t2245 = _extract_value_string(parser, get(config, "provider", nothing), "") - _t2246 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") - _t2247 = _extract_value_string(parser, get(config, "s3_region", nothing), "") - _t2248 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") - _t2249 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") - _t2250 = Proto.StorageIntegration(provider=_t2245, azure_sas_token=_t2246, s3_region=_t2247, s3_access_key_id=_t2248, s3_secret_access_key=_t2249) - return _t2250 + _t2241 = _extract_value_string(parser, get(config, "provider", nothing), "") + _t2242 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") + _t2243 = _extract_value_string(parser, get(config, "s3_region", nothing), "") + _t2244 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") + _t2245 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") + _t2246 = Proto.StorageIntegration(provider=_t2241, azure_sas_token=_t2242, s3_region=_t2243, s3_access_key_id=_t2244, s3_secret_access_key=_t2245) + return _t2246 end function construct_betree_info(parser::ParserState, key_types::Vector{Proto.var"#Type"}, value_types::Vector{Proto.var"#Type"}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.BeTreeInfo config = Dict(config_dict) - _t2251 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t2251 - _t2252 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t2252 - _t2253 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t2253 - _t2254 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t2254 - _t2255 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2255 - _t2256 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t2256 - _t2257 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t2257 - _t2258 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t2258 - _t2259 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t2259 - _t2260 = Proto.BeTreeLocator(location=(!isnothing(root_pageid) ? OneOf(:root_pageid, root_pageid) : (!isnothing(inline_data) ? OneOf(:inline_data, inline_data) : nothing)), element_count=element_count, tree_height=tree_height) - relation_locator = _t2260 - _t2261 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2261 + _t2247 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t2247 + _t2248 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t2248 + _t2249 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t2249 + _t2250 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t2250 + _t2251 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2251 + _t2252 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t2252 + _t2253 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t2253 + _t2254 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t2254 + _t2255 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t2255 + _t2256 = Proto.BeTreeLocator(location=(!isnothing(root_pageid) ? OneOf(:root_pageid, root_pageid) : (!isnothing(inline_data) ? OneOf(:inline_data, inline_data) : nothing)), element_count=element_count, tree_height=tree_height) + relation_locator = _t2256 + _t2257 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2257 end function default_configure(parser::ParserState)::Proto.Configure - _t2262 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2262 - _t2263 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2263 + _t2258 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2258 + _t2259 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2259 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -591,4101 +582,4099 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t2264 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t2264 - _t2265 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t2265 - _t2266 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2266 + _t2260 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t2260 + _t2261 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t2261 + _t2262 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2262 end function construct_export_csv_config(parser::ParserState, path::String, columns::Vector{Proto.ExportCSVColumn}, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.ExportCSVConfig config = Dict(config_dict) - _t2267 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t2267 - _t2268 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t2268 - _t2269 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t2269 - _t2270 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t2270 - _t2271 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t2271 - _t2272 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t2272 - _t2273 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t2273 - _t2274 = Proto.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) - return _t2274 + _t2263 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t2263 + _t2264 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t2264 + _t2265 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t2265 + _t2266 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t2266 + _t2267 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t2267 + _t2268 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t2268 + _t2269 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t2269 + _t2270 = Proto.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) + return _t2270 end function construct_export_csv_config_with_location(parser::ParserState, location::Tuple{String, String}, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig - _t2275 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) - return _t2275 + _t2271 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) + return _t2271 end function construct_iceberg_catalog_config(parser::ParserState, catalog_uri::String, scope_opt::Union{Nothing, String}, property_pairs::Vector{Tuple{String, String}}, auth_property_pairs::Vector{Tuple{String, String}})::Proto.IcebergCatalogConfig props = Dict(property_pairs) auth_props = Dict(auth_property_pairs) - _t2276 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) - return _t2276 + _t2272 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) + return _t2272 end function construct_iceberg_data(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, columns::Vector{Proto.GNFColumn}, from_snapshot_opt::Union{Nothing, String}, to_snapshot_opt::Union{Nothing, String}, returns_delta::Bool)::Proto.IcebergData - _t2277 = Proto.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(!isnothing(from_snapshot_opt) ? from_snapshot_opt : ""), to_snapshot=(!isnothing(to_snapshot_opt) ? to_snapshot_opt : ""), returns_delta=returns_delta) - return _t2277 + _t2273 = Proto.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(!isnothing(from_snapshot_opt) ? from_snapshot_opt : ""), to_snapshot=(!isnothing(to_snapshot_opt) ? to_snapshot_opt : ""), returns_delta=returns_delta) + return _t2273 end function construct_export_iceberg_config_full(parser::ParserState, locator::Proto.IcebergLocator, config::Proto.IcebergCatalogConfig, table_def::Proto.RelationId, table_property_pairs::Vector{Tuple{String, String}}, config_dict::Union{Nothing, Vector{Tuple{String, Proto.Value}}})::Proto.ExportIcebergConfig cfg = Dict((!isnothing(config_dict) ? config_dict : Tuple{String, Proto.Value}[])) - _t2278 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") - prefix = _t2278 - _t2279 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) - target_file_size_bytes = _t2279 - _t2280 = _extract_value_string(parser, get(cfg, "compression", nothing), "") - compression = _t2280 + _t2274 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") + prefix = _t2274 + _t2275 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) + target_file_size_bytes = _t2275 + _t2276 = _extract_value_string(parser, get(cfg, "compression", nothing), "") + compression = _t2276 table_props = Dict(table_property_pairs) - _t2281 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2281 + _t2277 = Proto.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2277 end # --- Parse functions --- function parse_transaction(parser::ParserState)::Proto.Transaction - span_start715 = span_start(parser) + span_start714 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t1419 = parse_configure(parser) - _t1418 = _t1419 + _t1417 = parse_configure(parser) + _t1416 = _t1417 else - _t1418 = nothing + _t1416 = nothing end - configure709 = _t1418 + configure708 = _t1416 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t1421 = parse_sync(parser) - _t1420 = _t1421 + _t1419 = parse_sync(parser) + _t1418 = _t1419 else - _t1420 = nothing - end - sync710 = _t1420 - xs711 = Proto.Epoch[] - cond712 = match_lookahead_literal(parser, "(", 0) - while cond712 - _t1422 = parse_epoch(parser) - item713 = _t1422 - push!(xs711, item713) - cond712 = match_lookahead_literal(parser, "(", 0) - end - epochs714 = xs711 + _t1418 = nothing + end + sync709 = _t1418 + xs710 = Proto.Epoch[] + cond711 = match_lookahead_literal(parser, "(", 0) + while cond711 + _t1420 = parse_epoch(parser) + item712 = _t1420 + push!(xs710, item712) + cond711 = match_lookahead_literal(parser, "(", 0) + end + epochs713 = xs710 consume_literal!(parser, ")") - _t1423 = default_configure(parser) - _t1424 = Proto.Transaction(epochs=epochs714, configure=(!isnothing(configure709) ? configure709 : _t1423), sync=sync710) - result716 = _t1424 - record_span!(parser, span_start715, "Transaction") - return result716 + _t1421 = default_configure(parser) + _t1422 = Proto.Transaction(epochs=epochs713, configure=(!isnothing(configure708) ? configure708 : _t1421), sync=sync709) + result715 = _t1422 + record_span!(parser, span_start714, "Transaction") + return result715 end function parse_configure(parser::ParserState)::Proto.Configure - span_start718 = span_start(parser) + span_start717 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t1425 = parse_config_dict(parser) - config_dict717 = _t1425 + _t1423 = parse_config_dict(parser) + config_dict716 = _t1423 consume_literal!(parser, ")") - _t1426 = construct_configure(parser, config_dict717) - result719 = _t1426 - record_span!(parser, span_start718, "Configure") - return result719 + _t1424 = construct_configure(parser, config_dict716) + result718 = _t1424 + record_span!(parser, span_start717, "Configure") + return result718 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs720 = Tuple{String, Proto.Value}[] - cond721 = match_lookahead_literal(parser, ":", 0) - while cond721 - _t1427 = parse_config_key_value(parser) - item722 = _t1427 - push!(xs720, item722) - cond721 = match_lookahead_literal(parser, ":", 0) - end - config_key_values723 = xs720 + xs719 = Tuple{String, Proto.Value}[] + cond720 = match_lookahead_literal(parser, ":", 0) + while cond720 + _t1425 = parse_config_key_value(parser) + item721 = _t1425 + push!(xs719, item721) + cond720 = match_lookahead_literal(parser, ":", 0) + end + config_key_values722 = xs719 consume_literal!(parser, "}") - return config_key_values723 + return config_key_values722 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol724 = consume_terminal!(parser, "SYMBOL") - _t1428 = parse_raw_value(parser) - raw_value725 = _t1428 - return (symbol724, raw_value725,) + symbol723 = consume_terminal!(parser, "SYMBOL") + _t1426 = parse_raw_value(parser) + raw_value724 = _t1426 + return (symbol723, raw_value724,) end function parse_raw_value(parser::ParserState)::Proto.Value - span_start739 = span_start(parser) + span_start738 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1429 = 12 + _t1427 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1430 = 11 + _t1428 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1431 = 12 + _t1429 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1433 = 1 + _t1431 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1434 = 0 + _t1432 = 0 else - _t1434 = -1 + _t1432 = -1 end - _t1433 = _t1434 + _t1431 = _t1432 end - _t1432 = _t1433 + _t1430 = _t1431 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1435 = 7 + _t1433 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1436 = 8 + _t1434 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1437 = 2 + _t1435 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1438 = 3 + _t1436 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1439 = 9 + _t1437 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1440 = 4 + _t1438 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1441 = 5 + _t1439 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1442 = 6 + _t1440 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1443 = 10 + _t1441 = 10 else - _t1443 = -1 + _t1441 = -1 end - _t1442 = _t1443 + _t1440 = _t1441 end - _t1441 = _t1442 + _t1439 = _t1440 end - _t1440 = _t1441 + _t1438 = _t1439 end - _t1439 = _t1440 + _t1437 = _t1438 end - _t1438 = _t1439 + _t1436 = _t1437 end - _t1437 = _t1438 + _t1435 = _t1436 end - _t1436 = _t1437 + _t1434 = _t1435 end - _t1435 = _t1436 + _t1433 = _t1434 end - _t1432 = _t1435 + _t1430 = _t1433 end - _t1431 = _t1432 + _t1429 = _t1430 end - _t1430 = _t1431 + _t1428 = _t1429 end - _t1429 = _t1430 - end - prediction726 = _t1429 - if prediction726 == 12 - _t1445 = parse_boolean_value(parser) - boolean_value738 = _t1445 - _t1446 = Proto.Value(value=OneOf(:boolean_value, boolean_value738)) - _t1444 = _t1446 + _t1427 = _t1428 + end + prediction725 = _t1427 + if prediction725 == 12 + _t1443 = parse_boolean_value(parser) + boolean_value737 = _t1443 + _t1444 = Proto.Value(value=OneOf(:boolean_value, boolean_value737)) + _t1442 = _t1444 else - if prediction726 == 11 + if prediction725 == 11 consume_literal!(parser, "missing") - _t1448 = Proto.MissingValue() - _t1449 = Proto.Value(value=OneOf(:missing_value, _t1448)) - _t1447 = _t1449 + _t1446 = Proto.MissingValue() + _t1447 = Proto.Value(value=OneOf(:missing_value, _t1446)) + _t1445 = _t1447 else - if prediction726 == 10 - decimal737 = consume_terminal!(parser, "DECIMAL") - _t1451 = Proto.Value(value=OneOf(:decimal_value, decimal737)) - _t1450 = _t1451 + if prediction725 == 10 + decimal736 = consume_terminal!(parser, "DECIMAL") + _t1449 = Proto.Value(value=OneOf(:decimal_value, decimal736)) + _t1448 = _t1449 else - if prediction726 == 9 - int128736 = consume_terminal!(parser, "INT128") - _t1453 = Proto.Value(value=OneOf(:int128_value, int128736)) - _t1452 = _t1453 + if prediction725 == 9 + int128735 = consume_terminal!(parser, "INT128") + _t1451 = Proto.Value(value=OneOf(:int128_value, int128735)) + _t1450 = _t1451 else - if prediction726 == 8 - uint128735 = consume_terminal!(parser, "UINT128") - _t1455 = Proto.Value(value=OneOf(:uint128_value, uint128735)) - _t1454 = _t1455 + if prediction725 == 8 + uint128734 = consume_terminal!(parser, "UINT128") + _t1453 = Proto.Value(value=OneOf(:uint128_value, uint128734)) + _t1452 = _t1453 else - if prediction726 == 7 - uint32734 = consume_terminal!(parser, "UINT32") - _t1457 = Proto.Value(value=OneOf(:uint32_value, uint32734)) - _t1456 = _t1457 + if prediction725 == 7 + uint32733 = consume_terminal!(parser, "UINT32") + _t1455 = Proto.Value(value=OneOf(:uint32_value, uint32733)) + _t1454 = _t1455 else - if prediction726 == 6 - float733 = consume_terminal!(parser, "FLOAT") - _t1459 = Proto.Value(value=OneOf(:float_value, float733)) - _t1458 = _t1459 + if prediction725 == 6 + float732 = consume_terminal!(parser, "FLOAT") + _t1457 = Proto.Value(value=OneOf(:float_value, float732)) + _t1456 = _t1457 else - if prediction726 == 5 - float32732 = consume_terminal!(parser, "FLOAT32") - _t1461 = Proto.Value(value=OneOf(:float32_value, float32732)) - _t1460 = _t1461 + if prediction725 == 5 + float32731 = consume_terminal!(parser, "FLOAT32") + _t1459 = Proto.Value(value=OneOf(:float32_value, float32731)) + _t1458 = _t1459 else - if prediction726 == 4 - int731 = consume_terminal!(parser, "INT") - _t1463 = Proto.Value(value=OneOf(:int_value, int731)) - _t1462 = _t1463 + if prediction725 == 4 + int730 = consume_terminal!(parser, "INT") + _t1461 = Proto.Value(value=OneOf(:int_value, int730)) + _t1460 = _t1461 else - if prediction726 == 3 - int32730 = consume_terminal!(parser, "INT32") - _t1465 = Proto.Value(value=OneOf(:int32_value, int32730)) - _t1464 = _t1465 + if prediction725 == 3 + int32729 = consume_terminal!(parser, "INT32") + _t1463 = Proto.Value(value=OneOf(:int32_value, int32729)) + _t1462 = _t1463 else - if prediction726 == 2 - string729 = consume_terminal!(parser, "STRING") - _t1467 = Proto.Value(value=OneOf(:string_value, string729)) - _t1466 = _t1467 + if prediction725 == 2 + string728 = consume_terminal!(parser, "STRING") + _t1465 = Proto.Value(value=OneOf(:string_value, string728)) + _t1464 = _t1465 else - if prediction726 == 1 - _t1469 = parse_raw_datetime(parser) - raw_datetime728 = _t1469 - _t1470 = Proto.Value(value=OneOf(:datetime_value, raw_datetime728)) - _t1468 = _t1470 + if prediction725 == 1 + _t1467 = parse_raw_datetime(parser) + raw_datetime727 = _t1467 + _t1468 = Proto.Value(value=OneOf(:datetime_value, raw_datetime727)) + _t1466 = _t1468 else - if prediction726 == 0 - _t1472 = parse_raw_date(parser) - raw_date727 = _t1472 - _t1473 = Proto.Value(value=OneOf(:date_value, raw_date727)) - _t1471 = _t1473 + if prediction725 == 0 + _t1470 = parse_raw_date(parser) + raw_date726 = _t1470 + _t1471 = Proto.Value(value=OneOf(:date_value, raw_date726)) + _t1469 = _t1471 else throw(ParseError("Unexpected token in raw_value" * ": " * string(lookahead(parser, 0)))) end - _t1468 = _t1471 + _t1466 = _t1469 end - _t1466 = _t1468 + _t1464 = _t1466 end - _t1464 = _t1466 + _t1462 = _t1464 end - _t1462 = _t1464 + _t1460 = _t1462 end - _t1460 = _t1462 + _t1458 = _t1460 end - _t1458 = _t1460 + _t1456 = _t1458 end - _t1456 = _t1458 + _t1454 = _t1456 end - _t1454 = _t1456 + _t1452 = _t1454 end - _t1452 = _t1454 + _t1450 = _t1452 end - _t1450 = _t1452 + _t1448 = _t1450 end - _t1447 = _t1450 + _t1445 = _t1448 end - _t1444 = _t1447 + _t1442 = _t1445 end - result740 = _t1444 - record_span!(parser, span_start739, "Value") - return result740 + result739 = _t1442 + record_span!(parser, span_start738, "Value") + return result739 end function parse_raw_date(parser::ParserState)::Proto.DateValue - span_start744 = span_start(parser) + span_start743 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - int741 = consume_terminal!(parser, "INT") - int_3742 = consume_terminal!(parser, "INT") - int_4743 = consume_terminal!(parser, "INT") + int740 = consume_terminal!(parser, "INT") + int_3741 = consume_terminal!(parser, "INT") + int_4742 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1474 = Proto.DateValue(year=Int32(int741), month=Int32(int_3742), day=Int32(int_4743)) - result745 = _t1474 - record_span!(parser, span_start744, "DateValue") - return result745 + _t1472 = Proto.DateValue(year=Int32(int740), month=Int32(int_3741), day=Int32(int_4742)) + result744 = _t1472 + record_span!(parser, span_start743, "DateValue") + return result744 end function parse_raw_datetime(parser::ParserState)::Proto.DateTimeValue - span_start753 = span_start(parser) + span_start752 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int746 = consume_terminal!(parser, "INT") - int_3747 = consume_terminal!(parser, "INT") - int_4748 = consume_terminal!(parser, "INT") - int_5749 = consume_terminal!(parser, "INT") - int_6750 = consume_terminal!(parser, "INT") - int_7751 = consume_terminal!(parser, "INT") + int745 = consume_terminal!(parser, "INT") + int_3746 = consume_terminal!(parser, "INT") + int_4747 = consume_terminal!(parser, "INT") + int_5748 = consume_terminal!(parser, "INT") + int_6749 = consume_terminal!(parser, "INT") + int_7750 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1475 = consume_terminal!(parser, "INT") + _t1473 = consume_terminal!(parser, "INT") else - _t1475 = nothing + _t1473 = nothing end - int_8752 = _t1475 + int_8751 = _t1473 consume_literal!(parser, ")") - _t1476 = Proto.DateTimeValue(year=Int32(int746), month=Int32(int_3747), day=Int32(int_4748), hour=Int32(int_5749), minute=Int32(int_6750), second=Int32(int_7751), microsecond=Int32((!isnothing(int_8752) ? int_8752 : 0))) - result754 = _t1476 - record_span!(parser, span_start753, "DateTimeValue") - return result754 + _t1474 = Proto.DateTimeValue(year=Int32(int745), month=Int32(int_3746), day=Int32(int_4747), hour=Int32(int_5748), minute=Int32(int_6749), second=Int32(int_7750), microsecond=Int32((!isnothing(int_8751) ? int_8751 : 0))) + result753 = _t1474 + record_span!(parser, span_start752, "DateTimeValue") + return result753 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t1477 = 0 + _t1475 = 0 else if match_lookahead_literal(parser, "false", 0) - _t1478 = 1 + _t1476 = 1 else - _t1478 = -1 + _t1476 = -1 end - _t1477 = _t1478 + _t1475 = _t1476 end - prediction755 = _t1477 - if prediction755 == 1 + prediction754 = _t1475 + if prediction754 == 1 consume_literal!(parser, "false") - _t1479 = false + _t1477 = false else - if prediction755 == 0 + if prediction754 == 0 consume_literal!(parser, "true") - _t1480 = true + _t1478 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t1479 = _t1480 + _t1477 = _t1478 end - return _t1479 + return _t1477 end function parse_sync(parser::ParserState)::Proto.Sync - span_start760 = span_start(parser) + span_start759 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs756 = Proto.FragmentId[] - cond757 = match_lookahead_literal(parser, ":", 0) - while cond757 - _t1481 = parse_fragment_id(parser) - item758 = _t1481 - push!(xs756, item758) - cond757 = match_lookahead_literal(parser, ":", 0) - end - fragment_ids759 = xs756 + xs755 = Proto.FragmentId[] + cond756 = match_lookahead_literal(parser, ":", 0) + while cond756 + _t1479 = parse_fragment_id(parser) + item757 = _t1479 + push!(xs755, item757) + cond756 = match_lookahead_literal(parser, ":", 0) + end + fragment_ids758 = xs755 consume_literal!(parser, ")") - _t1482 = Proto.Sync(fragments=fragment_ids759) - result761 = _t1482 - record_span!(parser, span_start760, "Sync") - return result761 + _t1480 = Proto.Sync(fragments=fragment_ids758) + result760 = _t1480 + record_span!(parser, span_start759, "Sync") + return result760 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId - span_start763 = span_start(parser) + span_start762 = span_start(parser) consume_literal!(parser, ":") - symbol762 = consume_terminal!(parser, "SYMBOL") - result764 = Proto.FragmentId(Vector{UInt8}(symbol762)) - record_span!(parser, span_start763, "FragmentId") - return result764 + symbol761 = consume_terminal!(parser, "SYMBOL") + result763 = Proto.FragmentId(Vector{UInt8}(symbol761)) + record_span!(parser, span_start762, "FragmentId") + return result763 end function parse_epoch(parser::ParserState)::Proto.Epoch - span_start767 = span_start(parser) + span_start766 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t1484 = parse_epoch_writes(parser) - _t1483 = _t1484 + _t1482 = parse_epoch_writes(parser) + _t1481 = _t1482 else - _t1483 = nothing + _t1481 = nothing end - epoch_writes765 = _t1483 + epoch_writes764 = _t1481 if match_lookahead_literal(parser, "(", 0) - _t1486 = parse_epoch_reads(parser) - _t1485 = _t1486 + _t1484 = parse_epoch_reads(parser) + _t1483 = _t1484 else - _t1485 = nothing + _t1483 = nothing end - epoch_reads766 = _t1485 + epoch_reads765 = _t1483 consume_literal!(parser, ")") - _t1487 = Proto.Epoch(writes=(!isnothing(epoch_writes765) ? epoch_writes765 : Proto.Write[]), reads=(!isnothing(epoch_reads766) ? epoch_reads766 : Proto.Read[])) - result768 = _t1487 - record_span!(parser, span_start767, "Epoch") - return result768 + _t1485 = Proto.Epoch(writes=(!isnothing(epoch_writes764) ? epoch_writes764 : Proto.Write[]), reads=(!isnothing(epoch_reads765) ? epoch_reads765 : Proto.Read[])) + result767 = _t1485 + record_span!(parser, span_start766, "Epoch") + return result767 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs769 = Proto.Write[] - cond770 = match_lookahead_literal(parser, "(", 0) - while cond770 - _t1488 = parse_write(parser) - item771 = _t1488 - push!(xs769, item771) - cond770 = match_lookahead_literal(parser, "(", 0) - end - writes772 = xs769 + xs768 = Proto.Write[] + cond769 = match_lookahead_literal(parser, "(", 0) + while cond769 + _t1486 = parse_write(parser) + item770 = _t1486 + push!(xs768, item770) + cond769 = match_lookahead_literal(parser, "(", 0) + end + writes771 = xs768 consume_literal!(parser, ")") - return writes772 + return writes771 end function parse_write(parser::ParserState)::Proto.Write - span_start778 = span_start(parser) + span_start777 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t1490 = 1 + _t1488 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t1491 = 3 + _t1489 = 3 else if match_lookahead_literal(parser, "define", 1) - _t1492 = 0 + _t1490 = 0 else if match_lookahead_literal(parser, "context", 1) - _t1493 = 2 + _t1491 = 2 else - _t1493 = -1 + _t1491 = -1 end - _t1492 = _t1493 + _t1490 = _t1491 end - _t1491 = _t1492 + _t1489 = _t1490 end - _t1490 = _t1491 + _t1488 = _t1489 end - _t1489 = _t1490 + _t1487 = _t1488 else - _t1489 = -1 - end - prediction773 = _t1489 - if prediction773 == 3 - _t1495 = parse_snapshot(parser) - snapshot777 = _t1495 - _t1496 = Proto.Write(write_type=OneOf(:snapshot, snapshot777)) - _t1494 = _t1496 + _t1487 = -1 + end + prediction772 = _t1487 + if prediction772 == 3 + _t1493 = parse_snapshot(parser) + snapshot776 = _t1493 + _t1494 = Proto.Write(write_type=OneOf(:snapshot, snapshot776)) + _t1492 = _t1494 else - if prediction773 == 2 - _t1498 = parse_context(parser) - context776 = _t1498 - _t1499 = Proto.Write(write_type=OneOf(:context, context776)) - _t1497 = _t1499 + if prediction772 == 2 + _t1496 = parse_context(parser) + context775 = _t1496 + _t1497 = Proto.Write(write_type=OneOf(:context, context775)) + _t1495 = _t1497 else - if prediction773 == 1 - _t1501 = parse_undefine(parser) - undefine775 = _t1501 - _t1502 = Proto.Write(write_type=OneOf(:undefine, undefine775)) - _t1500 = _t1502 + if prediction772 == 1 + _t1499 = parse_undefine(parser) + undefine774 = _t1499 + _t1500 = Proto.Write(write_type=OneOf(:undefine, undefine774)) + _t1498 = _t1500 else - if prediction773 == 0 - _t1504 = parse_define(parser) - define774 = _t1504 - _t1505 = Proto.Write(write_type=OneOf(:define, define774)) - _t1503 = _t1505 + if prediction772 == 0 + _t1502 = parse_define(parser) + define773 = _t1502 + _t1503 = Proto.Write(write_type=OneOf(:define, define773)) + _t1501 = _t1503 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t1500 = _t1503 + _t1498 = _t1501 end - _t1497 = _t1500 + _t1495 = _t1498 end - _t1494 = _t1497 + _t1492 = _t1495 end - result779 = _t1494 - record_span!(parser, span_start778, "Write") - return result779 + result778 = _t1492 + record_span!(parser, span_start777, "Write") + return result778 end function parse_define(parser::ParserState)::Proto.Define - span_start781 = span_start(parser) + span_start780 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "define") - _t1506 = parse_fragment(parser) - fragment780 = _t1506 + _t1504 = parse_fragment(parser) + fragment779 = _t1504 consume_literal!(parser, ")") - _t1507 = Proto.Define(fragment=fragment780) - result782 = _t1507 - record_span!(parser, span_start781, "Define") - return result782 + _t1505 = Proto.Define(fragment=fragment779) + result781 = _t1505 + record_span!(parser, span_start780, "Define") + return result781 end function parse_fragment(parser::ParserState)::Proto.Fragment - span_start788 = span_start(parser) + span_start787 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t1508 = parse_new_fragment_id(parser) - new_fragment_id783 = _t1508 - xs784 = Proto.Declaration[] - cond785 = match_lookahead_literal(parser, "(", 0) - while cond785 - _t1509 = parse_declaration(parser) - item786 = _t1509 - push!(xs784, item786) - cond785 = match_lookahead_literal(parser, "(", 0) - end - declarations787 = xs784 + _t1506 = parse_new_fragment_id(parser) + new_fragment_id782 = _t1506 + xs783 = Proto.Declaration[] + cond784 = match_lookahead_literal(parser, "(", 0) + while cond784 + _t1507 = parse_declaration(parser) + item785 = _t1507 + push!(xs783, item785) + cond784 = match_lookahead_literal(parser, "(", 0) + end + declarations786 = xs783 consume_literal!(parser, ")") - result789 = construct_fragment(parser, new_fragment_id783, declarations787) - record_span!(parser, span_start788, "Fragment") - return result789 + result788 = construct_fragment(parser, new_fragment_id782, declarations786) + record_span!(parser, span_start787, "Fragment") + return result788 end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - span_start791 = span_start(parser) - _t1510 = parse_fragment_id(parser) - fragment_id790 = _t1510 - start_fragment!(parser, fragment_id790) - result792 = fragment_id790 - record_span!(parser, span_start791, "FragmentId") - return result792 + span_start790 = span_start(parser) + _t1508 = parse_fragment_id(parser) + fragment_id789 = _t1508 + start_fragment!(parser, fragment_id789) + result791 = fragment_id789 + record_span!(parser, span_start790, "FragmentId") + return result791 end function parse_declaration(parser::ParserState)::Proto.Declaration - span_start798 = span_start(parser) + span_start797 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1512 = 3 + _t1510 = 3 else if match_lookahead_literal(parser, "functional_dependency", 1) - _t1513 = 2 + _t1511 = 2 else if match_lookahead_literal(parser, "edb", 1) - _t1514 = 3 + _t1512 = 3 else if match_lookahead_literal(parser, "def", 1) - _t1515 = 0 + _t1513 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1516 = 3 + _t1514 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1517 = 3 + _t1515 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t1518 = 1 + _t1516 = 1 else - _t1518 = -1 + _t1516 = -1 end - _t1517 = _t1518 + _t1515 = _t1516 end - _t1516 = _t1517 + _t1514 = _t1515 end - _t1515 = _t1516 + _t1513 = _t1514 end - _t1514 = _t1515 + _t1512 = _t1513 end - _t1513 = _t1514 + _t1511 = _t1512 end - _t1512 = _t1513 + _t1510 = _t1511 end - _t1511 = _t1512 + _t1509 = _t1510 else - _t1511 = -1 - end - prediction793 = _t1511 - if prediction793 == 3 - _t1520 = parse_data(parser) - data797 = _t1520 - _t1521 = Proto.Declaration(declaration_type=OneOf(:data, data797)) - _t1519 = _t1521 + _t1509 = -1 + end + prediction792 = _t1509 + if prediction792 == 3 + _t1518 = parse_data(parser) + data796 = _t1518 + _t1519 = Proto.Declaration(declaration_type=OneOf(:data, data796)) + _t1517 = _t1519 else - if prediction793 == 2 - _t1523 = parse_constraint(parser) - constraint796 = _t1523 - _t1524 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint796)) - _t1522 = _t1524 + if prediction792 == 2 + _t1521 = parse_constraint(parser) + constraint795 = _t1521 + _t1522 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint795)) + _t1520 = _t1522 else - if prediction793 == 1 - _t1526 = parse_algorithm(parser) - algorithm795 = _t1526 - _t1527 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm795)) - _t1525 = _t1527 + if prediction792 == 1 + _t1524 = parse_algorithm(parser) + algorithm794 = _t1524 + _t1525 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm794)) + _t1523 = _t1525 else - if prediction793 == 0 - _t1529 = parse_def(parser) - def794 = _t1529 - _t1530 = Proto.Declaration(declaration_type=OneOf(:def, def794)) - _t1528 = _t1530 + if prediction792 == 0 + _t1527 = parse_def(parser) + def793 = _t1527 + _t1528 = Proto.Declaration(declaration_type=OneOf(:def, def793)) + _t1526 = _t1528 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t1525 = _t1528 + _t1523 = _t1526 end - _t1522 = _t1525 + _t1520 = _t1523 end - _t1519 = _t1522 + _t1517 = _t1520 end - result799 = _t1519 - record_span!(parser, span_start798, "Declaration") - return result799 + result798 = _t1517 + record_span!(parser, span_start797, "Declaration") + return result798 end function parse_def(parser::ParserState)::Proto.Def - span_start803 = span_start(parser) + span_start802 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "def") - _t1531 = parse_relation_id(parser) - relation_id800 = _t1531 - _t1532 = parse_abstraction(parser) - abstraction801 = _t1532 + _t1529 = parse_relation_id(parser) + relation_id799 = _t1529 + _t1530 = parse_abstraction(parser) + abstraction800 = _t1530 if match_lookahead_literal(parser, "(", 0) - _t1534 = parse_attrs(parser) - _t1533 = _t1534 + _t1532 = parse_attrs(parser) + _t1531 = _t1532 else - _t1533 = nothing + _t1531 = nothing end - attrs802 = _t1533 + attrs801 = _t1531 consume_literal!(parser, ")") - _t1535 = Proto.Def(name=relation_id800, body=abstraction801, attrs=(!isnothing(attrs802) ? attrs802 : Proto.Attribute[])) - result804 = _t1535 - record_span!(parser, span_start803, "Def") - return result804 + _t1533 = Proto.Def(name=relation_id799, body=abstraction800, attrs=(!isnothing(attrs801) ? attrs801 : Proto.Attribute[])) + result803 = _t1533 + record_span!(parser, span_start802, "Def") + return result803 end function parse_relation_id(parser::ParserState)::Proto.RelationId - span_start808 = span_start(parser) + span_start807 = span_start(parser) if match_lookahead_literal(parser, ":", 0) - _t1536 = 0 + _t1534 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1537 = 1 + _t1535 = 1 else - _t1537 = -1 + _t1535 = -1 end - _t1536 = _t1537 + _t1534 = _t1535 end - prediction805 = _t1536 - if prediction805 == 1 - uint128807 = consume_terminal!(parser, "UINT128") - _t1538 = Proto.RelationId(uint128807.low, uint128807.high) + prediction804 = _t1534 + if prediction804 == 1 + uint128806 = consume_terminal!(parser, "UINT128") + _t1536 = Proto.RelationId(uint128806.low, uint128806.high) else - if prediction805 == 0 + if prediction804 == 0 consume_literal!(parser, ":") - symbol806 = consume_terminal!(parser, "SYMBOL") - _t1539 = relation_id_from_string(parser, symbol806) + symbol805 = consume_terminal!(parser, "SYMBOL") + _t1537 = relation_id_from_string(parser, symbol805) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t1538 = _t1539 + _t1536 = _t1537 end - result809 = _t1538 - record_span!(parser, span_start808, "RelationId") - return result809 + result808 = _t1536 + record_span!(parser, span_start807, "RelationId") + return result808 end function parse_abstraction(parser::ParserState)::Proto.Abstraction - span_start812 = span_start(parser) + span_start811 = span_start(parser) consume_literal!(parser, "(") - _t1540 = parse_bindings(parser) - bindings810 = _t1540 - _t1541 = parse_formula(parser) - formula811 = _t1541 + _t1538 = parse_bindings(parser) + bindings809 = _t1538 + _t1539 = parse_formula(parser) + formula810 = _t1539 consume_literal!(parser, ")") - _t1542 = Proto.Abstraction(vars=vcat(bindings810[1], !isnothing(bindings810[2]) ? bindings810[2] : []), value=formula811) - result813 = _t1542 - record_span!(parser, span_start812, "Abstraction") - return result813 + _t1540 = Proto.Abstraction(vars=vcat(bindings809[1], !isnothing(bindings809[2]) ? bindings809[2] : []), value=formula810) + result812 = _t1540 + record_span!(parser, span_start811, "Abstraction") + return result812 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs814 = Proto.Binding[] - cond815 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond815 - _t1543 = parse_binding(parser) - item816 = _t1543 - push!(xs814, item816) - cond815 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - bindings817 = xs814 + xs813 = Proto.Binding[] + cond814 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond814 + _t1541 = parse_binding(parser) + item815 = _t1541 + push!(xs813, item815) + cond814 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + bindings816 = xs813 if match_lookahead_literal(parser, "|", 0) - _t1545 = parse_value_bindings(parser) - _t1544 = _t1545 + _t1543 = parse_value_bindings(parser) + _t1542 = _t1543 else - _t1544 = nothing + _t1542 = nothing end - value_bindings818 = _t1544 + value_bindings817 = _t1542 consume_literal!(parser, "]") - return (bindings817, (!isnothing(value_bindings818) ? value_bindings818 : Proto.Binding[]),) + return (bindings816, (!isnothing(value_bindings817) ? value_bindings817 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - span_start821 = span_start(parser) - symbol819 = consume_terminal!(parser, "SYMBOL") + span_start820 = span_start(parser) + symbol818 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t1546 = parse_type(parser) - type820 = _t1546 - _t1547 = Proto.Var(name=symbol819) - _t1548 = Proto.Binding(var=_t1547, var"#type"=type820) - result822 = _t1548 - record_span!(parser, span_start821, "Binding") - return result822 + _t1544 = parse_type(parser) + type819 = _t1544 + _t1545 = Proto.Var(name=symbol818) + _t1546 = Proto.Binding(var=_t1545, var"#type"=type819) + result821 = _t1546 + record_span!(parser, span_start820, "Binding") + return result821 end function parse_type(parser::ParserState)::Proto.var"#Type" - span_start838 = span_start(parser) + span_start837 = span_start(parser) if match_lookahead_literal(parser, "UNKNOWN", 0) - _t1549 = 0 + _t1547 = 0 else if match_lookahead_literal(parser, "UINT32", 0) - _t1550 = 13 + _t1548 = 13 else if match_lookahead_literal(parser, "UINT128", 0) - _t1551 = 4 + _t1549 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t1552 = 1 + _t1550 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t1553 = 8 + _t1551 = 8 else if match_lookahead_literal(parser, "INT32", 0) - _t1554 = 11 + _t1552 = 11 else if match_lookahead_literal(parser, "INT128", 0) - _t1555 = 5 + _t1553 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t1556 = 2 + _t1554 = 2 else if match_lookahead_literal(parser, "FLOAT32", 0) - _t1557 = 12 + _t1555 = 12 else if match_lookahead_literal(parser, "FLOAT", 0) - _t1558 = 3 + _t1556 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t1559 = 7 + _t1557 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t1560 = 6 + _t1558 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t1561 = 10 + _t1559 = 10 else if match_lookahead_literal(parser, "(", 0) - _t1562 = 9 + _t1560 = 9 else - _t1562 = -1 + _t1560 = -1 end - _t1561 = _t1562 + _t1559 = _t1560 end - _t1560 = _t1561 + _t1558 = _t1559 end - _t1559 = _t1560 + _t1557 = _t1558 end - _t1558 = _t1559 + _t1556 = _t1557 end - _t1557 = _t1558 + _t1555 = _t1556 end - _t1556 = _t1557 + _t1554 = _t1555 end - _t1555 = _t1556 + _t1553 = _t1554 end - _t1554 = _t1555 + _t1552 = _t1553 end - _t1553 = _t1554 + _t1551 = _t1552 end - _t1552 = _t1553 + _t1550 = _t1551 end - _t1551 = _t1552 + _t1549 = _t1550 end - _t1550 = _t1551 + _t1548 = _t1549 end - _t1549 = _t1550 - end - prediction823 = _t1549 - if prediction823 == 13 - _t1564 = parse_uint32_type(parser) - uint32_type837 = _t1564 - _t1565 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type837)) - _t1563 = _t1565 + _t1547 = _t1548 + end + prediction822 = _t1547 + if prediction822 == 13 + _t1562 = parse_uint32_type(parser) + uint32_type836 = _t1562 + _t1563 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type836)) + _t1561 = _t1563 else - if prediction823 == 12 - _t1567 = parse_float32_type(parser) - float32_type836 = _t1567 - _t1568 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type836)) - _t1566 = _t1568 + if prediction822 == 12 + _t1565 = parse_float32_type(parser) + float32_type835 = _t1565 + _t1566 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type835)) + _t1564 = _t1566 else - if prediction823 == 11 - _t1570 = parse_int32_type(parser) - int32_type835 = _t1570 - _t1571 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type835)) - _t1569 = _t1571 + if prediction822 == 11 + _t1568 = parse_int32_type(parser) + int32_type834 = _t1568 + _t1569 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type834)) + _t1567 = _t1569 else - if prediction823 == 10 - _t1573 = parse_boolean_type(parser) - boolean_type834 = _t1573 - _t1574 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type834)) - _t1572 = _t1574 + if prediction822 == 10 + _t1571 = parse_boolean_type(parser) + boolean_type833 = _t1571 + _t1572 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type833)) + _t1570 = _t1572 else - if prediction823 == 9 - _t1576 = parse_decimal_type(parser) - decimal_type833 = _t1576 - _t1577 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type833)) - _t1575 = _t1577 + if prediction822 == 9 + _t1574 = parse_decimal_type(parser) + decimal_type832 = _t1574 + _t1575 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type832)) + _t1573 = _t1575 else - if prediction823 == 8 - _t1579 = parse_missing_type(parser) - missing_type832 = _t1579 - _t1580 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type832)) - _t1578 = _t1580 + if prediction822 == 8 + _t1577 = parse_missing_type(parser) + missing_type831 = _t1577 + _t1578 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type831)) + _t1576 = _t1578 else - if prediction823 == 7 - _t1582 = parse_datetime_type(parser) - datetime_type831 = _t1582 - _t1583 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type831)) - _t1581 = _t1583 + if prediction822 == 7 + _t1580 = parse_datetime_type(parser) + datetime_type830 = _t1580 + _t1581 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type830)) + _t1579 = _t1581 else - if prediction823 == 6 - _t1585 = parse_date_type(parser) - date_type830 = _t1585 - _t1586 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type830)) - _t1584 = _t1586 + if prediction822 == 6 + _t1583 = parse_date_type(parser) + date_type829 = _t1583 + _t1584 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type829)) + _t1582 = _t1584 else - if prediction823 == 5 - _t1588 = parse_int128_type(parser) - int128_type829 = _t1588 - _t1589 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type829)) - _t1587 = _t1589 + if prediction822 == 5 + _t1586 = parse_int128_type(parser) + int128_type828 = _t1586 + _t1587 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type828)) + _t1585 = _t1587 else - if prediction823 == 4 - _t1591 = parse_uint128_type(parser) - uint128_type828 = _t1591 - _t1592 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type828)) - _t1590 = _t1592 + if prediction822 == 4 + _t1589 = parse_uint128_type(parser) + uint128_type827 = _t1589 + _t1590 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type827)) + _t1588 = _t1590 else - if prediction823 == 3 - _t1594 = parse_float_type(parser) - float_type827 = _t1594 - _t1595 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type827)) - _t1593 = _t1595 + if prediction822 == 3 + _t1592 = parse_float_type(parser) + float_type826 = _t1592 + _t1593 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type826)) + _t1591 = _t1593 else - if prediction823 == 2 - _t1597 = parse_int_type(parser) - int_type826 = _t1597 - _t1598 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type826)) - _t1596 = _t1598 + if prediction822 == 2 + _t1595 = parse_int_type(parser) + int_type825 = _t1595 + _t1596 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type825)) + _t1594 = _t1596 else - if prediction823 == 1 - _t1600 = parse_string_type(parser) - string_type825 = _t1600 - _t1601 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type825)) - _t1599 = _t1601 + if prediction822 == 1 + _t1598 = parse_string_type(parser) + string_type824 = _t1598 + _t1599 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type824)) + _t1597 = _t1599 else - if prediction823 == 0 - _t1603 = parse_unspecified_type(parser) - unspecified_type824 = _t1603 - _t1604 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type824)) - _t1602 = _t1604 + if prediction822 == 0 + _t1601 = parse_unspecified_type(parser) + unspecified_type823 = _t1601 + _t1602 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type823)) + _t1600 = _t1602 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) end - _t1599 = _t1602 + _t1597 = _t1600 end - _t1596 = _t1599 + _t1594 = _t1597 end - _t1593 = _t1596 + _t1591 = _t1594 end - _t1590 = _t1593 + _t1588 = _t1591 end - _t1587 = _t1590 + _t1585 = _t1588 end - _t1584 = _t1587 + _t1582 = _t1585 end - _t1581 = _t1584 + _t1579 = _t1582 end - _t1578 = _t1581 + _t1576 = _t1579 end - _t1575 = _t1578 + _t1573 = _t1576 end - _t1572 = _t1575 + _t1570 = _t1573 end - _t1569 = _t1572 + _t1567 = _t1570 end - _t1566 = _t1569 + _t1564 = _t1567 end - _t1563 = _t1566 + _t1561 = _t1564 end - result839 = _t1563 - record_span!(parser, span_start838, "Type") - return result839 + result838 = _t1561 + record_span!(parser, span_start837, "Type") + return result838 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType - span_start840 = span_start(parser) + span_start839 = span_start(parser) consume_literal!(parser, "UNKNOWN") - _t1605 = Proto.UnspecifiedType() - result841 = _t1605 - record_span!(parser, span_start840, "UnspecifiedType") - return result841 + _t1603 = Proto.UnspecifiedType() + result840 = _t1603 + record_span!(parser, span_start839, "UnspecifiedType") + return result840 end function parse_string_type(parser::ParserState)::Proto.StringType - span_start842 = span_start(parser) + span_start841 = span_start(parser) consume_literal!(parser, "STRING") - _t1606 = Proto.StringType() - result843 = _t1606 - record_span!(parser, span_start842, "StringType") - return result843 + _t1604 = Proto.StringType() + result842 = _t1604 + record_span!(parser, span_start841, "StringType") + return result842 end function parse_int_type(parser::ParserState)::Proto.IntType - span_start844 = span_start(parser) + span_start843 = span_start(parser) consume_literal!(parser, "INT") - _t1607 = Proto.IntType() - result845 = _t1607 - record_span!(parser, span_start844, "IntType") - return result845 + _t1605 = Proto.IntType() + result844 = _t1605 + record_span!(parser, span_start843, "IntType") + return result844 end function parse_float_type(parser::ParserState)::Proto.FloatType - span_start846 = span_start(parser) + span_start845 = span_start(parser) consume_literal!(parser, "FLOAT") - _t1608 = Proto.FloatType() - result847 = _t1608 - record_span!(parser, span_start846, "FloatType") - return result847 + _t1606 = Proto.FloatType() + result846 = _t1606 + record_span!(parser, span_start845, "FloatType") + return result846 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type - span_start848 = span_start(parser) + span_start847 = span_start(parser) consume_literal!(parser, "UINT128") - _t1609 = Proto.UInt128Type() - result849 = _t1609 - record_span!(parser, span_start848, "UInt128Type") - return result849 + _t1607 = Proto.UInt128Type() + result848 = _t1607 + record_span!(parser, span_start847, "UInt128Type") + return result848 end function parse_int128_type(parser::ParserState)::Proto.Int128Type - span_start850 = span_start(parser) + span_start849 = span_start(parser) consume_literal!(parser, "INT128") - _t1610 = Proto.Int128Type() - result851 = _t1610 - record_span!(parser, span_start850, "Int128Type") - return result851 + _t1608 = Proto.Int128Type() + result850 = _t1608 + record_span!(parser, span_start849, "Int128Type") + return result850 end function parse_date_type(parser::ParserState)::Proto.DateType - span_start852 = span_start(parser) + span_start851 = span_start(parser) consume_literal!(parser, "DATE") - _t1611 = Proto.DateType() - result853 = _t1611 - record_span!(parser, span_start852, "DateType") - return result853 + _t1609 = Proto.DateType() + result852 = _t1609 + record_span!(parser, span_start851, "DateType") + return result852 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType - span_start854 = span_start(parser) + span_start853 = span_start(parser) consume_literal!(parser, "DATETIME") - _t1612 = Proto.DateTimeType() - result855 = _t1612 - record_span!(parser, span_start854, "DateTimeType") - return result855 + _t1610 = Proto.DateTimeType() + result854 = _t1610 + record_span!(parser, span_start853, "DateTimeType") + return result854 end function parse_missing_type(parser::ParserState)::Proto.MissingType - span_start856 = span_start(parser) + span_start855 = span_start(parser) consume_literal!(parser, "MISSING") - _t1613 = Proto.MissingType() - result857 = _t1613 - record_span!(parser, span_start856, "MissingType") - return result857 + _t1611 = Proto.MissingType() + result856 = _t1611 + record_span!(parser, span_start855, "MissingType") + return result856 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType - span_start860 = span_start(parser) + span_start859 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int858 = consume_terminal!(parser, "INT") - int_3859 = consume_terminal!(parser, "INT") + int857 = consume_terminal!(parser, "INT") + int_3858 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1614 = Proto.DecimalType(precision=Int32(int858), scale=Int32(int_3859)) - result861 = _t1614 - record_span!(parser, span_start860, "DecimalType") - return result861 + _t1612 = Proto.DecimalType(precision=Int32(int857), scale=Int32(int_3858)) + result860 = _t1612 + record_span!(parser, span_start859, "DecimalType") + return result860 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType - span_start862 = span_start(parser) + span_start861 = span_start(parser) consume_literal!(parser, "BOOLEAN") - _t1615 = Proto.BooleanType() - result863 = _t1615 - record_span!(parser, span_start862, "BooleanType") - return result863 + _t1613 = Proto.BooleanType() + result862 = _t1613 + record_span!(parser, span_start861, "BooleanType") + return result862 end function parse_int32_type(parser::ParserState)::Proto.Int32Type - span_start864 = span_start(parser) + span_start863 = span_start(parser) consume_literal!(parser, "INT32") - _t1616 = Proto.Int32Type() - result865 = _t1616 - record_span!(parser, span_start864, "Int32Type") - return result865 + _t1614 = Proto.Int32Type() + result864 = _t1614 + record_span!(parser, span_start863, "Int32Type") + return result864 end function parse_float32_type(parser::ParserState)::Proto.Float32Type - span_start866 = span_start(parser) + span_start865 = span_start(parser) consume_literal!(parser, "FLOAT32") - _t1617 = Proto.Float32Type() - result867 = _t1617 - record_span!(parser, span_start866, "Float32Type") - return result867 + _t1615 = Proto.Float32Type() + result866 = _t1615 + record_span!(parser, span_start865, "Float32Type") + return result866 end function parse_uint32_type(parser::ParserState)::Proto.UInt32Type - span_start868 = span_start(parser) + span_start867 = span_start(parser) consume_literal!(parser, "UINT32") - _t1618 = Proto.UInt32Type() - result869 = _t1618 - record_span!(parser, span_start868, "UInt32Type") - return result869 + _t1616 = Proto.UInt32Type() + result868 = _t1616 + record_span!(parser, span_start867, "UInt32Type") + return result868 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs870 = Proto.Binding[] - cond871 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond871 - _t1619 = parse_binding(parser) - item872 = _t1619 - push!(xs870, item872) - cond871 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs869 = Proto.Binding[] + cond870 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond870 + _t1617 = parse_binding(parser) + item871 = _t1617 + push!(xs869, item871) + cond870 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings873 = xs870 - return bindings873 + bindings872 = xs869 + return bindings872 end function parse_formula(parser::ParserState)::Proto.Formula - span_start888 = span_start(parser) + span_start887 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t1621 = 0 + _t1619 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t1622 = 11 + _t1620 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t1623 = 3 + _t1621 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t1624 = 10 + _t1622 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t1625 = 9 + _t1623 = 9 else if match_lookahead_literal(parser, "or", 1) - _t1626 = 5 + _t1624 = 5 else if match_lookahead_literal(parser, "not", 1) - _t1627 = 6 + _t1625 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t1628 = 7 + _t1626 = 7 else if match_lookahead_literal(parser, "false", 1) - _t1629 = 1 + _t1627 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t1630 = 2 + _t1628 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t1631 = 12 + _t1629 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t1632 = 8 + _t1630 = 8 else if match_lookahead_literal(parser, "and", 1) - _t1633 = 4 + _t1631 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t1634 = 10 + _t1632 = 10 else if match_lookahead_literal(parser, ">", 1) - _t1635 = 10 + _t1633 = 10 else if match_lookahead_literal(parser, "=", 1) - _t1636 = 10 + _t1634 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t1637 = 10 + _t1635 = 10 else if match_lookahead_literal(parser, "<", 1) - _t1638 = 10 + _t1636 = 10 else if match_lookahead_literal(parser, "/", 1) - _t1639 = 10 + _t1637 = 10 else if match_lookahead_literal(parser, "-", 1) - _t1640 = 10 + _t1638 = 10 else if match_lookahead_literal(parser, "+", 1) - _t1641 = 10 + _t1639 = 10 else if match_lookahead_literal(parser, "*", 1) - _t1642 = 10 + _t1640 = 10 else - _t1642 = -1 + _t1640 = -1 end - _t1641 = _t1642 + _t1639 = _t1640 end - _t1640 = _t1641 + _t1638 = _t1639 end - _t1639 = _t1640 + _t1637 = _t1638 end - _t1638 = _t1639 + _t1636 = _t1637 end - _t1637 = _t1638 + _t1635 = _t1636 end - _t1636 = _t1637 + _t1634 = _t1635 end - _t1635 = _t1636 + _t1633 = _t1634 end - _t1634 = _t1635 + _t1632 = _t1633 end - _t1633 = _t1634 + _t1631 = _t1632 end - _t1632 = _t1633 + _t1630 = _t1631 end - _t1631 = _t1632 + _t1629 = _t1630 end - _t1630 = _t1631 + _t1628 = _t1629 end - _t1629 = _t1630 + _t1627 = _t1628 end - _t1628 = _t1629 + _t1626 = _t1627 end - _t1627 = _t1628 + _t1625 = _t1626 end - _t1626 = _t1627 + _t1624 = _t1625 end - _t1625 = _t1626 + _t1623 = _t1624 end - _t1624 = _t1625 + _t1622 = _t1623 end - _t1623 = _t1624 + _t1621 = _t1622 end - _t1622 = _t1623 + _t1620 = _t1621 end - _t1621 = _t1622 + _t1619 = _t1620 end - _t1620 = _t1621 + _t1618 = _t1619 else - _t1620 = -1 - end - prediction874 = _t1620 - if prediction874 == 12 - _t1644 = parse_cast(parser) - cast887 = _t1644 - _t1645 = Proto.Formula(formula_type=OneOf(:cast, cast887)) - _t1643 = _t1645 + _t1618 = -1 + end + prediction873 = _t1618 + if prediction873 == 12 + _t1642 = parse_cast(parser) + cast886 = _t1642 + _t1643 = Proto.Formula(formula_type=OneOf(:cast, cast886)) + _t1641 = _t1643 else - if prediction874 == 11 - _t1647 = parse_rel_atom(parser) - rel_atom886 = _t1647 - _t1648 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom886)) - _t1646 = _t1648 + if prediction873 == 11 + _t1645 = parse_rel_atom(parser) + rel_atom885 = _t1645 + _t1646 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom885)) + _t1644 = _t1646 else - if prediction874 == 10 - _t1650 = parse_primitive(parser) - primitive885 = _t1650 - _t1651 = Proto.Formula(formula_type=OneOf(:primitive, primitive885)) - _t1649 = _t1651 + if prediction873 == 10 + _t1648 = parse_primitive(parser) + primitive884 = _t1648 + _t1649 = Proto.Formula(formula_type=OneOf(:primitive, primitive884)) + _t1647 = _t1649 else - if prediction874 == 9 - _t1653 = parse_pragma(parser) - pragma884 = _t1653 - _t1654 = Proto.Formula(formula_type=OneOf(:pragma, pragma884)) - _t1652 = _t1654 + if prediction873 == 9 + _t1651 = parse_pragma(parser) + pragma883 = _t1651 + _t1652 = Proto.Formula(formula_type=OneOf(:pragma, pragma883)) + _t1650 = _t1652 else - if prediction874 == 8 - _t1656 = parse_atom(parser) - atom883 = _t1656 - _t1657 = Proto.Formula(formula_type=OneOf(:atom, atom883)) - _t1655 = _t1657 + if prediction873 == 8 + _t1654 = parse_atom(parser) + atom882 = _t1654 + _t1655 = Proto.Formula(formula_type=OneOf(:atom, atom882)) + _t1653 = _t1655 else - if prediction874 == 7 - _t1659 = parse_ffi(parser) - ffi882 = _t1659 - _t1660 = Proto.Formula(formula_type=OneOf(:ffi, ffi882)) - _t1658 = _t1660 + if prediction873 == 7 + _t1657 = parse_ffi(parser) + ffi881 = _t1657 + _t1658 = Proto.Formula(formula_type=OneOf(:ffi, ffi881)) + _t1656 = _t1658 else - if prediction874 == 6 - _t1662 = parse_not(parser) - not881 = _t1662 - _t1663 = Proto.Formula(formula_type=OneOf(:not, not881)) - _t1661 = _t1663 + if prediction873 == 6 + _t1660 = parse_not(parser) + not880 = _t1660 + _t1661 = Proto.Formula(formula_type=OneOf(:not, not880)) + _t1659 = _t1661 else - if prediction874 == 5 - _t1665 = parse_disjunction(parser) - disjunction880 = _t1665 - _t1666 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction880)) - _t1664 = _t1666 + if prediction873 == 5 + _t1663 = parse_disjunction(parser) + disjunction879 = _t1663 + _t1664 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction879)) + _t1662 = _t1664 else - if prediction874 == 4 - _t1668 = parse_conjunction(parser) - conjunction879 = _t1668 - _t1669 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction879)) - _t1667 = _t1669 + if prediction873 == 4 + _t1666 = parse_conjunction(parser) + conjunction878 = _t1666 + _t1667 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction878)) + _t1665 = _t1667 else - if prediction874 == 3 - _t1671 = parse_reduce(parser) - reduce878 = _t1671 - _t1672 = Proto.Formula(formula_type=OneOf(:reduce, reduce878)) - _t1670 = _t1672 + if prediction873 == 3 + _t1669 = parse_reduce(parser) + reduce877 = _t1669 + _t1670 = Proto.Formula(formula_type=OneOf(:reduce, reduce877)) + _t1668 = _t1670 else - if prediction874 == 2 - _t1674 = parse_exists(parser) - exists877 = _t1674 - _t1675 = Proto.Formula(formula_type=OneOf(:exists, exists877)) - _t1673 = _t1675 + if prediction873 == 2 + _t1672 = parse_exists(parser) + exists876 = _t1672 + _t1673 = Proto.Formula(formula_type=OneOf(:exists, exists876)) + _t1671 = _t1673 else - if prediction874 == 1 - _t1677 = parse_false(parser) - false876 = _t1677 - _t1678 = Proto.Formula(formula_type=OneOf(:disjunction, false876)) - _t1676 = _t1678 + if prediction873 == 1 + _t1675 = parse_false(parser) + false875 = _t1675 + _t1676 = Proto.Formula(formula_type=OneOf(:disjunction, false875)) + _t1674 = _t1676 else - if prediction874 == 0 - _t1680 = parse_true(parser) - true875 = _t1680 - _t1681 = Proto.Formula(formula_type=OneOf(:conjunction, true875)) - _t1679 = _t1681 + if prediction873 == 0 + _t1678 = parse_true(parser) + true874 = _t1678 + _t1679 = Proto.Formula(formula_type=OneOf(:conjunction, true874)) + _t1677 = _t1679 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t1676 = _t1679 + _t1674 = _t1677 end - _t1673 = _t1676 + _t1671 = _t1674 end - _t1670 = _t1673 + _t1668 = _t1671 end - _t1667 = _t1670 + _t1665 = _t1668 end - _t1664 = _t1667 + _t1662 = _t1665 end - _t1661 = _t1664 + _t1659 = _t1662 end - _t1658 = _t1661 + _t1656 = _t1659 end - _t1655 = _t1658 + _t1653 = _t1656 end - _t1652 = _t1655 + _t1650 = _t1653 end - _t1649 = _t1652 + _t1647 = _t1650 end - _t1646 = _t1649 + _t1644 = _t1647 end - _t1643 = _t1646 + _t1641 = _t1644 end - result889 = _t1643 - record_span!(parser, span_start888, "Formula") - return result889 + result888 = _t1641 + record_span!(parser, span_start887, "Formula") + return result888 end function parse_true(parser::ParserState)::Proto.Conjunction - span_start890 = span_start(parser) + span_start889 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t1682 = Proto.Conjunction(args=Proto.Formula[]) - result891 = _t1682 - record_span!(parser, span_start890, "Conjunction") - return result891 + _t1680 = Proto.Conjunction(args=Proto.Formula[]) + result890 = _t1680 + record_span!(parser, span_start889, "Conjunction") + return result890 end function parse_false(parser::ParserState)::Proto.Disjunction - span_start892 = span_start(parser) + span_start891 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t1683 = Proto.Disjunction(args=Proto.Formula[]) - result893 = _t1683 - record_span!(parser, span_start892, "Disjunction") - return result893 + _t1681 = Proto.Disjunction(args=Proto.Formula[]) + result892 = _t1681 + record_span!(parser, span_start891, "Disjunction") + return result892 end function parse_exists(parser::ParserState)::Proto.Exists - span_start896 = span_start(parser) + span_start895 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t1684 = parse_bindings(parser) - bindings894 = _t1684 - _t1685 = parse_formula(parser) - formula895 = _t1685 + _t1682 = parse_bindings(parser) + bindings893 = _t1682 + _t1683 = parse_formula(parser) + formula894 = _t1683 consume_literal!(parser, ")") - _t1686 = Proto.Abstraction(vars=vcat(bindings894[1], !isnothing(bindings894[2]) ? bindings894[2] : []), value=formula895) - _t1687 = Proto.Exists(body=_t1686) - result897 = _t1687 - record_span!(parser, span_start896, "Exists") - return result897 + _t1684 = Proto.Abstraction(vars=vcat(bindings893[1], !isnothing(bindings893[2]) ? bindings893[2] : []), value=formula894) + _t1685 = Proto.Exists(body=_t1684) + result896 = _t1685 + record_span!(parser, span_start895, "Exists") + return result896 end function parse_reduce(parser::ParserState)::Proto.Reduce - span_start901 = span_start(parser) + span_start900 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t1688 = parse_abstraction(parser) - abstraction898 = _t1688 - _t1689 = parse_abstraction(parser) - abstraction_3899 = _t1689 - _t1690 = parse_terms(parser) - terms900 = _t1690 + _t1686 = parse_abstraction(parser) + abstraction897 = _t1686 + _t1687 = parse_abstraction(parser) + abstraction_3898 = _t1687 + _t1688 = parse_terms(parser) + terms899 = _t1688 consume_literal!(parser, ")") - _t1691 = Proto.Reduce(op=abstraction898, body=abstraction_3899, terms=terms900) - result902 = _t1691 - record_span!(parser, span_start901, "Reduce") - return result902 + _t1689 = Proto.Reduce(op=abstraction897, body=abstraction_3898, terms=terms899) + result901 = _t1689 + record_span!(parser, span_start900, "Reduce") + return result901 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs903 = Proto.Term[] - cond904 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond904 - _t1692 = parse_term(parser) - item905 = _t1692 - push!(xs903, item905) - cond904 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - end - terms906 = xs903 + xs902 = Proto.Term[] + cond903 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond903 + _t1690 = parse_term(parser) + item904 = _t1690 + push!(xs902, item904) + cond903 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + terms905 = xs902 consume_literal!(parser, ")") - return terms906 + return terms905 end function parse_term(parser::ParserState)::Proto.Term - span_start910 = span_start(parser) + span_start909 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1693 = 1 + _t1691 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1694 = 1 + _t1692 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1695 = 1 + _t1693 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1696 = 1 + _t1694 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1697 = 0 + _t1695 = 0 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1698 = 1 + _t1696 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1699 = 1 + _t1697 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1700 = 1 + _t1698 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1701 = 1 + _t1699 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1702 = 1 + _t1700 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1703 = 1 + _t1701 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1704 = 1 + _t1702 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1705 = 1 + _t1703 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1706 = 1 + _t1704 = 1 else - _t1706 = -1 + _t1704 = -1 end - _t1705 = _t1706 + _t1703 = _t1704 end - _t1704 = _t1705 + _t1702 = _t1703 end - _t1703 = _t1704 + _t1701 = _t1702 end - _t1702 = _t1703 + _t1700 = _t1701 end - _t1701 = _t1702 + _t1699 = _t1700 end - _t1700 = _t1701 + _t1698 = _t1699 end - _t1699 = _t1700 + _t1697 = _t1698 end - _t1698 = _t1699 + _t1696 = _t1697 end - _t1697 = _t1698 + _t1695 = _t1696 end - _t1696 = _t1697 + _t1694 = _t1695 end - _t1695 = _t1696 + _t1693 = _t1694 end - _t1694 = _t1695 + _t1692 = _t1693 end - _t1693 = _t1694 - end - prediction907 = _t1693 - if prediction907 == 1 - _t1708 = parse_value(parser) - value909 = _t1708 - _t1709 = Proto.Term(term_type=OneOf(:constant, value909)) - _t1707 = _t1709 + _t1691 = _t1692 + end + prediction906 = _t1691 + if prediction906 == 1 + _t1706 = parse_value(parser) + value908 = _t1706 + _t1707 = Proto.Term(term_type=OneOf(:constant, value908)) + _t1705 = _t1707 else - if prediction907 == 0 - _t1711 = parse_var(parser) - var908 = _t1711 - _t1712 = Proto.Term(term_type=OneOf(:var, var908)) - _t1710 = _t1712 + if prediction906 == 0 + _t1709 = parse_var(parser) + var907 = _t1709 + _t1710 = Proto.Term(term_type=OneOf(:var, var907)) + _t1708 = _t1710 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t1707 = _t1710 + _t1705 = _t1708 end - result911 = _t1707 - record_span!(parser, span_start910, "Term") - return result911 + result910 = _t1705 + record_span!(parser, span_start909, "Term") + return result910 end function parse_var(parser::ParserState)::Proto.Var - span_start913 = span_start(parser) - symbol912 = consume_terminal!(parser, "SYMBOL") - _t1713 = Proto.Var(name=symbol912) - result914 = _t1713 - record_span!(parser, span_start913, "Var") - return result914 + span_start912 = span_start(parser) + symbol911 = consume_terminal!(parser, "SYMBOL") + _t1711 = Proto.Var(name=symbol911) + result913 = _t1711 + record_span!(parser, span_start912, "Var") + return result913 end function parse_value(parser::ParserState)::Proto.Value - span_start928 = span_start(parser) + span_start927 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1714 = 12 + _t1712 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1715 = 11 + _t1713 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1716 = 12 + _t1714 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1718 = 1 + _t1716 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1719 = 0 + _t1717 = 0 else - _t1719 = -1 + _t1717 = -1 end - _t1718 = _t1719 + _t1716 = _t1717 end - _t1717 = _t1718 + _t1715 = _t1716 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1720 = 7 + _t1718 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1721 = 8 + _t1719 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1722 = 2 + _t1720 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1723 = 3 + _t1721 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1724 = 9 + _t1722 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1725 = 4 + _t1723 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1726 = 5 + _t1724 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1727 = 6 + _t1725 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1728 = 10 + _t1726 = 10 else - _t1728 = -1 + _t1726 = -1 end - _t1727 = _t1728 + _t1725 = _t1726 end - _t1726 = _t1727 + _t1724 = _t1725 end - _t1725 = _t1726 + _t1723 = _t1724 end - _t1724 = _t1725 + _t1722 = _t1723 end - _t1723 = _t1724 + _t1721 = _t1722 end - _t1722 = _t1723 + _t1720 = _t1721 end - _t1721 = _t1722 + _t1719 = _t1720 end - _t1720 = _t1721 + _t1718 = _t1719 end - _t1717 = _t1720 + _t1715 = _t1718 end - _t1716 = _t1717 + _t1714 = _t1715 end - _t1715 = _t1716 + _t1713 = _t1714 end - _t1714 = _t1715 - end - prediction915 = _t1714 - if prediction915 == 12 - _t1730 = parse_boolean_value(parser) - boolean_value927 = _t1730 - _t1731 = Proto.Value(value=OneOf(:boolean_value, boolean_value927)) - _t1729 = _t1731 + _t1712 = _t1713 + end + prediction914 = _t1712 + if prediction914 == 12 + _t1728 = parse_boolean_value(parser) + boolean_value926 = _t1728 + _t1729 = Proto.Value(value=OneOf(:boolean_value, boolean_value926)) + _t1727 = _t1729 else - if prediction915 == 11 + if prediction914 == 11 consume_literal!(parser, "missing") - _t1733 = Proto.MissingValue() - _t1734 = Proto.Value(value=OneOf(:missing_value, _t1733)) - _t1732 = _t1734 + _t1731 = Proto.MissingValue() + _t1732 = Proto.Value(value=OneOf(:missing_value, _t1731)) + _t1730 = _t1732 else - if prediction915 == 10 - formatted_decimal926 = consume_terminal!(parser, "DECIMAL") - _t1736 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal926)) - _t1735 = _t1736 + if prediction914 == 10 + formatted_decimal925 = consume_terminal!(parser, "DECIMAL") + _t1734 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal925)) + _t1733 = _t1734 else - if prediction915 == 9 - formatted_int128925 = consume_terminal!(parser, "INT128") - _t1738 = Proto.Value(value=OneOf(:int128_value, formatted_int128925)) - _t1737 = _t1738 + if prediction914 == 9 + formatted_int128924 = consume_terminal!(parser, "INT128") + _t1736 = Proto.Value(value=OneOf(:int128_value, formatted_int128924)) + _t1735 = _t1736 else - if prediction915 == 8 - formatted_uint128924 = consume_terminal!(parser, "UINT128") - _t1740 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128924)) - _t1739 = _t1740 + if prediction914 == 8 + formatted_uint128923 = consume_terminal!(parser, "UINT128") + _t1738 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128923)) + _t1737 = _t1738 else - if prediction915 == 7 - formatted_uint32923 = consume_terminal!(parser, "UINT32") - _t1742 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32923)) - _t1741 = _t1742 + if prediction914 == 7 + formatted_uint32922 = consume_terminal!(parser, "UINT32") + _t1740 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32922)) + _t1739 = _t1740 else - if prediction915 == 6 - formatted_float922 = consume_terminal!(parser, "FLOAT") - _t1744 = Proto.Value(value=OneOf(:float_value, formatted_float922)) - _t1743 = _t1744 + if prediction914 == 6 + formatted_float921 = consume_terminal!(parser, "FLOAT") + _t1742 = Proto.Value(value=OneOf(:float_value, formatted_float921)) + _t1741 = _t1742 else - if prediction915 == 5 - formatted_float32921 = consume_terminal!(parser, "FLOAT32") - _t1746 = Proto.Value(value=OneOf(:float32_value, formatted_float32921)) - _t1745 = _t1746 + if prediction914 == 5 + formatted_float32920 = consume_terminal!(parser, "FLOAT32") + _t1744 = Proto.Value(value=OneOf(:float32_value, formatted_float32920)) + _t1743 = _t1744 else - if prediction915 == 4 - formatted_int920 = consume_terminal!(parser, "INT") - _t1748 = Proto.Value(value=OneOf(:int_value, formatted_int920)) - _t1747 = _t1748 + if prediction914 == 4 + formatted_int919 = consume_terminal!(parser, "INT") + _t1746 = Proto.Value(value=OneOf(:int_value, formatted_int919)) + _t1745 = _t1746 else - if prediction915 == 3 - formatted_int32919 = consume_terminal!(parser, "INT32") - _t1750 = Proto.Value(value=OneOf(:int32_value, formatted_int32919)) - _t1749 = _t1750 + if prediction914 == 3 + formatted_int32918 = consume_terminal!(parser, "INT32") + _t1748 = Proto.Value(value=OneOf(:int32_value, formatted_int32918)) + _t1747 = _t1748 else - if prediction915 == 2 - formatted_string918 = consume_terminal!(parser, "STRING") - _t1752 = Proto.Value(value=OneOf(:string_value, formatted_string918)) - _t1751 = _t1752 + if prediction914 == 2 + formatted_string917 = consume_terminal!(parser, "STRING") + _t1750 = Proto.Value(value=OneOf(:string_value, formatted_string917)) + _t1749 = _t1750 else - if prediction915 == 1 - _t1754 = parse_datetime(parser) - datetime917 = _t1754 - _t1755 = Proto.Value(value=OneOf(:datetime_value, datetime917)) - _t1753 = _t1755 + if prediction914 == 1 + _t1752 = parse_datetime(parser) + datetime916 = _t1752 + _t1753 = Proto.Value(value=OneOf(:datetime_value, datetime916)) + _t1751 = _t1753 else - if prediction915 == 0 - _t1757 = parse_date(parser) - date916 = _t1757 - _t1758 = Proto.Value(value=OneOf(:date_value, date916)) - _t1756 = _t1758 + if prediction914 == 0 + _t1755 = parse_date(parser) + date915 = _t1755 + _t1756 = Proto.Value(value=OneOf(:date_value, date915)) + _t1754 = _t1756 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t1753 = _t1756 + _t1751 = _t1754 end - _t1751 = _t1753 + _t1749 = _t1751 end - _t1749 = _t1751 + _t1747 = _t1749 end - _t1747 = _t1749 + _t1745 = _t1747 end - _t1745 = _t1747 + _t1743 = _t1745 end - _t1743 = _t1745 + _t1741 = _t1743 end - _t1741 = _t1743 + _t1739 = _t1741 end - _t1739 = _t1741 + _t1737 = _t1739 end - _t1737 = _t1739 + _t1735 = _t1737 end - _t1735 = _t1737 + _t1733 = _t1735 end - _t1732 = _t1735 + _t1730 = _t1733 end - _t1729 = _t1732 + _t1727 = _t1730 end - result929 = _t1729 - record_span!(parser, span_start928, "Value") - return result929 + result928 = _t1727 + record_span!(parser, span_start927, "Value") + return result928 end function parse_date(parser::ParserState)::Proto.DateValue - span_start933 = span_start(parser) + span_start932 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - formatted_int930 = consume_terminal!(parser, "INT") - formatted_int_3931 = consume_terminal!(parser, "INT") - formatted_int_4932 = consume_terminal!(parser, "INT") + formatted_int929 = consume_terminal!(parser, "INT") + formatted_int_3930 = consume_terminal!(parser, "INT") + formatted_int_4931 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1759 = Proto.DateValue(year=Int32(formatted_int930), month=Int32(formatted_int_3931), day=Int32(formatted_int_4932)) - result934 = _t1759 - record_span!(parser, span_start933, "DateValue") - return result934 + _t1757 = Proto.DateValue(year=Int32(formatted_int929), month=Int32(formatted_int_3930), day=Int32(formatted_int_4931)) + result933 = _t1757 + record_span!(parser, span_start932, "DateValue") + return result933 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue - span_start942 = span_start(parser) + span_start941 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - formatted_int935 = consume_terminal!(parser, "INT") - formatted_int_3936 = consume_terminal!(parser, "INT") - formatted_int_4937 = consume_terminal!(parser, "INT") - formatted_int_5938 = consume_terminal!(parser, "INT") - formatted_int_6939 = consume_terminal!(parser, "INT") - formatted_int_7940 = consume_terminal!(parser, "INT") + formatted_int934 = consume_terminal!(parser, "INT") + formatted_int_3935 = consume_terminal!(parser, "INT") + formatted_int_4936 = consume_terminal!(parser, "INT") + formatted_int_5937 = consume_terminal!(parser, "INT") + formatted_int_6938 = consume_terminal!(parser, "INT") + formatted_int_7939 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1760 = consume_terminal!(parser, "INT") + _t1758 = consume_terminal!(parser, "INT") else - _t1760 = nothing + _t1758 = nothing end - formatted_int_8941 = _t1760 + formatted_int_8940 = _t1758 consume_literal!(parser, ")") - _t1761 = Proto.DateTimeValue(year=Int32(formatted_int935), month=Int32(formatted_int_3936), day=Int32(formatted_int_4937), hour=Int32(formatted_int_5938), minute=Int32(formatted_int_6939), second=Int32(formatted_int_7940), microsecond=Int32((!isnothing(formatted_int_8941) ? formatted_int_8941 : 0))) - result943 = _t1761 - record_span!(parser, span_start942, "DateTimeValue") - return result943 + _t1759 = Proto.DateTimeValue(year=Int32(formatted_int934), month=Int32(formatted_int_3935), day=Int32(formatted_int_4936), hour=Int32(formatted_int_5937), minute=Int32(formatted_int_6938), second=Int32(formatted_int_7939), microsecond=Int32((!isnothing(formatted_int_8940) ? formatted_int_8940 : 0))) + result942 = _t1759 + record_span!(parser, span_start941, "DateTimeValue") + return result942 end function parse_conjunction(parser::ParserState)::Proto.Conjunction - span_start948 = span_start(parser) + span_start947 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "and") - xs944 = Proto.Formula[] - cond945 = match_lookahead_literal(parser, "(", 0) - while cond945 - _t1762 = parse_formula(parser) - item946 = _t1762 - push!(xs944, item946) - cond945 = match_lookahead_literal(parser, "(", 0) - end - formulas947 = xs944 + xs943 = Proto.Formula[] + cond944 = match_lookahead_literal(parser, "(", 0) + while cond944 + _t1760 = parse_formula(parser) + item945 = _t1760 + push!(xs943, item945) + cond944 = match_lookahead_literal(parser, "(", 0) + end + formulas946 = xs943 consume_literal!(parser, ")") - _t1763 = Proto.Conjunction(args=formulas947) - result949 = _t1763 - record_span!(parser, span_start948, "Conjunction") - return result949 + _t1761 = Proto.Conjunction(args=formulas946) + result948 = _t1761 + record_span!(parser, span_start947, "Conjunction") + return result948 end function parse_disjunction(parser::ParserState)::Proto.Disjunction - span_start954 = span_start(parser) + span_start953 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") - xs950 = Proto.Formula[] - cond951 = match_lookahead_literal(parser, "(", 0) - while cond951 - _t1764 = parse_formula(parser) - item952 = _t1764 - push!(xs950, item952) - cond951 = match_lookahead_literal(parser, "(", 0) - end - formulas953 = xs950 + xs949 = Proto.Formula[] + cond950 = match_lookahead_literal(parser, "(", 0) + while cond950 + _t1762 = parse_formula(parser) + item951 = _t1762 + push!(xs949, item951) + cond950 = match_lookahead_literal(parser, "(", 0) + end + formulas952 = xs949 consume_literal!(parser, ")") - _t1765 = Proto.Disjunction(args=formulas953) - result955 = _t1765 - record_span!(parser, span_start954, "Disjunction") - return result955 + _t1763 = Proto.Disjunction(args=formulas952) + result954 = _t1763 + record_span!(parser, span_start953, "Disjunction") + return result954 end function parse_not(parser::ParserState)::Proto.Not - span_start957 = span_start(parser) + span_start956 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "not") - _t1766 = parse_formula(parser) - formula956 = _t1766 + _t1764 = parse_formula(parser) + formula955 = _t1764 consume_literal!(parser, ")") - _t1767 = Proto.Not(arg=formula956) - result958 = _t1767 - record_span!(parser, span_start957, "Not") - return result958 + _t1765 = Proto.Not(arg=formula955) + result957 = _t1765 + record_span!(parser, span_start956, "Not") + return result957 end function parse_ffi(parser::ParserState)::Proto.FFI - span_start962 = span_start(parser) + span_start961 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t1768 = parse_name(parser) - name959 = _t1768 - _t1769 = parse_ffi_args(parser) - ffi_args960 = _t1769 - _t1770 = parse_terms(parser) - terms961 = _t1770 + _t1766 = parse_name(parser) + name958 = _t1766 + _t1767 = parse_ffi_args(parser) + ffi_args959 = _t1767 + _t1768 = parse_terms(parser) + terms960 = _t1768 consume_literal!(parser, ")") - _t1771 = Proto.FFI(name=name959, args=ffi_args960, terms=terms961) - result963 = _t1771 - record_span!(parser, span_start962, "FFI") - return result963 + _t1769 = Proto.FFI(name=name958, args=ffi_args959, terms=terms960) + result962 = _t1769 + record_span!(parser, span_start961, "FFI") + return result962 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol964 = consume_terminal!(parser, "SYMBOL") - return symbol964 + symbol963 = consume_terminal!(parser, "SYMBOL") + return symbol963 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs965 = Proto.Abstraction[] - cond966 = match_lookahead_literal(parser, "(", 0) - while cond966 - _t1772 = parse_abstraction(parser) - item967 = _t1772 - push!(xs965, item967) - cond966 = match_lookahead_literal(parser, "(", 0) - end - abstractions968 = xs965 + xs964 = Proto.Abstraction[] + cond965 = match_lookahead_literal(parser, "(", 0) + while cond965 + _t1770 = parse_abstraction(parser) + item966 = _t1770 + push!(xs964, item966) + cond965 = match_lookahead_literal(parser, "(", 0) + end + abstractions967 = xs964 consume_literal!(parser, ")") - return abstractions968 + return abstractions967 end function parse_atom(parser::ParserState)::Proto.Atom - span_start974 = span_start(parser) + span_start973 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1773 = parse_relation_id(parser) - relation_id969 = _t1773 - xs970 = Proto.Term[] - cond971 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond971 - _t1774 = parse_term(parser) - item972 = _t1774 - push!(xs970, item972) - cond971 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - end - terms973 = xs970 + _t1771 = parse_relation_id(parser) + relation_id968 = _t1771 + xs969 = Proto.Term[] + cond970 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond970 + _t1772 = parse_term(parser) + item971 = _t1772 + push!(xs969, item971) + cond970 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + terms972 = xs969 consume_literal!(parser, ")") - _t1775 = Proto.Atom(name=relation_id969, terms=terms973) - result975 = _t1775 - record_span!(parser, span_start974, "Atom") - return result975 + _t1773 = Proto.Atom(name=relation_id968, terms=terms972) + result974 = _t1773 + record_span!(parser, span_start973, "Atom") + return result974 end function parse_pragma(parser::ParserState)::Proto.Pragma - span_start981 = span_start(parser) + span_start980 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1776 = parse_name(parser) - name976 = _t1776 - xs977 = Proto.Term[] - cond978 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond978 - _t1777 = parse_term(parser) - item979 = _t1777 - push!(xs977, item979) - cond978 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - end - terms980 = xs977 + _t1774 = parse_name(parser) + name975 = _t1774 + xs976 = Proto.Term[] + cond977 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond977 + _t1775 = parse_term(parser) + item978 = _t1775 + push!(xs976, item978) + cond977 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + terms979 = xs976 consume_literal!(parser, ")") - _t1778 = Proto.Pragma(name=name976, terms=terms980) - result982 = _t1778 - record_span!(parser, span_start981, "Pragma") - return result982 + _t1776 = Proto.Pragma(name=name975, terms=terms979) + result981 = _t1776 + record_span!(parser, span_start980, "Pragma") + return result981 end function parse_primitive(parser::ParserState)::Proto.Primitive - span_start998 = span_start(parser) + span_start997 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1780 = 9 + _t1778 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1781 = 4 + _t1779 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1782 = 3 + _t1780 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1783 = 0 + _t1781 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1784 = 2 + _t1782 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1785 = 1 + _t1783 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1786 = 8 + _t1784 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1787 = 6 + _t1785 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1788 = 5 + _t1786 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1789 = 7 + _t1787 = 7 else - _t1789 = -1 + _t1787 = -1 end - _t1788 = _t1789 + _t1786 = _t1787 end - _t1787 = _t1788 + _t1785 = _t1786 end - _t1786 = _t1787 + _t1784 = _t1785 end - _t1785 = _t1786 + _t1783 = _t1784 end - _t1784 = _t1785 + _t1782 = _t1783 end - _t1783 = _t1784 + _t1781 = _t1782 end - _t1782 = _t1783 + _t1780 = _t1781 end - _t1781 = _t1782 + _t1779 = _t1780 end - _t1780 = _t1781 + _t1778 = _t1779 end - _t1779 = _t1780 + _t1777 = _t1778 else - _t1779 = -1 + _t1777 = -1 end - prediction983 = _t1779 - if prediction983 == 9 + prediction982 = _t1777 + if prediction982 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1791 = parse_name(parser) - name993 = _t1791 - xs994 = Proto.RelTerm[] - cond995 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond995 - _t1792 = parse_rel_term(parser) - item996 = _t1792 - push!(xs994, item996) - cond995 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + _t1789 = parse_name(parser) + name992 = _t1789 + xs993 = Proto.RelTerm[] + cond994 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond994 + _t1790 = parse_rel_term(parser) + item995 = _t1790 + push!(xs993, item995) + cond994 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) end - rel_terms997 = xs994 + rel_terms996 = xs993 consume_literal!(parser, ")") - _t1793 = Proto.Primitive(name=name993, terms=rel_terms997) - _t1790 = _t1793 + _t1791 = Proto.Primitive(name=name992, terms=rel_terms996) + _t1788 = _t1791 else - if prediction983 == 8 - _t1795 = parse_divide(parser) - divide992 = _t1795 - _t1794 = divide992 + if prediction982 == 8 + _t1793 = parse_divide(parser) + divide991 = _t1793 + _t1792 = divide991 else - if prediction983 == 7 - _t1797 = parse_multiply(parser) - multiply991 = _t1797 - _t1796 = multiply991 + if prediction982 == 7 + _t1795 = parse_multiply(parser) + multiply990 = _t1795 + _t1794 = multiply990 else - if prediction983 == 6 - _t1799 = parse_minus(parser) - minus990 = _t1799 - _t1798 = minus990 + if prediction982 == 6 + _t1797 = parse_minus(parser) + minus989 = _t1797 + _t1796 = minus989 else - if prediction983 == 5 - _t1801 = parse_add(parser) - add989 = _t1801 - _t1800 = add989 + if prediction982 == 5 + _t1799 = parse_add(parser) + add988 = _t1799 + _t1798 = add988 else - if prediction983 == 4 - _t1803 = parse_gt_eq(parser) - gt_eq988 = _t1803 - _t1802 = gt_eq988 + if prediction982 == 4 + _t1801 = parse_gt_eq(parser) + gt_eq987 = _t1801 + _t1800 = gt_eq987 else - if prediction983 == 3 - _t1805 = parse_gt(parser) - gt987 = _t1805 - _t1804 = gt987 + if prediction982 == 3 + _t1803 = parse_gt(parser) + gt986 = _t1803 + _t1802 = gt986 else - if prediction983 == 2 - _t1807 = parse_lt_eq(parser) - lt_eq986 = _t1807 - _t1806 = lt_eq986 + if prediction982 == 2 + _t1805 = parse_lt_eq(parser) + lt_eq985 = _t1805 + _t1804 = lt_eq985 else - if prediction983 == 1 - _t1809 = parse_lt(parser) - lt985 = _t1809 - _t1808 = lt985 + if prediction982 == 1 + _t1807 = parse_lt(parser) + lt984 = _t1807 + _t1806 = lt984 else - if prediction983 == 0 - _t1811 = parse_eq(parser) - eq984 = _t1811 - _t1810 = eq984 + if prediction982 == 0 + _t1809 = parse_eq(parser) + eq983 = _t1809 + _t1808 = eq983 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1808 = _t1810 + _t1806 = _t1808 end - _t1806 = _t1808 + _t1804 = _t1806 end - _t1804 = _t1806 + _t1802 = _t1804 end - _t1802 = _t1804 + _t1800 = _t1802 end - _t1800 = _t1802 + _t1798 = _t1800 end - _t1798 = _t1800 + _t1796 = _t1798 end - _t1796 = _t1798 + _t1794 = _t1796 end - _t1794 = _t1796 + _t1792 = _t1794 end - _t1790 = _t1794 + _t1788 = _t1792 end - result999 = _t1790 - record_span!(parser, span_start998, "Primitive") - return result999 + result998 = _t1788 + record_span!(parser, span_start997, "Primitive") + return result998 end function parse_eq(parser::ParserState)::Proto.Primitive - span_start1002 = span_start(parser) + span_start1001 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1812 = parse_term(parser) - term1000 = _t1812 - _t1813 = parse_term(parser) - term_31001 = _t1813 + _t1810 = parse_term(parser) + term999 = _t1810 + _t1811 = parse_term(parser) + term_31000 = _t1811 consume_literal!(parser, ")") - _t1814 = Proto.RelTerm(rel_term_type=OneOf(:term, term1000)) - _t1815 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31001)) - _t1816 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1814, _t1815]) - result1003 = _t1816 - record_span!(parser, span_start1002, "Primitive") - return result1003 + _t1812 = Proto.RelTerm(rel_term_type=OneOf(:term, term999)) + _t1813 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31000)) + _t1814 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1812, _t1813]) + result1002 = _t1814 + record_span!(parser, span_start1001, "Primitive") + return result1002 end function parse_lt(parser::ParserState)::Proto.Primitive - span_start1006 = span_start(parser) + span_start1005 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1817 = parse_term(parser) - term1004 = _t1817 - _t1818 = parse_term(parser) - term_31005 = _t1818 + _t1815 = parse_term(parser) + term1003 = _t1815 + _t1816 = parse_term(parser) + term_31004 = _t1816 consume_literal!(parser, ")") - _t1819 = Proto.RelTerm(rel_term_type=OneOf(:term, term1004)) - _t1820 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31005)) - _t1821 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1819, _t1820]) - result1007 = _t1821 - record_span!(parser, span_start1006, "Primitive") - return result1007 + _t1817 = Proto.RelTerm(rel_term_type=OneOf(:term, term1003)) + _t1818 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31004)) + _t1819 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1817, _t1818]) + result1006 = _t1819 + record_span!(parser, span_start1005, "Primitive") + return result1006 end function parse_lt_eq(parser::ParserState)::Proto.Primitive - span_start1010 = span_start(parser) + span_start1009 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1822 = parse_term(parser) - term1008 = _t1822 - _t1823 = parse_term(parser) - term_31009 = _t1823 + _t1820 = parse_term(parser) + term1007 = _t1820 + _t1821 = parse_term(parser) + term_31008 = _t1821 consume_literal!(parser, ")") - _t1824 = Proto.RelTerm(rel_term_type=OneOf(:term, term1008)) - _t1825 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31009)) - _t1826 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1824, _t1825]) - result1011 = _t1826 - record_span!(parser, span_start1010, "Primitive") - return result1011 + _t1822 = Proto.RelTerm(rel_term_type=OneOf(:term, term1007)) + _t1823 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31008)) + _t1824 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1822, _t1823]) + result1010 = _t1824 + record_span!(parser, span_start1009, "Primitive") + return result1010 end function parse_gt(parser::ParserState)::Proto.Primitive - span_start1014 = span_start(parser) + span_start1013 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1827 = parse_term(parser) - term1012 = _t1827 - _t1828 = parse_term(parser) - term_31013 = _t1828 + _t1825 = parse_term(parser) + term1011 = _t1825 + _t1826 = parse_term(parser) + term_31012 = _t1826 consume_literal!(parser, ")") - _t1829 = Proto.RelTerm(rel_term_type=OneOf(:term, term1012)) - _t1830 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31013)) - _t1831 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1829, _t1830]) - result1015 = _t1831 - record_span!(parser, span_start1014, "Primitive") - return result1015 + _t1827 = Proto.RelTerm(rel_term_type=OneOf(:term, term1011)) + _t1828 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31012)) + _t1829 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1827, _t1828]) + result1014 = _t1829 + record_span!(parser, span_start1013, "Primitive") + return result1014 end function parse_gt_eq(parser::ParserState)::Proto.Primitive - span_start1018 = span_start(parser) + span_start1017 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1832 = parse_term(parser) - term1016 = _t1832 - _t1833 = parse_term(parser) - term_31017 = _t1833 + _t1830 = parse_term(parser) + term1015 = _t1830 + _t1831 = parse_term(parser) + term_31016 = _t1831 consume_literal!(parser, ")") - _t1834 = Proto.RelTerm(rel_term_type=OneOf(:term, term1016)) - _t1835 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31017)) - _t1836 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1834, _t1835]) - result1019 = _t1836 - record_span!(parser, span_start1018, "Primitive") - return result1019 + _t1832 = Proto.RelTerm(rel_term_type=OneOf(:term, term1015)) + _t1833 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31016)) + _t1834 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1832, _t1833]) + result1018 = _t1834 + record_span!(parser, span_start1017, "Primitive") + return result1018 end function parse_add(parser::ParserState)::Proto.Primitive - span_start1023 = span_start(parser) + span_start1022 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "+") + _t1835 = parse_term(parser) + term1019 = _t1835 + _t1836 = parse_term(parser) + term_31020 = _t1836 _t1837 = parse_term(parser) - term1020 = _t1837 - _t1838 = parse_term(parser) - term_31021 = _t1838 - _t1839 = parse_term(parser) - term_41022 = _t1839 + term_41021 = _t1837 consume_literal!(parser, ")") - _t1840 = Proto.RelTerm(rel_term_type=OneOf(:term, term1020)) - _t1841 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31021)) - _t1842 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41022)) - _t1843 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1840, _t1841, _t1842]) - result1024 = _t1843 - record_span!(parser, span_start1023, "Primitive") - return result1024 + _t1838 = Proto.RelTerm(rel_term_type=OneOf(:term, term1019)) + _t1839 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31020)) + _t1840 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41021)) + _t1841 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1838, _t1839, _t1840]) + result1023 = _t1841 + record_span!(parser, span_start1022, "Primitive") + return result1023 end function parse_minus(parser::ParserState)::Proto.Primitive - span_start1028 = span_start(parser) + span_start1027 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "-") + _t1842 = parse_term(parser) + term1024 = _t1842 + _t1843 = parse_term(parser) + term_31025 = _t1843 _t1844 = parse_term(parser) - term1025 = _t1844 - _t1845 = parse_term(parser) - term_31026 = _t1845 - _t1846 = parse_term(parser) - term_41027 = _t1846 + term_41026 = _t1844 consume_literal!(parser, ")") - _t1847 = Proto.RelTerm(rel_term_type=OneOf(:term, term1025)) - _t1848 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31026)) - _t1849 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41027)) - _t1850 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1847, _t1848, _t1849]) - result1029 = _t1850 - record_span!(parser, span_start1028, "Primitive") - return result1029 + _t1845 = Proto.RelTerm(rel_term_type=OneOf(:term, term1024)) + _t1846 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31025)) + _t1847 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41026)) + _t1848 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1845, _t1846, _t1847]) + result1028 = _t1848 + record_span!(parser, span_start1027, "Primitive") + return result1028 end function parse_multiply(parser::ParserState)::Proto.Primitive - span_start1033 = span_start(parser) + span_start1032 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "*") + _t1849 = parse_term(parser) + term1029 = _t1849 + _t1850 = parse_term(parser) + term_31030 = _t1850 _t1851 = parse_term(parser) - term1030 = _t1851 - _t1852 = parse_term(parser) - term_31031 = _t1852 - _t1853 = parse_term(parser) - term_41032 = _t1853 + term_41031 = _t1851 consume_literal!(parser, ")") - _t1854 = Proto.RelTerm(rel_term_type=OneOf(:term, term1030)) - _t1855 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31031)) - _t1856 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41032)) - _t1857 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1854, _t1855, _t1856]) - result1034 = _t1857 - record_span!(parser, span_start1033, "Primitive") - return result1034 + _t1852 = Proto.RelTerm(rel_term_type=OneOf(:term, term1029)) + _t1853 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31030)) + _t1854 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41031)) + _t1855 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1852, _t1853, _t1854]) + result1033 = _t1855 + record_span!(parser, span_start1032, "Primitive") + return result1033 end function parse_divide(parser::ParserState)::Proto.Primitive - span_start1038 = span_start(parser) + span_start1037 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "/") + _t1856 = parse_term(parser) + term1034 = _t1856 + _t1857 = parse_term(parser) + term_31035 = _t1857 _t1858 = parse_term(parser) - term1035 = _t1858 - _t1859 = parse_term(parser) - term_31036 = _t1859 - _t1860 = parse_term(parser) - term_41037 = _t1860 + term_41036 = _t1858 consume_literal!(parser, ")") - _t1861 = Proto.RelTerm(rel_term_type=OneOf(:term, term1035)) - _t1862 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31036)) - _t1863 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41037)) - _t1864 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1861, _t1862, _t1863]) - result1039 = _t1864 - record_span!(parser, span_start1038, "Primitive") - return result1039 + _t1859 = Proto.RelTerm(rel_term_type=OneOf(:term, term1034)) + _t1860 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31035)) + _t1861 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41036)) + _t1862 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1859, _t1860, _t1861]) + result1038 = _t1862 + record_span!(parser, span_start1037, "Primitive") + return result1038 end function parse_rel_term(parser::ParserState)::Proto.RelTerm - span_start1043 = span_start(parser) + span_start1042 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1865 = 1 + _t1863 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1866 = 1 + _t1864 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1867 = 1 + _t1865 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1868 = 1 + _t1866 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1869 = 0 + _t1867 = 0 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1870 = 1 + _t1868 = 1 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1871 = 1 + _t1869 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1872 = 1 + _t1870 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1873 = 1 + _t1871 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1874 = 1 + _t1872 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1875 = 1 + _t1873 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1876 = 1 + _t1874 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1877 = 1 + _t1875 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1878 = 1 + _t1876 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1879 = 1 + _t1877 = 1 else - _t1879 = -1 + _t1877 = -1 end - _t1878 = _t1879 + _t1876 = _t1877 end - _t1877 = _t1878 + _t1875 = _t1876 end - _t1876 = _t1877 + _t1874 = _t1875 end - _t1875 = _t1876 + _t1873 = _t1874 end - _t1874 = _t1875 + _t1872 = _t1873 end - _t1873 = _t1874 + _t1871 = _t1872 end - _t1872 = _t1873 + _t1870 = _t1871 end - _t1871 = _t1872 + _t1869 = _t1870 end - _t1870 = _t1871 + _t1868 = _t1869 end - _t1869 = _t1870 + _t1867 = _t1868 end - _t1868 = _t1869 + _t1866 = _t1867 end - _t1867 = _t1868 + _t1865 = _t1866 end - _t1866 = _t1867 + _t1864 = _t1865 end - _t1865 = _t1866 - end - prediction1040 = _t1865 - if prediction1040 == 1 - _t1881 = parse_term(parser) - term1042 = _t1881 - _t1882 = Proto.RelTerm(rel_term_type=OneOf(:term, term1042)) - _t1880 = _t1882 + _t1863 = _t1864 + end + prediction1039 = _t1863 + if prediction1039 == 1 + _t1879 = parse_term(parser) + term1041 = _t1879 + _t1880 = Proto.RelTerm(rel_term_type=OneOf(:term, term1041)) + _t1878 = _t1880 else - if prediction1040 == 0 - _t1884 = parse_specialized_value(parser) - specialized_value1041 = _t1884 - _t1885 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1041)) - _t1883 = _t1885 + if prediction1039 == 0 + _t1882 = parse_specialized_value(parser) + specialized_value1040 = _t1882 + _t1883 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1040)) + _t1881 = _t1883 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1880 = _t1883 + _t1878 = _t1881 end - result1044 = _t1880 - record_span!(parser, span_start1043, "RelTerm") - return result1044 + result1043 = _t1878 + record_span!(parser, span_start1042, "RelTerm") + return result1043 end function parse_specialized_value(parser::ParserState)::Proto.Value - span_start1046 = span_start(parser) + span_start1045 = span_start(parser) consume_literal!(parser, "#") - _t1886 = parse_raw_value(parser) - raw_value1045 = _t1886 - result1047 = raw_value1045 - record_span!(parser, span_start1046, "Value") - return result1047 + _t1884 = parse_raw_value(parser) + raw_value1044 = _t1884 + result1046 = raw_value1044 + record_span!(parser, span_start1045, "Value") + return result1046 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom - span_start1053 = span_start(parser) + span_start1052 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1887 = parse_name(parser) - name1048 = _t1887 - xs1049 = Proto.RelTerm[] - cond1050 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - while cond1050 - _t1888 = parse_rel_term(parser) - item1051 = _t1888 - push!(xs1049, item1051) - cond1050 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) - end - rel_terms1052 = xs1049 + _t1885 = parse_name(parser) + name1047 = _t1885 + xs1048 = Proto.RelTerm[] + cond1049 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond1049 + _t1886 = parse_rel_term(parser) + item1050 = _t1886 + push!(xs1048, item1050) + cond1049 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + rel_terms1051 = xs1048 consume_literal!(parser, ")") - _t1889 = Proto.RelAtom(name=name1048, terms=rel_terms1052) - result1054 = _t1889 - record_span!(parser, span_start1053, "RelAtom") - return result1054 + _t1887 = Proto.RelAtom(name=name1047, terms=rel_terms1051) + result1053 = _t1887 + record_span!(parser, span_start1052, "RelAtom") + return result1053 end function parse_cast(parser::ParserState)::Proto.Cast - span_start1057 = span_start(parser) + span_start1056 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1890 = parse_term(parser) - term1055 = _t1890 - _t1891 = parse_term(parser) - term_31056 = _t1891 + _t1888 = parse_term(parser) + term1054 = _t1888 + _t1889 = parse_term(parser) + term_31055 = _t1889 consume_literal!(parser, ")") - _t1892 = Proto.Cast(input=term1055, result=term_31056) - result1058 = _t1892 - record_span!(parser, span_start1057, "Cast") - return result1058 + _t1890 = Proto.Cast(input=term1054, result=term_31055) + result1057 = _t1890 + record_span!(parser, span_start1056, "Cast") + return result1057 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs1059 = Proto.Attribute[] - cond1060 = match_lookahead_literal(parser, "(", 0) - while cond1060 - _t1893 = parse_attribute(parser) - item1061 = _t1893 - push!(xs1059, item1061) - cond1060 = match_lookahead_literal(parser, "(", 0) - end - attributes1062 = xs1059 + xs1058 = Proto.Attribute[] + cond1059 = match_lookahead_literal(parser, "(", 0) + while cond1059 + _t1891 = parse_attribute(parser) + item1060 = _t1891 + push!(xs1058, item1060) + cond1059 = match_lookahead_literal(parser, "(", 0) + end + attributes1061 = xs1058 consume_literal!(parser, ")") - return attributes1062 + return attributes1061 end function parse_attribute(parser::ParserState)::Proto.Attribute - span_start1068 = span_start(parser) + span_start1067 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1894 = parse_name(parser) - name1063 = _t1894 - xs1064 = Proto.Value[] - cond1065 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) - while cond1065 - _t1895 = parse_raw_value(parser) - item1066 = _t1895 - push!(xs1064, item1066) - cond1065 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) - end - raw_values1067 = xs1064 + _t1892 = parse_name(parser) + name1062 = _t1892 + xs1063 = Proto.Value[] + cond1064 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) + while cond1064 + _t1893 = parse_raw_value(parser) + item1065 = _t1893 + push!(xs1063, item1065) + cond1064 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) + end + raw_values1066 = xs1063 consume_literal!(parser, ")") - _t1896 = Proto.Attribute(name=name1063, args=raw_values1067) - result1069 = _t1896 - record_span!(parser, span_start1068, "Attribute") - return result1069 + _t1894 = Proto.Attribute(name=name1062, args=raw_values1066) + result1068 = _t1894 + record_span!(parser, span_start1067, "Attribute") + return result1068 end function parse_algorithm(parser::ParserState)::Proto.Algorithm - span_start1076 = span_start(parser) + span_start1075 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs1070 = Proto.RelationId[] - cond1071 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1071 - _t1897 = parse_relation_id(parser) - item1072 = _t1897 - push!(xs1070, item1072) - cond1071 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1073 = xs1070 - _t1898 = parse_script(parser) - script1074 = _t1898 + xs1069 = Proto.RelationId[] + cond1070 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1070 + _t1895 = parse_relation_id(parser) + item1071 = _t1895 + push!(xs1069, item1071) + cond1070 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1072 = xs1069 + _t1896 = parse_script(parser) + script1073 = _t1896 if match_lookahead_literal(parser, "(", 0) - _t1900 = parse_attrs(parser) - _t1899 = _t1900 + _t1898 = parse_attrs(parser) + _t1897 = _t1898 else - _t1899 = nothing + _t1897 = nothing end - attrs1075 = _t1899 + attrs1074 = _t1897 consume_literal!(parser, ")") - _t1901 = Proto.Algorithm(var"#global"=relation_ids1073, body=script1074, attrs=(!isnothing(attrs1075) ? attrs1075 : Proto.Attribute[])) - result1077 = _t1901 - record_span!(parser, span_start1076, "Algorithm") - return result1077 + _t1899 = Proto.Algorithm(var"#global"=relation_ids1072, body=script1073, attrs=(!isnothing(attrs1074) ? attrs1074 : Proto.Attribute[])) + result1076 = _t1899 + record_span!(parser, span_start1075, "Algorithm") + return result1076 end function parse_script(parser::ParserState)::Proto.Script - span_start1082 = span_start(parser) + span_start1081 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "script") - xs1078 = Proto.Construct[] - cond1079 = match_lookahead_literal(parser, "(", 0) - while cond1079 - _t1902 = parse_construct(parser) - item1080 = _t1902 - push!(xs1078, item1080) - cond1079 = match_lookahead_literal(parser, "(", 0) - end - constructs1081 = xs1078 + xs1077 = Proto.Construct[] + cond1078 = match_lookahead_literal(parser, "(", 0) + while cond1078 + _t1900 = parse_construct(parser) + item1079 = _t1900 + push!(xs1077, item1079) + cond1078 = match_lookahead_literal(parser, "(", 0) + end + constructs1080 = xs1077 consume_literal!(parser, ")") - _t1903 = Proto.Script(constructs=constructs1081) - result1083 = _t1903 - record_span!(parser, span_start1082, "Script") - return result1083 + _t1901 = Proto.Script(constructs=constructs1080) + result1082 = _t1901 + record_span!(parser, span_start1081, "Script") + return result1082 end function parse_construct(parser::ParserState)::Proto.Construct - span_start1087 = span_start(parser) + span_start1086 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1905 = 1 + _t1903 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1906 = 1 + _t1904 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1907 = 1 + _t1905 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1908 = 0 + _t1906 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1909 = 1 + _t1907 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1910 = 1 + _t1908 = 1 else - _t1910 = -1 + _t1908 = -1 end - _t1909 = _t1910 + _t1907 = _t1908 end - _t1908 = _t1909 + _t1906 = _t1907 end - _t1907 = _t1908 + _t1905 = _t1906 end - _t1906 = _t1907 + _t1904 = _t1905 end - _t1905 = _t1906 + _t1903 = _t1904 end - _t1904 = _t1905 + _t1902 = _t1903 else - _t1904 = -1 - end - prediction1084 = _t1904 - if prediction1084 == 1 - _t1912 = parse_instruction(parser) - instruction1086 = _t1912 - _t1913 = Proto.Construct(construct_type=OneOf(:instruction, instruction1086)) - _t1911 = _t1913 + _t1902 = -1 + end + prediction1083 = _t1902 + if prediction1083 == 1 + _t1910 = parse_instruction(parser) + instruction1085 = _t1910 + _t1911 = Proto.Construct(construct_type=OneOf(:instruction, instruction1085)) + _t1909 = _t1911 else - if prediction1084 == 0 - _t1915 = parse_loop(parser) - loop1085 = _t1915 - _t1916 = Proto.Construct(construct_type=OneOf(:loop, loop1085)) - _t1914 = _t1916 + if prediction1083 == 0 + _t1913 = parse_loop(parser) + loop1084 = _t1913 + _t1914 = Proto.Construct(construct_type=OneOf(:loop, loop1084)) + _t1912 = _t1914 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1911 = _t1914 + _t1909 = _t1912 end - result1088 = _t1911 - record_span!(parser, span_start1087, "Construct") - return result1088 + result1087 = _t1909 + record_span!(parser, span_start1086, "Construct") + return result1087 end function parse_loop(parser::ParserState)::Proto.Loop - span_start1092 = span_start(parser) + span_start1091 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1917 = parse_init(parser) - init1089 = _t1917 - _t1918 = parse_script(parser) - script1090 = _t1918 + _t1915 = parse_init(parser) + init1088 = _t1915 + _t1916 = parse_script(parser) + script1089 = _t1916 if match_lookahead_literal(parser, "(", 0) - _t1920 = parse_attrs(parser) - _t1919 = _t1920 + _t1918 = parse_attrs(parser) + _t1917 = _t1918 else - _t1919 = nothing + _t1917 = nothing end - attrs1091 = _t1919 + attrs1090 = _t1917 consume_literal!(parser, ")") - _t1921 = Proto.Loop(init=init1089, body=script1090, attrs=(!isnothing(attrs1091) ? attrs1091 : Proto.Attribute[])) - result1093 = _t1921 - record_span!(parser, span_start1092, "Loop") - return result1093 + _t1919 = Proto.Loop(init=init1088, body=script1089, attrs=(!isnothing(attrs1090) ? attrs1090 : Proto.Attribute[])) + result1092 = _t1919 + record_span!(parser, span_start1091, "Loop") + return result1092 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs1094 = Proto.Instruction[] - cond1095 = match_lookahead_literal(parser, "(", 0) - while cond1095 - _t1922 = parse_instruction(parser) - item1096 = _t1922 - push!(xs1094, item1096) - cond1095 = match_lookahead_literal(parser, "(", 0) - end - instructions1097 = xs1094 + xs1093 = Proto.Instruction[] + cond1094 = match_lookahead_literal(parser, "(", 0) + while cond1094 + _t1920 = parse_instruction(parser) + item1095 = _t1920 + push!(xs1093, item1095) + cond1094 = match_lookahead_literal(parser, "(", 0) + end + instructions1096 = xs1093 consume_literal!(parser, ")") - return instructions1097 + return instructions1096 end function parse_instruction(parser::ParserState)::Proto.Instruction - span_start1104 = span_start(parser) + span_start1103 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1924 = 1 + _t1922 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1925 = 4 + _t1923 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1926 = 3 + _t1924 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1927 = 2 + _t1925 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1928 = 0 + _t1926 = 0 else - _t1928 = -1 + _t1926 = -1 end - _t1927 = _t1928 + _t1925 = _t1926 end - _t1926 = _t1927 + _t1924 = _t1925 end - _t1925 = _t1926 + _t1923 = _t1924 end - _t1924 = _t1925 + _t1922 = _t1923 end - _t1923 = _t1924 + _t1921 = _t1922 else - _t1923 = -1 - end - prediction1098 = _t1923 - if prediction1098 == 4 - _t1930 = parse_monus_def(parser) - monus_def1103 = _t1930 - _t1931 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1103)) - _t1929 = _t1931 + _t1921 = -1 + end + prediction1097 = _t1921 + if prediction1097 == 4 + _t1928 = parse_monus_def(parser) + monus_def1102 = _t1928 + _t1929 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1102)) + _t1927 = _t1929 else - if prediction1098 == 3 - _t1933 = parse_monoid_def(parser) - monoid_def1102 = _t1933 - _t1934 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1102)) - _t1932 = _t1934 + if prediction1097 == 3 + _t1931 = parse_monoid_def(parser) + monoid_def1101 = _t1931 + _t1932 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1101)) + _t1930 = _t1932 else - if prediction1098 == 2 - _t1936 = parse_break(parser) - break1101 = _t1936 - _t1937 = Proto.Instruction(instr_type=OneOf(:var"#break", break1101)) - _t1935 = _t1937 + if prediction1097 == 2 + _t1934 = parse_break(parser) + break1100 = _t1934 + _t1935 = Proto.Instruction(instr_type=OneOf(:var"#break", break1100)) + _t1933 = _t1935 else - if prediction1098 == 1 - _t1939 = parse_upsert(parser) - upsert1100 = _t1939 - _t1940 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1100)) - _t1938 = _t1940 + if prediction1097 == 1 + _t1937 = parse_upsert(parser) + upsert1099 = _t1937 + _t1938 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1099)) + _t1936 = _t1938 else - if prediction1098 == 0 - _t1942 = parse_assign(parser) - assign1099 = _t1942 - _t1943 = Proto.Instruction(instr_type=OneOf(:assign, assign1099)) - _t1941 = _t1943 + if prediction1097 == 0 + _t1940 = parse_assign(parser) + assign1098 = _t1940 + _t1941 = Proto.Instruction(instr_type=OneOf(:assign, assign1098)) + _t1939 = _t1941 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1938 = _t1941 + _t1936 = _t1939 end - _t1935 = _t1938 + _t1933 = _t1936 end - _t1932 = _t1935 + _t1930 = _t1933 end - _t1929 = _t1932 + _t1927 = _t1930 end - result1105 = _t1929 - record_span!(parser, span_start1104, "Instruction") - return result1105 + result1104 = _t1927 + record_span!(parser, span_start1103, "Instruction") + return result1104 end function parse_assign(parser::ParserState)::Proto.Assign - span_start1109 = span_start(parser) + span_start1108 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1944 = parse_relation_id(parser) - relation_id1106 = _t1944 - _t1945 = parse_abstraction(parser) - abstraction1107 = _t1945 + _t1942 = parse_relation_id(parser) + relation_id1105 = _t1942 + _t1943 = parse_abstraction(parser) + abstraction1106 = _t1943 if match_lookahead_literal(parser, "(", 0) - _t1947 = parse_attrs(parser) - _t1946 = _t1947 + _t1945 = parse_attrs(parser) + _t1944 = _t1945 else - _t1946 = nothing + _t1944 = nothing end - attrs1108 = _t1946 + attrs1107 = _t1944 consume_literal!(parser, ")") - _t1948 = Proto.Assign(name=relation_id1106, body=abstraction1107, attrs=(!isnothing(attrs1108) ? attrs1108 : Proto.Attribute[])) - result1110 = _t1948 - record_span!(parser, span_start1109, "Assign") - return result1110 + _t1946 = Proto.Assign(name=relation_id1105, body=abstraction1106, attrs=(!isnothing(attrs1107) ? attrs1107 : Proto.Attribute[])) + result1109 = _t1946 + record_span!(parser, span_start1108, "Assign") + return result1109 end function parse_upsert(parser::ParserState)::Proto.Upsert - span_start1114 = span_start(parser) + span_start1113 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1949 = parse_relation_id(parser) - relation_id1111 = _t1949 - _t1950 = parse_abstraction_with_arity(parser) - abstraction_with_arity1112 = _t1950 + _t1947 = parse_relation_id(parser) + relation_id1110 = _t1947 + _t1948 = parse_abstraction_with_arity(parser) + abstraction_with_arity1111 = _t1948 if match_lookahead_literal(parser, "(", 0) - _t1952 = parse_attrs(parser) - _t1951 = _t1952 + _t1950 = parse_attrs(parser) + _t1949 = _t1950 else - _t1951 = nothing + _t1949 = nothing end - attrs1113 = _t1951 + attrs1112 = _t1949 consume_literal!(parser, ")") - _t1953 = Proto.Upsert(name=relation_id1111, body=abstraction_with_arity1112[1], attrs=(!isnothing(attrs1113) ? attrs1113 : Proto.Attribute[]), value_arity=abstraction_with_arity1112[2]) - result1115 = _t1953 - record_span!(parser, span_start1114, "Upsert") - return result1115 + _t1951 = Proto.Upsert(name=relation_id1110, body=abstraction_with_arity1111[1], attrs=(!isnothing(attrs1112) ? attrs1112 : Proto.Attribute[]), value_arity=abstraction_with_arity1111[2]) + result1114 = _t1951 + record_span!(parser, span_start1113, "Upsert") + return result1114 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1954 = parse_bindings(parser) - bindings1116 = _t1954 - _t1955 = parse_formula(parser) - formula1117 = _t1955 + _t1952 = parse_bindings(parser) + bindings1115 = _t1952 + _t1953 = parse_formula(parser) + formula1116 = _t1953 consume_literal!(parser, ")") - _t1956 = Proto.Abstraction(vars=vcat(bindings1116[1], !isnothing(bindings1116[2]) ? bindings1116[2] : []), value=formula1117) - return (_t1956, length(bindings1116[2]),) + _t1954 = Proto.Abstraction(vars=vcat(bindings1115[1], !isnothing(bindings1115[2]) ? bindings1115[2] : []), value=formula1116) + return (_t1954, length(bindings1115[2]),) end function parse_break(parser::ParserState)::Proto.Break - span_start1121 = span_start(parser) + span_start1120 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1957 = parse_relation_id(parser) - relation_id1118 = _t1957 - _t1958 = parse_abstraction(parser) - abstraction1119 = _t1958 + _t1955 = parse_relation_id(parser) + relation_id1117 = _t1955 + _t1956 = parse_abstraction(parser) + abstraction1118 = _t1956 if match_lookahead_literal(parser, "(", 0) - _t1960 = parse_attrs(parser) - _t1959 = _t1960 + _t1958 = parse_attrs(parser) + _t1957 = _t1958 else - _t1959 = nothing + _t1957 = nothing end - attrs1120 = _t1959 + attrs1119 = _t1957 consume_literal!(parser, ")") - _t1961 = Proto.Break(name=relation_id1118, body=abstraction1119, attrs=(!isnothing(attrs1120) ? attrs1120 : Proto.Attribute[])) - result1122 = _t1961 - record_span!(parser, span_start1121, "Break") - return result1122 + _t1959 = Proto.Break(name=relation_id1117, body=abstraction1118, attrs=(!isnothing(attrs1119) ? attrs1119 : Proto.Attribute[])) + result1121 = _t1959 + record_span!(parser, span_start1120, "Break") + return result1121 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef - span_start1127 = span_start(parser) + span_start1126 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1962 = parse_monoid(parser) - monoid1123 = _t1962 - _t1963 = parse_relation_id(parser) - relation_id1124 = _t1963 - _t1964 = parse_abstraction_with_arity(parser) - abstraction_with_arity1125 = _t1964 + _t1960 = parse_monoid(parser) + monoid1122 = _t1960 + _t1961 = parse_relation_id(parser) + relation_id1123 = _t1961 + _t1962 = parse_abstraction_with_arity(parser) + abstraction_with_arity1124 = _t1962 if match_lookahead_literal(parser, "(", 0) - _t1966 = parse_attrs(parser) - _t1965 = _t1966 + _t1964 = parse_attrs(parser) + _t1963 = _t1964 else - _t1965 = nothing + _t1963 = nothing end - attrs1126 = _t1965 + attrs1125 = _t1963 consume_literal!(parser, ")") - _t1967 = Proto.MonoidDef(monoid=monoid1123, name=relation_id1124, body=abstraction_with_arity1125[1], attrs=(!isnothing(attrs1126) ? attrs1126 : Proto.Attribute[]), value_arity=abstraction_with_arity1125[2]) - result1128 = _t1967 - record_span!(parser, span_start1127, "MonoidDef") - return result1128 + _t1965 = Proto.MonoidDef(monoid=monoid1122, name=relation_id1123, body=abstraction_with_arity1124[1], attrs=(!isnothing(attrs1125) ? attrs1125 : Proto.Attribute[]), value_arity=abstraction_with_arity1124[2]) + result1127 = _t1965 + record_span!(parser, span_start1126, "MonoidDef") + return result1127 end function parse_monoid(parser::ParserState)::Proto.Monoid - span_start1134 = span_start(parser) + span_start1133 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1969 = 3 + _t1967 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1970 = 0 + _t1968 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1971 = 1 + _t1969 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1972 = 2 + _t1970 = 2 else - _t1972 = -1 + _t1970 = -1 end - _t1971 = _t1972 + _t1969 = _t1970 end - _t1970 = _t1971 + _t1968 = _t1969 end - _t1969 = _t1970 + _t1967 = _t1968 end - _t1968 = _t1969 + _t1966 = _t1967 else - _t1968 = -1 - end - prediction1129 = _t1968 - if prediction1129 == 3 - _t1974 = parse_sum_monoid(parser) - sum_monoid1133 = _t1974 - _t1975 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1133)) - _t1973 = _t1975 + _t1966 = -1 + end + prediction1128 = _t1966 + if prediction1128 == 3 + _t1972 = parse_sum_monoid(parser) + sum_monoid1132 = _t1972 + _t1973 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1132)) + _t1971 = _t1973 else - if prediction1129 == 2 - _t1977 = parse_max_monoid(parser) - max_monoid1132 = _t1977 - _t1978 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1132)) - _t1976 = _t1978 + if prediction1128 == 2 + _t1975 = parse_max_monoid(parser) + max_monoid1131 = _t1975 + _t1976 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1131)) + _t1974 = _t1976 else - if prediction1129 == 1 - _t1980 = parse_min_monoid(parser) - min_monoid1131 = _t1980 - _t1981 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1131)) - _t1979 = _t1981 + if prediction1128 == 1 + _t1978 = parse_min_monoid(parser) + min_monoid1130 = _t1978 + _t1979 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1130)) + _t1977 = _t1979 else - if prediction1129 == 0 - _t1983 = parse_or_monoid(parser) - or_monoid1130 = _t1983 - _t1984 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1130)) - _t1982 = _t1984 + if prediction1128 == 0 + _t1981 = parse_or_monoid(parser) + or_monoid1129 = _t1981 + _t1982 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1129)) + _t1980 = _t1982 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1979 = _t1982 + _t1977 = _t1980 end - _t1976 = _t1979 + _t1974 = _t1977 end - _t1973 = _t1976 + _t1971 = _t1974 end - result1135 = _t1973 - record_span!(parser, span_start1134, "Monoid") - return result1135 + result1134 = _t1971 + record_span!(parser, span_start1133, "Monoid") + return result1134 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid - span_start1136 = span_start(parser) + span_start1135 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1985 = Proto.OrMonoid() - result1137 = _t1985 - record_span!(parser, span_start1136, "OrMonoid") - return result1137 + _t1983 = Proto.OrMonoid() + result1136 = _t1983 + record_span!(parser, span_start1135, "OrMonoid") + return result1136 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid - span_start1139 = span_start(parser) + span_start1138 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1986 = parse_type(parser) - type1138 = _t1986 + _t1984 = parse_type(parser) + type1137 = _t1984 consume_literal!(parser, ")") - _t1987 = Proto.MinMonoid(var"#type"=type1138) - result1140 = _t1987 - record_span!(parser, span_start1139, "MinMonoid") - return result1140 + _t1985 = Proto.MinMonoid(var"#type"=type1137) + result1139 = _t1985 + record_span!(parser, span_start1138, "MinMonoid") + return result1139 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid - span_start1142 = span_start(parser) + span_start1141 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1988 = parse_type(parser) - type1141 = _t1988 + _t1986 = parse_type(parser) + type1140 = _t1986 consume_literal!(parser, ")") - _t1989 = Proto.MaxMonoid(var"#type"=type1141) - result1143 = _t1989 - record_span!(parser, span_start1142, "MaxMonoid") - return result1143 + _t1987 = Proto.MaxMonoid(var"#type"=type1140) + result1142 = _t1987 + record_span!(parser, span_start1141, "MaxMonoid") + return result1142 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid - span_start1145 = span_start(parser) + span_start1144 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1990 = parse_type(parser) - type1144 = _t1990 + _t1988 = parse_type(parser) + type1143 = _t1988 consume_literal!(parser, ")") - _t1991 = Proto.SumMonoid(var"#type"=type1144) - result1146 = _t1991 - record_span!(parser, span_start1145, "SumMonoid") - return result1146 + _t1989 = Proto.SumMonoid(var"#type"=type1143) + result1145 = _t1989 + record_span!(parser, span_start1144, "SumMonoid") + return result1145 end function parse_monus_def(parser::ParserState)::Proto.MonusDef - span_start1151 = span_start(parser) + span_start1150 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1992 = parse_monoid(parser) - monoid1147 = _t1992 - _t1993 = parse_relation_id(parser) - relation_id1148 = _t1993 - _t1994 = parse_abstraction_with_arity(parser) - abstraction_with_arity1149 = _t1994 + _t1990 = parse_monoid(parser) + monoid1146 = _t1990 + _t1991 = parse_relation_id(parser) + relation_id1147 = _t1991 + _t1992 = parse_abstraction_with_arity(parser) + abstraction_with_arity1148 = _t1992 if match_lookahead_literal(parser, "(", 0) - _t1996 = parse_attrs(parser) - _t1995 = _t1996 + _t1994 = parse_attrs(parser) + _t1993 = _t1994 else - _t1995 = nothing + _t1993 = nothing end - attrs1150 = _t1995 + attrs1149 = _t1993 consume_literal!(parser, ")") - _t1997 = Proto.MonusDef(monoid=monoid1147, name=relation_id1148, body=abstraction_with_arity1149[1], attrs=(!isnothing(attrs1150) ? attrs1150 : Proto.Attribute[]), value_arity=abstraction_with_arity1149[2]) - result1152 = _t1997 - record_span!(parser, span_start1151, "MonusDef") - return result1152 + _t1995 = Proto.MonusDef(monoid=monoid1146, name=relation_id1147, body=abstraction_with_arity1148[1], attrs=(!isnothing(attrs1149) ? attrs1149 : Proto.Attribute[]), value_arity=abstraction_with_arity1148[2]) + result1151 = _t1995 + record_span!(parser, span_start1150, "MonusDef") + return result1151 end function parse_constraint(parser::ParserState)::Proto.Constraint - span_start1157 = span_start(parser) + span_start1156 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1998 = parse_relation_id(parser) - relation_id1153 = _t1998 - _t1999 = parse_abstraction(parser) - abstraction1154 = _t1999 - _t2000 = parse_functional_dependency_keys(parser) - functional_dependency_keys1155 = _t2000 - _t2001 = parse_functional_dependency_values(parser) - functional_dependency_values1156 = _t2001 + _t1996 = parse_relation_id(parser) + relation_id1152 = _t1996 + _t1997 = parse_abstraction(parser) + abstraction1153 = _t1997 + _t1998 = parse_functional_dependency_keys(parser) + functional_dependency_keys1154 = _t1998 + _t1999 = parse_functional_dependency_values(parser) + functional_dependency_values1155 = _t1999 consume_literal!(parser, ")") - _t2002 = Proto.FunctionalDependency(guard=abstraction1154, keys=functional_dependency_keys1155, values=functional_dependency_values1156) - _t2003 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t2002), name=relation_id1153) - result1158 = _t2003 - record_span!(parser, span_start1157, "Constraint") - return result1158 + _t2000 = Proto.FunctionalDependency(guard=abstraction1153, keys=functional_dependency_keys1154, values=functional_dependency_values1155) + _t2001 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t2000), name=relation_id1152) + result1157 = _t2001 + record_span!(parser, span_start1156, "Constraint") + return result1157 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1159 = Proto.Var[] - cond1160 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1160 - _t2004 = parse_var(parser) - item1161 = _t2004 - push!(xs1159, item1161) - cond1160 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1162 = xs1159 + xs1158 = Proto.Var[] + cond1159 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1159 + _t2002 = parse_var(parser) + item1160 = _t2002 + push!(xs1158, item1160) + cond1159 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1161 = xs1158 consume_literal!(parser, ")") - return vars1162 + return vars1161 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs1163 = Proto.Var[] - cond1164 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1164 - _t2005 = parse_var(parser) - item1165 = _t2005 - push!(xs1163, item1165) - cond1164 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1166 = xs1163 + xs1162 = Proto.Var[] + cond1163 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1163 + _t2003 = parse_var(parser) + item1164 = _t2003 + push!(xs1162, item1164) + cond1163 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1165 = xs1162 consume_literal!(parser, ")") - return vars1166 + return vars1165 end function parse_data(parser::ParserState)::Proto.Data - span_start1172 = span_start(parser) + span_start1171 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t2007 = 3 + _t2005 = 3 else if match_lookahead_literal(parser, "edb", 1) - _t2008 = 0 + _t2006 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t2009 = 2 + _t2007 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t2010 = 1 + _t2008 = 1 else - _t2010 = -1 + _t2008 = -1 end - _t2009 = _t2010 + _t2007 = _t2008 end - _t2008 = _t2009 + _t2006 = _t2007 end - _t2007 = _t2008 + _t2005 = _t2006 end - _t2006 = _t2007 + _t2004 = _t2005 else - _t2006 = -1 - end - prediction1167 = _t2006 - if prediction1167 == 3 - _t2012 = parse_iceberg_data(parser) - iceberg_data1171 = _t2012 - _t2013 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1171)) - _t2011 = _t2013 + _t2004 = -1 + end + prediction1166 = _t2004 + if prediction1166 == 3 + _t2010 = parse_iceberg_data(parser) + iceberg_data1170 = _t2010 + _t2011 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1170)) + _t2009 = _t2011 else - if prediction1167 == 2 - _t2015 = parse_csv_data(parser) - csv_data1170 = _t2015 - _t2016 = Proto.Data(data_type=OneOf(:csv_data, csv_data1170)) - _t2014 = _t2016 + if prediction1166 == 2 + _t2013 = parse_csv_data(parser) + csv_data1169 = _t2013 + _t2014 = Proto.Data(data_type=OneOf(:csv_data, csv_data1169)) + _t2012 = _t2014 else - if prediction1167 == 1 - _t2018 = parse_betree_relation(parser) - betree_relation1169 = _t2018 - _t2019 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1169)) - _t2017 = _t2019 + if prediction1166 == 1 + _t2016 = parse_betree_relation(parser) + betree_relation1168 = _t2016 + _t2017 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1168)) + _t2015 = _t2017 else - if prediction1167 == 0 - _t2021 = parse_edb(parser) - edb1168 = _t2021 - _t2022 = Proto.Data(data_type=OneOf(:edb, edb1168)) - _t2020 = _t2022 + if prediction1166 == 0 + _t2019 = parse_edb(parser) + edb1167 = _t2019 + _t2020 = Proto.Data(data_type=OneOf(:edb, edb1167)) + _t2018 = _t2020 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t2017 = _t2020 + _t2015 = _t2018 end - _t2014 = _t2017 + _t2012 = _t2015 end - _t2011 = _t2014 + _t2009 = _t2012 end - result1173 = _t2011 - record_span!(parser, span_start1172, "Data") - return result1173 + result1172 = _t2009 + record_span!(parser, span_start1171, "Data") + return result1172 end function parse_edb(parser::ParserState)::Proto.EDB - span_start1177 = span_start(parser) + span_start1176 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "edb") - _t2023 = parse_relation_id(parser) - relation_id1174 = _t2023 - _t2024 = parse_edb_path(parser) - edb_path1175 = _t2024 - _t2025 = parse_edb_types(parser) - edb_types1176 = _t2025 + _t2021 = parse_relation_id(parser) + relation_id1173 = _t2021 + _t2022 = parse_edb_path(parser) + edb_path1174 = _t2022 + _t2023 = parse_edb_types(parser) + edb_types1175 = _t2023 consume_literal!(parser, ")") - _t2026 = Proto.EDB(target_id=relation_id1174, path=edb_path1175, types=edb_types1176) - result1178 = _t2026 - record_span!(parser, span_start1177, "EDB") - return result1178 + _t2024 = Proto.EDB(target_id=relation_id1173, path=edb_path1174, types=edb_types1175) + result1177 = _t2024 + record_span!(parser, span_start1176, "EDB") + return result1177 end function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs1179 = String[] - cond1180 = match_lookahead_terminal(parser, "STRING", 0) - while cond1180 - item1181 = consume_terminal!(parser, "STRING") - push!(xs1179, item1181) - cond1180 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1182 = xs1179 + xs1178 = String[] + cond1179 = match_lookahead_terminal(parser, "STRING", 0) + while cond1179 + item1180 = consume_terminal!(parser, "STRING") + push!(xs1178, item1180) + cond1179 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1181 = xs1178 consume_literal!(parser, "]") - return strings1182 + return strings1181 end function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs1183 = Proto.var"#Type"[] - cond1184 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1184 - _t2027 = parse_type(parser) - item1185 = _t2027 - push!(xs1183, item1185) - cond1184 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1186 = xs1183 + xs1182 = Proto.var"#Type"[] + cond1183 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1183 + _t2025 = parse_type(parser) + item1184 = _t2025 + push!(xs1182, item1184) + cond1183 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1185 = xs1182 consume_literal!(parser, "]") - return types1186 + return types1185 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation - span_start1189 = span_start(parser) + span_start1188 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t2028 = parse_relation_id(parser) - relation_id1187 = _t2028 - _t2029 = parse_betree_info(parser) - betree_info1188 = _t2029 + _t2026 = parse_relation_id(parser) + relation_id1186 = _t2026 + _t2027 = parse_betree_info(parser) + betree_info1187 = _t2027 consume_literal!(parser, ")") - _t2030 = Proto.BeTreeRelation(name=relation_id1187, relation_info=betree_info1188) - result1190 = _t2030 - record_span!(parser, span_start1189, "BeTreeRelation") - return result1190 + _t2028 = Proto.BeTreeRelation(name=relation_id1186, relation_info=betree_info1187) + result1189 = _t2028 + record_span!(parser, span_start1188, "BeTreeRelation") + return result1189 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo - span_start1194 = span_start(parser) + span_start1193 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t2031 = parse_betree_info_key_types(parser) - betree_info_key_types1191 = _t2031 - _t2032 = parse_betree_info_value_types(parser) - betree_info_value_types1192 = _t2032 - _t2033 = parse_config_dict(parser) - config_dict1193 = _t2033 + _t2029 = parse_betree_info_key_types(parser) + betree_info_key_types1190 = _t2029 + _t2030 = parse_betree_info_value_types(parser) + betree_info_value_types1191 = _t2030 + _t2031 = parse_config_dict(parser) + config_dict1192 = _t2031 consume_literal!(parser, ")") - _t2034 = construct_betree_info(parser, betree_info_key_types1191, betree_info_value_types1192, config_dict1193) - result1195 = _t2034 - record_span!(parser, span_start1194, "BeTreeInfo") - return result1195 + _t2032 = construct_betree_info(parser, betree_info_key_types1190, betree_info_value_types1191, config_dict1192) + result1194 = _t2032 + record_span!(parser, span_start1193, "BeTreeInfo") + return result1194 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs1196 = Proto.var"#Type"[] - cond1197 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1197 - _t2035 = parse_type(parser) - item1198 = _t2035 - push!(xs1196, item1198) - cond1197 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1199 = xs1196 + xs1195 = Proto.var"#Type"[] + cond1196 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1196 + _t2033 = parse_type(parser) + item1197 = _t2033 + push!(xs1195, item1197) + cond1196 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1198 = xs1195 consume_literal!(parser, ")") - return types1199 + return types1198 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs1200 = Proto.var"#Type"[] - cond1201 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1201 - _t2036 = parse_type(parser) - item1202 = _t2036 - push!(xs1200, item1202) - cond1201 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1203 = xs1200 + xs1199 = Proto.var"#Type"[] + cond1200 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1200 + _t2034 = parse_type(parser) + item1201 = _t2034 + push!(xs1199, item1201) + cond1200 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1202 = xs1199 consume_literal!(parser, ")") - return types1203 + return types1202 end function parse_csv_data(parser::ParserState)::Proto.CSVData - span_start1209 = span_start(parser) + span_start1208 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t2037 = parse_csvlocator(parser) - csvlocator1204 = _t2037 - _t2038 = parse_csv_config(parser) - csv_config1205 = _t2038 + _t2035 = parse_csvlocator(parser) + csvlocator1203 = _t2035 + _t2036 = parse_csv_config(parser) + csv_config1204 = _t2036 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "columns", 1)) - _t2040 = parse_gnf_columns(parser) - _t2039 = _t2040 + _t2038 = parse_gnf_columns(parser) + _t2037 = _t2038 else - _t2039 = nothing + _t2037 = nothing end - gnf_columns1206 = _t2039 + gnf_columns1205 = _t2037 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "relations", 1)) - _t2042 = parse_target_relations(parser) - _t2041 = _t2042 + _t2040 = parse_target_relations(parser) + _t2039 = _t2040 else - _t2041 = nothing + _t2039 = nothing end - target_relations1207 = _t2041 - _t2043 = parse_csv_asof(parser) - csv_asof1208 = _t2043 + target_relations1206 = _t2039 + _t2041 = parse_csv_asof(parser) + csv_asof1207 = _t2041 consume_literal!(parser, ")") - _t2044 = construct_csv_data(parser, csvlocator1204, csv_config1205, gnf_columns1206, target_relations1207, csv_asof1208) - result1210 = _t2044 - record_span!(parser, span_start1209, "CSVData") - return result1210 + _t2042 = construct_csv_data(parser, csvlocator1203, csv_config1204, gnf_columns1205, target_relations1206, csv_asof1207) + result1209 = _t2042 + record_span!(parser, span_start1208, "CSVData") + return result1209 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator - span_start1213 = span_start(parser) + span_start1212 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t2046 = parse_csv_locator_paths(parser) - _t2045 = _t2046 + _t2044 = parse_csv_locator_paths(parser) + _t2043 = _t2044 else - _t2045 = nothing + _t2043 = nothing end - csv_locator_paths1211 = _t2045 + csv_locator_paths1210 = _t2043 if match_lookahead_literal(parser, "(", 0) - _t2048 = parse_csv_locator_inline_data(parser) - _t2047 = _t2048 + _t2046 = parse_csv_locator_inline_data(parser) + _t2045 = _t2046 else - _t2047 = nothing + _t2045 = nothing end - csv_locator_inline_data1212 = _t2047 + csv_locator_inline_data1211 = _t2045 consume_literal!(parser, ")") - _t2049 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1211) ? csv_locator_paths1211 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1212) ? csv_locator_inline_data1212 : ""))) - result1214 = _t2049 - record_span!(parser, span_start1213, "CSVLocator") - return result1214 + _t2047 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1210) ? csv_locator_paths1210 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1211) ? csv_locator_inline_data1211 : ""))) + result1213 = _t2047 + record_span!(parser, span_start1212, "CSVLocator") + return result1213 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs1215 = String[] - cond1216 = match_lookahead_terminal(parser, "STRING", 0) - while cond1216 - item1217 = consume_terminal!(parser, "STRING") - push!(xs1215, item1217) - cond1216 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1218 = xs1215 + xs1214 = String[] + cond1215 = match_lookahead_terminal(parser, "STRING", 0) + while cond1215 + item1216 = consume_terminal!(parser, "STRING") + push!(xs1214, item1216) + cond1215 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1217 = xs1214 consume_literal!(parser, ")") - return strings1218 + return strings1217 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - formatted_string1219 = consume_terminal!(parser, "STRING") + formatted_string1218 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return formatted_string1219 + return formatted_string1218 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig - span_start1222 = span_start(parser) + span_start1221 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t2050 = parse_config_dict(parser) - config_dict1220 = _t2050 + _t2048 = parse_config_dict(parser) + config_dict1219 = _t2048 if match_lookahead_literal(parser, "(", 0) - _t2052 = parse__storage_integration(parser) - _t2051 = _t2052 + _t2050 = parse__storage_integration(parser) + _t2049 = _t2050 else - _t2051 = nothing + _t2049 = nothing end - _storage_integration1221 = _t2051 + _storage_integration1220 = _t2049 consume_literal!(parser, ")") - _t2053 = construct_csv_config(parser, config_dict1220, _storage_integration1221) - result1223 = _t2053 - record_span!(parser, span_start1222, "CSVConfig") - return result1223 + _t2051 = construct_csv_config(parser, config_dict1219, _storage_integration1220) + result1222 = _t2051 + record_span!(parser, span_start1221, "CSVConfig") + return result1222 end function parse__storage_integration(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "(") consume_literal!(parser, "storage_integration") - _t2054 = parse_config_dict(parser) - config_dict1224 = _t2054 + _t2052 = parse_config_dict(parser) + config_dict1223 = _t2052 consume_literal!(parser, ")") - return config_dict1224 + return config_dict1223 end function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1225 = Proto.GNFColumn[] - cond1226 = match_lookahead_literal(parser, "(", 0) - while cond1226 - _t2055 = parse_gnf_column(parser) - item1227 = _t2055 - push!(xs1225, item1227) - cond1226 = match_lookahead_literal(parser, "(", 0) - end - gnf_columns1228 = xs1225 + xs1224 = Proto.GNFColumn[] + cond1225 = match_lookahead_literal(parser, "(", 0) + while cond1225 + _t2053 = parse_gnf_column(parser) + item1226 = _t2053 + push!(xs1224, item1226) + cond1225 = match_lookahead_literal(parser, "(", 0) + end + gnf_columns1227 = xs1224 consume_literal!(parser, ")") - return gnf_columns1228 + return gnf_columns1227 end function parse_gnf_column(parser::ParserState)::Proto.GNFColumn - span_start1235 = span_start(parser) + span_start1234 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - _t2056 = parse_gnf_column_path(parser) - gnf_column_path1229 = _t2056 + _t2054 = parse_gnf_column_path(parser) + gnf_column_path1228 = _t2054 if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - _t2058 = parse_relation_id(parser) - _t2057 = _t2058 + _t2056 = parse_relation_id(parser) + _t2055 = _t2056 else - _t2057 = nothing + _t2055 = nothing end - relation_id1230 = _t2057 + relation_id1229 = _t2055 consume_literal!(parser, "[") - xs1231 = Proto.var"#Type"[] - cond1232 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1232 - _t2059 = parse_type(parser) - item1233 = _t2059 - push!(xs1231, item1233) - cond1232 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1234 = xs1231 + xs1230 = Proto.var"#Type"[] + cond1231 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1231 + _t2057 = parse_type(parser) + item1232 = _t2057 + push!(xs1230, item1232) + cond1231 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1233 = xs1230 consume_literal!(parser, "]") consume_literal!(parser, ")") - _t2060 = Proto.GNFColumn(column_path=gnf_column_path1229, target_id=relation_id1230, types=types1234) - result1236 = _t2060 - record_span!(parser, span_start1235, "GNFColumn") - return result1236 + _t2058 = Proto.GNFColumn(column_path=gnf_column_path1228, target_id=relation_id1229, types=types1233) + result1235 = _t2058 + record_span!(parser, span_start1234, "GNFColumn") + return result1235 end function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t2061 = 1 + _t2059 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t2062 = 0 + _t2060 = 0 else - _t2062 = -1 + _t2060 = -1 end - _t2061 = _t2062 + _t2059 = _t2060 end - prediction1237 = _t2061 - if prediction1237 == 1 + prediction1236 = _t2059 + if prediction1236 == 1 consume_literal!(parser, "[") - xs1239 = String[] - cond1240 = match_lookahead_terminal(parser, "STRING", 0) - while cond1240 - item1241 = consume_terminal!(parser, "STRING") - push!(xs1239, item1241) - cond1240 = match_lookahead_terminal(parser, "STRING", 0) + xs1238 = String[] + cond1239 = match_lookahead_terminal(parser, "STRING", 0) + while cond1239 + item1240 = consume_terminal!(parser, "STRING") + push!(xs1238, item1240) + cond1239 = match_lookahead_terminal(parser, "STRING", 0) end - strings1242 = xs1239 + strings1241 = xs1238 consume_literal!(parser, "]") - _t2063 = strings1242 + _t2061 = strings1241 else - if prediction1237 == 0 - string1238 = consume_terminal!(parser, "STRING") - _t2064 = String[string1238] + if prediction1236 == 0 + string1237 = consume_terminal!(parser, "STRING") + _t2062 = String[string1237] else throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t2063 = _t2064 + _t2061 = _t2062 end - return _t2063 + return _t2061 end function parse_target_relations(parser::ParserState)::Proto.TargetRelations - span_start1245 = span_start(parser) + span_start1244 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relations") - _t2065 = parse_relation_keys(parser) - relation_keys1243 = _t2065 - _t2066 = parse_relation_body(parser) - relation_body1244 = _t2066 + _t2063 = parse_relation_keys(parser) + relation_keys1242 = _t2063 + _t2064 = parse_relation_body(parser) + relation_body1243 = _t2064 consume_literal!(parser, ")") - _t2067 = construct_relations(parser, relation_keys1243, relation_body1244) - result1246 = _t2067 - record_span!(parser, span_start1245, "TargetRelations") - return result1246 + _t2065 = construct_relations(parser, relation_keys1242, relation_body1243) + result1245 = _t2065 + record_span!(parser, span_start1244, "TargetRelations") + return result1245 end function parse_relation_keys(parser::ParserState)::Tuple{Vector{Proto.NamedColumn}, Bool} if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "keys", 1) - if match_lookahead_literal(parser, ":", 2) - _t2070 = 1 + if match_lookahead_literal(parser, "synthetic", 2) + _t2068 = 1 else if match_lookahead_literal(parser, ")", 2) - _t2071 = 0 + _t2069 = 0 else if match_lookahead_literal(parser, "(", 2) - _t2072 = 0 + _t2070 = 0 else - _t2072 = -1 + _t2070 = -1 end - _t2071 = _t2072 + _t2069 = _t2070 end - _t2070 = _t2071 + _t2068 = _t2069 end - _t2069 = _t2070 + _t2067 = _t2068 else - _t2069 = -1 + _t2067 = -1 end - _t2068 = _t2069 + _t2066 = _t2067 else - _t2068 = -1 + _t2066 = -1 end - prediction1247 = _t2068 - if prediction1247 == 1 + prediction1246 = _t2066 + if prediction1246 == 1 consume_literal!(parser, "(") consume_literal!(parser, "keys") - consume_literal!(parser, ":") - symbol1252 = consume_terminal!(parser, "SYMBOL") + consume_literal!(parser, "synthetic") consume_literal!(parser, ")") - _t2074 = construct_synthetic_keys(parser, symbol1252) - _t2073 = _t2074 + _t2071 = (Proto.NamedColumn[], true,) else - if prediction1247 == 0 + if prediction1246 == 0 consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1248 = Proto.NamedColumn[] - cond1249 = match_lookahead_literal(parser, "(", 0) - while cond1249 - _t2076 = parse_named_column(parser) - item1250 = _t2076 - push!(xs1248, item1250) - cond1249 = match_lookahead_literal(parser, "(", 0) + xs1247 = Proto.NamedColumn[] + cond1248 = match_lookahead_literal(parser, "(", 0) + while cond1248 + _t2073 = parse_named_column(parser) + item1249 = _t2073 + push!(xs1247, item1249) + cond1248 = match_lookahead_literal(parser, "(", 0) end - named_columns1251 = xs1248 + named_columns1250 = xs1247 consume_literal!(parser, ")") - _t2075 = (named_columns1251, false,) + _t2072 = (named_columns1250, false,) else throw(ParseError("Unexpected token in relation_keys" * ": " * string(lookahead(parser, 0)))) end - _t2073 = _t2075 + _t2071 = _t2072 end - return _t2073 + return _t2071 end function parse_named_column(parser::ParserState)::Proto.NamedColumn - span_start1255 = span_start(parser) + span_start1253 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1253 = consume_terminal!(parser, "STRING") - _t2077 = parse_type(parser) - type1254 = _t2077 + string1251 = consume_terminal!(parser, "STRING") + _t2074 = parse_type(parser) + type1252 = _t2074 consume_literal!(parser, ")") - _t2078 = Proto.NamedColumn(name=string1253, var"#type"=type1254) - result1256 = _t2078 - record_span!(parser, span_start1255, "NamedColumn") - return result1256 + _t2075 = Proto.NamedColumn(name=string1251, var"#type"=type1252) + result1254 = _t2075 + record_span!(parser, span_start1253, "NamedColumn") + return result1254 end function parse_relation_body(parser::ParserState)::Proto.TargetRelations - span_start1261 = span_start(parser) + span_start1259 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "relation", 1) - _t2080 = 0 + _t2077 = 0 else if match_lookahead_literal(parser, "inserts", 1) - _t2081 = 1 + _t2078 = 1 else - _t2081 = 0 + _t2078 = 0 end - _t2080 = _t2081 + _t2077 = _t2078 end - _t2079 = _t2080 + _t2076 = _t2077 else - _t2079 = 0 - end - prediction1257 = _t2079 - if prediction1257 == 1 - _t2083 = parse_cdc_inserts(parser) - cdc_inserts1259 = _t2083 - _t2084 = parse_cdc_deletes(parser) - cdc_deletes1260 = _t2084 - _t2085 = construct_cdc_relations(parser, cdc_inserts1259, cdc_deletes1260) - _t2082 = _t2085 + _t2076 = 0 + end + prediction1255 = _t2076 + if prediction1255 == 1 + _t2080 = parse_cdc_inserts(parser) + cdc_inserts1257 = _t2080 + _t2081 = parse_cdc_deletes(parser) + cdc_deletes1258 = _t2081 + _t2082 = construct_cdc_relations(parser, cdc_inserts1257, cdc_deletes1258) + _t2079 = _t2082 else - if prediction1257 == 0 - _t2087 = parse_non_cdc_relations(parser) - non_cdc_relations1258 = _t2087 - _t2088 = construct_non_cdc_relations(parser, non_cdc_relations1258) - _t2086 = _t2088 + if prediction1255 == 0 + _t2084 = parse_non_cdc_relations(parser) + non_cdc_relations1256 = _t2084 + _t2085 = construct_non_cdc_relations(parser, non_cdc_relations1256) + _t2083 = _t2085 else throw(ParseError("Unexpected token in relation_body" * ": " * string(lookahead(parser, 0)))) end - _t2082 = _t2086 + _t2079 = _t2083 end - result1262 = _t2082 - record_span!(parser, span_start1261, "TargetRelations") - return result1262 + result1260 = _t2079 + record_span!(parser, span_start1259, "TargetRelations") + return result1260 end function parse_non_cdc_relations(parser::ParserState)::Vector{Proto.TargetRelation} - xs1263 = Proto.TargetRelation[] - cond1264 = match_lookahead_literal(parser, "(", 0) - while cond1264 - _t2089 = parse_target_relation(parser) - item1265 = _t2089 - push!(xs1263, item1265) - cond1264 = match_lookahead_literal(parser, "(", 0) + xs1261 = Proto.TargetRelation[] + cond1262 = match_lookahead_literal(parser, "(", 0) + while cond1262 + _t2086 = parse_target_relation(parser) + item1263 = _t2086 + push!(xs1261, item1263) + cond1262 = match_lookahead_literal(parser, "(", 0) end - return xs1263 + return xs1261 end function parse_target_relation(parser::ParserState)::Proto.TargetRelation - span_start1271 = span_start(parser) + span_start1269 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relation") - _t2090 = parse_relation_id(parser) - relation_id1266 = _t2090 - xs1267 = Proto.NamedColumn[] - cond1268 = match_lookahead_literal(parser, "(", 0) - while cond1268 - _t2091 = parse_named_column(parser) - item1269 = _t2091 - push!(xs1267, item1269) - cond1268 = match_lookahead_literal(parser, "(", 0) - end - named_columns1270 = xs1267 + _t2087 = parse_relation_id(parser) + relation_id1264 = _t2087 + xs1265 = Proto.NamedColumn[] + cond1266 = match_lookahead_literal(parser, "(", 0) + while cond1266 + _t2088 = parse_named_column(parser) + item1267 = _t2088 + push!(xs1265, item1267) + cond1266 = match_lookahead_literal(parser, "(", 0) + end + named_columns1268 = xs1265 consume_literal!(parser, ")") - _t2092 = Proto.TargetRelation(target_id=relation_id1266, values=named_columns1270) - result1272 = _t2092 - record_span!(parser, span_start1271, "TargetRelation") - return result1272 + _t2089 = Proto.TargetRelation(target_id=relation_id1264, values=named_columns1268) + result1270 = _t2089 + record_span!(parser, span_start1269, "TargetRelation") + return result1270 end function parse_cdc_inserts(parser::ParserState)::Vector{Proto.TargetRelation} consume_literal!(parser, "(") consume_literal!(parser, "inserts") - xs1273 = Proto.TargetRelation[] - cond1274 = match_lookahead_literal(parser, "(", 0) - while cond1274 - _t2093 = parse_target_relation(parser) - item1275 = _t2093 - push!(xs1273, item1275) - cond1274 = match_lookahead_literal(parser, "(", 0) - end - target_relations1276 = xs1273 + xs1271 = Proto.TargetRelation[] + cond1272 = match_lookahead_literal(parser, "(", 0) + while cond1272 + _t2090 = parse_target_relation(parser) + item1273 = _t2090 + push!(xs1271, item1273) + cond1272 = match_lookahead_literal(parser, "(", 0) + end + target_relations1274 = xs1271 consume_literal!(parser, ")") - return target_relations1276 + return target_relations1274 end function parse_cdc_deletes(parser::ParserState)::Vector{Proto.TargetRelation} consume_literal!(parser, "(") consume_literal!(parser, "deletes") - xs1277 = Proto.TargetRelation[] - cond1278 = match_lookahead_literal(parser, "(", 0) - while cond1278 - _t2094 = parse_target_relation(parser) - item1279 = _t2094 - push!(xs1277, item1279) - cond1278 = match_lookahead_literal(parser, "(", 0) - end - target_relations1280 = xs1277 + xs1275 = Proto.TargetRelation[] + cond1276 = match_lookahead_literal(parser, "(", 0) + while cond1276 + _t2091 = parse_target_relation(parser) + item1277 = _t2091 + push!(xs1275, item1277) + cond1276 = match_lookahead_literal(parser, "(", 0) + end + target_relations1278 = xs1275 consume_literal!(parser, ")") - return target_relations1280 + return target_relations1278 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string1281 = consume_terminal!(parser, "STRING") + string1279 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1281 + return string1279 end function parse_iceberg_data(parser::ParserState)::Proto.IcebergData - span_start1288 = span_start(parser) + span_start1286 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_data") - _t2095 = parse_iceberg_locator(parser) - iceberg_locator1282 = _t2095 - _t2096 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1283 = _t2096 - _t2097 = parse_gnf_columns(parser) - gnf_columns1284 = _t2097 + _t2092 = parse_iceberg_locator(parser) + iceberg_locator1280 = _t2092 + _t2093 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1281 = _t2093 + _t2094 = parse_gnf_columns(parser) + gnf_columns1282 = _t2094 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "from_snapshot", 1)) - _t2099 = parse_iceberg_from_snapshot(parser) - _t2098 = _t2099 + _t2096 = parse_iceberg_from_snapshot(parser) + _t2095 = _t2096 else - _t2098 = nothing + _t2095 = nothing end - iceberg_from_snapshot1285 = _t2098 + iceberg_from_snapshot1283 = _t2095 if match_lookahead_literal(parser, "(", 0) - _t2101 = parse_iceberg_to_snapshot(parser) - _t2100 = _t2101 + _t2098 = parse_iceberg_to_snapshot(parser) + _t2097 = _t2098 else - _t2100 = nothing + _t2097 = nothing end - iceberg_to_snapshot1286 = _t2100 - _t2102 = parse_boolean_value(parser) - boolean_value1287 = _t2102 + iceberg_to_snapshot1284 = _t2097 + _t2099 = parse_boolean_value(parser) + boolean_value1285 = _t2099 consume_literal!(parser, ")") - _t2103 = construct_iceberg_data(parser, iceberg_locator1282, iceberg_catalog_config1283, gnf_columns1284, iceberg_from_snapshot1285, iceberg_to_snapshot1286, boolean_value1287) - result1289 = _t2103 - record_span!(parser, span_start1288, "IcebergData") - return result1289 + _t2100 = construct_iceberg_data(parser, iceberg_locator1280, iceberg_catalog_config1281, gnf_columns1282, iceberg_from_snapshot1283, iceberg_to_snapshot1284, boolean_value1285) + result1287 = _t2100 + record_span!(parser, span_start1286, "IcebergData") + return result1287 end function parse_iceberg_locator(parser::ParserState)::Proto.IcebergLocator - span_start1293 = span_start(parser) + span_start1291 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_locator") - _t2104 = parse_iceberg_locator_table_name(parser) - iceberg_locator_table_name1290 = _t2104 - _t2105 = parse_iceberg_locator_namespace(parser) - iceberg_locator_namespace1291 = _t2105 - _t2106 = parse_iceberg_locator_warehouse(parser) - iceberg_locator_warehouse1292 = _t2106 + _t2101 = parse_iceberg_locator_table_name(parser) + iceberg_locator_table_name1288 = _t2101 + _t2102 = parse_iceberg_locator_namespace(parser) + iceberg_locator_namespace1289 = _t2102 + _t2103 = parse_iceberg_locator_warehouse(parser) + iceberg_locator_warehouse1290 = _t2103 consume_literal!(parser, ")") - _t2107 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1290, namespace=iceberg_locator_namespace1291, warehouse=iceberg_locator_warehouse1292) - result1294 = _t2107 - record_span!(parser, span_start1293, "IcebergLocator") - return result1294 + _t2104 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1288, namespace=iceberg_locator_namespace1289, warehouse=iceberg_locator_warehouse1290) + result1292 = _t2104 + record_span!(parser, span_start1291, "IcebergLocator") + return result1292 end function parse_iceberg_locator_table_name(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "table_name") - string1295 = consume_terminal!(parser, "STRING") + string1293 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1295 + return string1293 end function parse_iceberg_locator_namespace(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "namespace") - xs1296 = String[] - cond1297 = match_lookahead_terminal(parser, "STRING", 0) - while cond1297 - item1298 = consume_terminal!(parser, "STRING") - push!(xs1296, item1298) - cond1297 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1299 = xs1296 + xs1294 = String[] + cond1295 = match_lookahead_terminal(parser, "STRING", 0) + while cond1295 + item1296 = consume_terminal!(parser, "STRING") + push!(xs1294, item1296) + cond1295 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1297 = xs1294 consume_literal!(parser, ")") - return strings1299 + return strings1297 end function parse_iceberg_locator_warehouse(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "warehouse") - string1300 = consume_terminal!(parser, "STRING") + string1298 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1300 + return string1298 end function parse_iceberg_catalog_config(parser::ParserState)::Proto.IcebergCatalogConfig - span_start1305 = span_start(parser) + span_start1303 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_catalog_config") - _t2108 = parse_iceberg_catalog_uri(parser) - iceberg_catalog_uri1301 = _t2108 + _t2105 = parse_iceberg_catalog_uri(parser) + iceberg_catalog_uri1299 = _t2105 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "scope", 1)) - _t2110 = parse_iceberg_catalog_config_scope(parser) - _t2109 = _t2110 + _t2107 = parse_iceberg_catalog_config_scope(parser) + _t2106 = _t2107 else - _t2109 = nothing + _t2106 = nothing end - iceberg_catalog_config_scope1302 = _t2109 - _t2111 = parse_iceberg_properties(parser) - iceberg_properties1303 = _t2111 - _t2112 = parse_iceberg_auth_properties(parser) - iceberg_auth_properties1304 = _t2112 + iceberg_catalog_config_scope1300 = _t2106 + _t2108 = parse_iceberg_properties(parser) + iceberg_properties1301 = _t2108 + _t2109 = parse_iceberg_auth_properties(parser) + iceberg_auth_properties1302 = _t2109 consume_literal!(parser, ")") - _t2113 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1301, iceberg_catalog_config_scope1302, iceberg_properties1303, iceberg_auth_properties1304) - result1306 = _t2113 - record_span!(parser, span_start1305, "IcebergCatalogConfig") - return result1306 + _t2110 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1299, iceberg_catalog_config_scope1300, iceberg_properties1301, iceberg_auth_properties1302) + result1304 = _t2110 + record_span!(parser, span_start1303, "IcebergCatalogConfig") + return result1304 end function parse_iceberg_catalog_uri(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "catalog_uri") - string1307 = consume_terminal!(parser, "STRING") + string1305 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1307 + return string1305 end function parse_iceberg_catalog_config_scope(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "scope") - string1308 = consume_terminal!(parser, "STRING") + string1306 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1308 + return string1306 end function parse_iceberg_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "properties") - xs1309 = Tuple{String, String}[] - cond1310 = match_lookahead_literal(parser, "(", 0) - while cond1310 - _t2114 = parse_iceberg_property_entry(parser) - item1311 = _t2114 - push!(xs1309, item1311) - cond1310 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1312 = xs1309 + xs1307 = Tuple{String, String}[] + cond1308 = match_lookahead_literal(parser, "(", 0) + while cond1308 + _t2111 = parse_iceberg_property_entry(parser) + item1309 = _t2111 + push!(xs1307, item1309) + cond1308 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1310 = xs1307 consume_literal!(parser, ")") - return iceberg_property_entrys1312 + return iceberg_property_entrys1310 end function parse_iceberg_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1313 = consume_terminal!(parser, "STRING") - string_31314 = consume_terminal!(parser, "STRING") + string1311 = consume_terminal!(parser, "STRING") + string_31312 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1313, string_31314,) + return (string1311, string_31312,) end function parse_iceberg_auth_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "auth_properties") - xs1315 = Tuple{String, String}[] - cond1316 = match_lookahead_literal(parser, "(", 0) - while cond1316 - _t2115 = parse_iceberg_masked_property_entry(parser) - item1317 = _t2115 - push!(xs1315, item1317) - cond1316 = match_lookahead_literal(parser, "(", 0) - end - iceberg_masked_property_entrys1318 = xs1315 + xs1313 = Tuple{String, String}[] + cond1314 = match_lookahead_literal(parser, "(", 0) + while cond1314 + _t2112 = parse_iceberg_masked_property_entry(parser) + item1315 = _t2112 + push!(xs1313, item1315) + cond1314 = match_lookahead_literal(parser, "(", 0) + end + iceberg_masked_property_entrys1316 = xs1313 consume_literal!(parser, ")") - return iceberg_masked_property_entrys1318 + return iceberg_masked_property_entrys1316 end function parse_iceberg_masked_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1319 = consume_terminal!(parser, "STRING") - string_31320 = consume_terminal!(parser, "STRING") + string1317 = consume_terminal!(parser, "STRING") + string_31318 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1319, string_31320,) + return (string1317, string_31318,) end function parse_iceberg_from_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "from_snapshot") - string1321 = consume_terminal!(parser, "STRING") + string1319 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1321 + return string1319 end function parse_iceberg_to_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "to_snapshot") - string1322 = consume_terminal!(parser, "STRING") + string1320 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1322 + return string1320 end function parse_undefine(parser::ParserState)::Proto.Undefine - span_start1324 = span_start(parser) + span_start1322 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t2116 = parse_fragment_id(parser) - fragment_id1323 = _t2116 + _t2113 = parse_fragment_id(parser) + fragment_id1321 = _t2113 consume_literal!(parser, ")") - _t2117 = Proto.Undefine(fragment_id=fragment_id1323) - result1325 = _t2117 - record_span!(parser, span_start1324, "Undefine") - return result1325 + _t2114 = Proto.Undefine(fragment_id=fragment_id1321) + result1323 = _t2114 + record_span!(parser, span_start1322, "Undefine") + return result1323 end function parse_context(parser::ParserState)::Proto.Context - span_start1330 = span_start(parser) + span_start1328 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "context") - xs1326 = Proto.RelationId[] - cond1327 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1327 - _t2118 = parse_relation_id(parser) - item1328 = _t2118 - push!(xs1326, item1328) - cond1327 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1329 = xs1326 + xs1324 = Proto.RelationId[] + cond1325 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1325 + _t2115 = parse_relation_id(parser) + item1326 = _t2115 + push!(xs1324, item1326) + cond1325 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1327 = xs1324 consume_literal!(parser, ")") - _t2119 = Proto.Context(relations=relation_ids1329) - result1331 = _t2119 - record_span!(parser, span_start1330, "Context") - return result1331 + _t2116 = Proto.Context(relations=relation_ids1327) + result1329 = _t2116 + record_span!(parser, span_start1328, "Context") + return result1329 end function parse_snapshot(parser::ParserState)::Proto.Snapshot - span_start1337 = span_start(parser) + span_start1335 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t2120 = parse_edb_path(parser) - edb_path1332 = _t2120 - xs1333 = Proto.SnapshotMapping[] - cond1334 = match_lookahead_literal(parser, "[", 0) - while cond1334 - _t2121 = parse_snapshot_mapping(parser) - item1335 = _t2121 - push!(xs1333, item1335) - cond1334 = match_lookahead_literal(parser, "[", 0) - end - snapshot_mappings1336 = xs1333 + _t2117 = parse_edb_path(parser) + edb_path1330 = _t2117 + xs1331 = Proto.SnapshotMapping[] + cond1332 = match_lookahead_literal(parser, "[", 0) + while cond1332 + _t2118 = parse_snapshot_mapping(parser) + item1333 = _t2118 + push!(xs1331, item1333) + cond1332 = match_lookahead_literal(parser, "[", 0) + end + snapshot_mappings1334 = xs1331 consume_literal!(parser, ")") - _t2122 = Proto.Snapshot(mappings=snapshot_mappings1336, prefix=edb_path1332) - result1338 = _t2122 - record_span!(parser, span_start1337, "Snapshot") - return result1338 + _t2119 = Proto.Snapshot(mappings=snapshot_mappings1334, prefix=edb_path1330) + result1336 = _t2119 + record_span!(parser, span_start1335, "Snapshot") + return result1336 end function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping - span_start1341 = span_start(parser) - _t2123 = parse_edb_path(parser) - edb_path1339 = _t2123 - _t2124 = parse_relation_id(parser) - relation_id1340 = _t2124 - _t2125 = Proto.SnapshotMapping(destination_path=edb_path1339, source_relation=relation_id1340) - result1342 = _t2125 - record_span!(parser, span_start1341, "SnapshotMapping") - return result1342 + span_start1339 = span_start(parser) + _t2120 = parse_edb_path(parser) + edb_path1337 = _t2120 + _t2121 = parse_relation_id(parser) + relation_id1338 = _t2121 + _t2122 = Proto.SnapshotMapping(destination_path=edb_path1337, source_relation=relation_id1338) + result1340 = _t2122 + record_span!(parser, span_start1339, "SnapshotMapping") + return result1340 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs1343 = Proto.Read[] - cond1344 = match_lookahead_literal(parser, "(", 0) - while cond1344 - _t2126 = parse_read(parser) - item1345 = _t2126 - push!(xs1343, item1345) - cond1344 = match_lookahead_literal(parser, "(", 0) - end - reads1346 = xs1343 + xs1341 = Proto.Read[] + cond1342 = match_lookahead_literal(parser, "(", 0) + while cond1342 + _t2123 = parse_read(parser) + item1343 = _t2123 + push!(xs1341, item1343) + cond1342 = match_lookahead_literal(parser, "(", 0) + end + reads1344 = xs1341 consume_literal!(parser, ")") - return reads1346 + return reads1344 end function parse_read(parser::ParserState)::Proto.Read - span_start1353 = span_start(parser) + span_start1351 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t2128 = 2 + _t2125 = 2 else if match_lookahead_literal(parser, "output", 1) - _t2129 = 1 + _t2126 = 1 else if match_lookahead_literal(parser, "export_iceberg", 1) - _t2130 = 4 + _t2127 = 4 else if match_lookahead_literal(parser, "export", 1) - _t2131 = 4 + _t2128 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t2132 = 0 + _t2129 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t2133 = 3 + _t2130 = 3 else - _t2133 = -1 + _t2130 = -1 end - _t2132 = _t2133 + _t2129 = _t2130 end - _t2131 = _t2132 + _t2128 = _t2129 end - _t2130 = _t2131 + _t2127 = _t2128 end - _t2129 = _t2130 + _t2126 = _t2127 end - _t2128 = _t2129 + _t2125 = _t2126 end - _t2127 = _t2128 + _t2124 = _t2125 else - _t2127 = -1 - end - prediction1347 = _t2127 - if prediction1347 == 4 - _t2135 = parse_export(parser) - export1352 = _t2135 - _t2136 = Proto.Read(read_type=OneOf(:var"#export", export1352)) - _t2134 = _t2136 + _t2124 = -1 + end + prediction1345 = _t2124 + if prediction1345 == 4 + _t2132 = parse_export(parser) + export1350 = _t2132 + _t2133 = Proto.Read(read_type=OneOf(:var"#export", export1350)) + _t2131 = _t2133 else - if prediction1347 == 3 - _t2138 = parse_abort(parser) - abort1351 = _t2138 - _t2139 = Proto.Read(read_type=OneOf(:abort, abort1351)) - _t2137 = _t2139 + if prediction1345 == 3 + _t2135 = parse_abort(parser) + abort1349 = _t2135 + _t2136 = Proto.Read(read_type=OneOf(:abort, abort1349)) + _t2134 = _t2136 else - if prediction1347 == 2 - _t2141 = parse_what_if(parser) - what_if1350 = _t2141 - _t2142 = Proto.Read(read_type=OneOf(:what_if, what_if1350)) - _t2140 = _t2142 + if prediction1345 == 2 + _t2138 = parse_what_if(parser) + what_if1348 = _t2138 + _t2139 = Proto.Read(read_type=OneOf(:what_if, what_if1348)) + _t2137 = _t2139 else - if prediction1347 == 1 - _t2144 = parse_output(parser) - output1349 = _t2144 - _t2145 = Proto.Read(read_type=OneOf(:output, output1349)) - _t2143 = _t2145 + if prediction1345 == 1 + _t2141 = parse_output(parser) + output1347 = _t2141 + _t2142 = Proto.Read(read_type=OneOf(:output, output1347)) + _t2140 = _t2142 else - if prediction1347 == 0 - _t2147 = parse_demand(parser) - demand1348 = _t2147 - _t2148 = Proto.Read(read_type=OneOf(:demand, demand1348)) - _t2146 = _t2148 + if prediction1345 == 0 + _t2144 = parse_demand(parser) + demand1346 = _t2144 + _t2145 = Proto.Read(read_type=OneOf(:demand, demand1346)) + _t2143 = _t2145 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t2143 = _t2146 + _t2140 = _t2143 end - _t2140 = _t2143 + _t2137 = _t2140 end - _t2137 = _t2140 + _t2134 = _t2137 end - _t2134 = _t2137 + _t2131 = _t2134 end - result1354 = _t2134 - record_span!(parser, span_start1353, "Read") - return result1354 + result1352 = _t2131 + record_span!(parser, span_start1351, "Read") + return result1352 end function parse_demand(parser::ParserState)::Proto.Demand - span_start1356 = span_start(parser) + span_start1354 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t2149 = parse_relation_id(parser) - relation_id1355 = _t2149 + _t2146 = parse_relation_id(parser) + relation_id1353 = _t2146 consume_literal!(parser, ")") - _t2150 = Proto.Demand(relation_id=relation_id1355) - result1357 = _t2150 - record_span!(parser, span_start1356, "Demand") - return result1357 + _t2147 = Proto.Demand(relation_id=relation_id1353) + result1355 = _t2147 + record_span!(parser, span_start1354, "Demand") + return result1355 end function parse_output(parser::ParserState)::Proto.Output - span_start1360 = span_start(parser) + span_start1358 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "output") - _t2151 = parse_name(parser) - name1358 = _t2151 - _t2152 = parse_relation_id(parser) - relation_id1359 = _t2152 + _t2148 = parse_name(parser) + name1356 = _t2148 + _t2149 = parse_relation_id(parser) + relation_id1357 = _t2149 consume_literal!(parser, ")") - _t2153 = Proto.Output(name=name1358, relation_id=relation_id1359) - result1361 = _t2153 - record_span!(parser, span_start1360, "Output") - return result1361 + _t2150 = Proto.Output(name=name1356, relation_id=relation_id1357) + result1359 = _t2150 + record_span!(parser, span_start1358, "Output") + return result1359 end function parse_what_if(parser::ParserState)::Proto.WhatIf - span_start1364 = span_start(parser) + span_start1362 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t2154 = parse_name(parser) - name1362 = _t2154 - _t2155 = parse_epoch(parser) - epoch1363 = _t2155 + _t2151 = parse_name(parser) + name1360 = _t2151 + _t2152 = parse_epoch(parser) + epoch1361 = _t2152 consume_literal!(parser, ")") - _t2156 = Proto.WhatIf(branch=name1362, epoch=epoch1363) - result1365 = _t2156 - record_span!(parser, span_start1364, "WhatIf") - return result1365 + _t2153 = Proto.WhatIf(branch=name1360, epoch=epoch1361) + result1363 = _t2153 + record_span!(parser, span_start1362, "WhatIf") + return result1363 end function parse_abort(parser::ParserState)::Proto.Abort - span_start1368 = span_start(parser) + span_start1366 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t2158 = parse_name(parser) - _t2157 = _t2158 + _t2155 = parse_name(parser) + _t2154 = _t2155 else - _t2157 = nothing + _t2154 = nothing end - name1366 = _t2157 - _t2159 = parse_relation_id(parser) - relation_id1367 = _t2159 + name1364 = _t2154 + _t2156 = parse_relation_id(parser) + relation_id1365 = _t2156 consume_literal!(parser, ")") - _t2160 = Proto.Abort(name=(!isnothing(name1366) ? name1366 : "abort"), relation_id=relation_id1367) - result1369 = _t2160 - record_span!(parser, span_start1368, "Abort") - return result1369 + _t2157 = Proto.Abort(name=(!isnothing(name1364) ? name1364 : "abort"), relation_id=relation_id1365) + result1367 = _t2157 + record_span!(parser, span_start1366, "Abort") + return result1367 end function parse_export(parser::ParserState)::Proto.Export - span_start1373 = span_start(parser) + span_start1371 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_iceberg", 1) - _t2162 = 1 + _t2159 = 1 else if match_lookahead_literal(parser, "export", 1) - _t2163 = 0 + _t2160 = 0 else - _t2163 = -1 + _t2160 = -1 end - _t2162 = _t2163 + _t2159 = _t2160 end - _t2161 = _t2162 + _t2158 = _t2159 else - _t2161 = -1 + _t2158 = -1 end - prediction1370 = _t2161 - if prediction1370 == 1 + prediction1368 = _t2158 + if prediction1368 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg") - _t2165 = parse_export_iceberg_config(parser) - export_iceberg_config1372 = _t2165 + _t2162 = parse_export_iceberg_config(parser) + export_iceberg_config1370 = _t2162 consume_literal!(parser, ")") - _t2166 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1372)) - _t2164 = _t2166 + _t2163 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1370)) + _t2161 = _t2163 else - if prediction1370 == 0 + if prediction1368 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export") - _t2168 = parse_export_csv_config(parser) - export_csv_config1371 = _t2168 + _t2165 = parse_export_csv_config(parser) + export_csv_config1369 = _t2165 consume_literal!(parser, ")") - _t2169 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1371)) - _t2167 = _t2169 + _t2166 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1369)) + _t2164 = _t2166 else throw(ParseError("Unexpected token in export" * ": " * string(lookahead(parser, 0)))) end - _t2164 = _t2167 + _t2161 = _t2164 end - result1374 = _t2164 - record_span!(parser, span_start1373, "Export") - return result1374 + result1372 = _t2161 + record_span!(parser, span_start1371, "Export") + return result1372 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig - span_start1382 = span_start(parser) + span_start1380 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_csv_config_v2", 1) - _t2171 = 0 + _t2168 = 0 else if match_lookahead_literal(parser, "export_csv_config", 1) - _t2172 = 1 + _t2169 = 1 else - _t2172 = -1 + _t2169 = -1 end - _t2171 = _t2172 + _t2168 = _t2169 end - _t2170 = _t2171 + _t2167 = _t2168 else - _t2170 = -1 + _t2167 = -1 end - prediction1375 = _t2170 - if prediction1375 == 1 + prediction1373 = _t2167 + if prediction1373 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t2174 = parse_export_csv_path(parser) - export_csv_path1379 = _t2174 - _t2175 = parse_export_csv_columns_list(parser) - export_csv_columns_list1380 = _t2175 - _t2176 = parse_config_dict(parser) - config_dict1381 = _t2176 + _t2171 = parse_export_csv_path(parser) + export_csv_path1377 = _t2171 + _t2172 = parse_export_csv_columns_list(parser) + export_csv_columns_list1378 = _t2172 + _t2173 = parse_config_dict(parser) + config_dict1379 = _t2173 consume_literal!(parser, ")") - _t2177 = construct_export_csv_config(parser, export_csv_path1379, export_csv_columns_list1380, config_dict1381) - _t2173 = _t2177 + _t2174 = construct_export_csv_config(parser, export_csv_path1377, export_csv_columns_list1378, config_dict1379) + _t2170 = _t2174 else - if prediction1375 == 0 + if prediction1373 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config_v2") - _t2179 = parse_export_csv_output_location(parser) - export_csv_output_location1376 = _t2179 - _t2180 = parse_export_csv_source(parser) - export_csv_source1377 = _t2180 - _t2181 = parse_csv_config(parser) - csv_config1378 = _t2181 + _t2176 = parse_export_csv_output_location(parser) + export_csv_output_location1374 = _t2176 + _t2177 = parse_export_csv_source(parser) + export_csv_source1375 = _t2177 + _t2178 = parse_csv_config(parser) + csv_config1376 = _t2178 consume_literal!(parser, ")") - _t2182 = construct_export_csv_config_with_location(parser, export_csv_output_location1376, export_csv_source1377, csv_config1378) - _t2178 = _t2182 + _t2179 = construct_export_csv_config_with_location(parser, export_csv_output_location1374, export_csv_source1375, csv_config1376) + _t2175 = _t2179 else throw(ParseError("Unexpected token in export_csv_config" * ": " * string(lookahead(parser, 0)))) end - _t2173 = _t2178 + _t2170 = _t2175 end - result1383 = _t2173 - record_span!(parser, span_start1382, "ExportCSVConfig") - return result1383 + result1381 = _t2170 + record_span!(parser, span_start1380, "ExportCSVConfig") + return result1381 end function parse_export_csv_output_location(parser::ParserState)::Tuple{String, String} if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "transaction_output_name", 1) - _t2184 = 1 + _t2181 = 1 else if match_lookahead_literal(parser, "path", 1) - _t2185 = 0 + _t2182 = 0 else - _t2185 = -1 + _t2182 = -1 end - _t2184 = _t2185 + _t2181 = _t2182 end - _t2183 = _t2184 + _t2180 = _t2181 else - _t2183 = -1 + _t2180 = -1 end - prediction1384 = _t2183 - if prediction1384 == 1 + prediction1382 = _t2180 + if prediction1382 == 1 consume_literal!(parser, "(") consume_literal!(parser, "transaction_output_name") - _t2187 = parse_name(parser) - name1386 = _t2187 + _t2184 = parse_name(parser) + name1384 = _t2184 consume_literal!(parser, ")") - _t2186 = ("", name1386,) + _t2183 = ("", name1384,) else - if prediction1384 == 0 + if prediction1382 == 0 consume_literal!(parser, "(") consume_literal!(parser, "path") - string1385 = consume_terminal!(parser, "STRING") + string1383 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - _t2188 = (string1385, "",) + _t2185 = (string1383, "",) else throw(ParseError("Unexpected token in export_csv_output_location" * ": " * string(lookahead(parser, 0)))) end - _t2186 = _t2188 + _t2183 = _t2185 end - return _t2186 + return _t2183 end function parse_export_csv_source(parser::ParserState)::Proto.ExportCSVSource - span_start1393 = span_start(parser) + span_start1391 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "table_def", 1) - _t2190 = 1 + _t2187 = 1 else if match_lookahead_literal(parser, "gnf_columns", 1) - _t2191 = 0 + _t2188 = 0 else - _t2191 = -1 + _t2188 = -1 end - _t2190 = _t2191 + _t2187 = _t2188 end - _t2189 = _t2190 + _t2186 = _t2187 else - _t2189 = -1 + _t2186 = -1 end - prediction1387 = _t2189 - if prediction1387 == 1 + prediction1385 = _t2186 + if prediction1385 == 1 consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2193 = parse_relation_id(parser) - relation_id1392 = _t2193 + _t2190 = parse_relation_id(parser) + relation_id1390 = _t2190 consume_literal!(parser, ")") - _t2194 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1392)) - _t2192 = _t2194 + _t2191 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1390)) + _t2189 = _t2191 else - if prediction1387 == 0 + if prediction1385 == 0 consume_literal!(parser, "(") consume_literal!(parser, "gnf_columns") - xs1388 = Proto.ExportCSVColumn[] - cond1389 = match_lookahead_literal(parser, "(", 0) - while cond1389 - _t2196 = parse_export_csv_column(parser) - item1390 = _t2196 - push!(xs1388, item1390) - cond1389 = match_lookahead_literal(parser, "(", 0) + xs1386 = Proto.ExportCSVColumn[] + cond1387 = match_lookahead_literal(parser, "(", 0) + while cond1387 + _t2193 = parse_export_csv_column(parser) + item1388 = _t2193 + push!(xs1386, item1388) + cond1387 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1391 = xs1388 + export_csv_columns1389 = xs1386 consume_literal!(parser, ")") - _t2197 = Proto.ExportCSVColumns(columns=export_csv_columns1391) - _t2198 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2197)) - _t2195 = _t2198 + _t2194 = Proto.ExportCSVColumns(columns=export_csv_columns1389) + _t2195 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2194)) + _t2192 = _t2195 else throw(ParseError("Unexpected token in export_csv_source" * ": " * string(lookahead(parser, 0)))) end - _t2192 = _t2195 + _t2189 = _t2192 end - result1394 = _t2192 - record_span!(parser, span_start1393, "ExportCSVSource") - return result1394 + result1392 = _t2189 + record_span!(parser, span_start1391, "ExportCSVSource") + return result1392 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn - span_start1397 = span_start(parser) + span_start1395 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1395 = consume_terminal!(parser, "STRING") - _t2199 = parse_relation_id(parser) - relation_id1396 = _t2199 + string1393 = consume_terminal!(parser, "STRING") + _t2196 = parse_relation_id(parser) + relation_id1394 = _t2196 consume_literal!(parser, ")") - _t2200 = Proto.ExportCSVColumn(column_name=string1395, column_data=relation_id1396) - result1398 = _t2200 - record_span!(parser, span_start1397, "ExportCSVColumn") - return result1398 + _t2197 = Proto.ExportCSVColumn(column_name=string1393, column_data=relation_id1394) + result1396 = _t2197 + record_span!(parser, span_start1395, "ExportCSVColumn") + return result1396 end function parse_export_csv_path(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "path") - string1399 = consume_terminal!(parser, "STRING") + string1397 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1399 + return string1397 end function parse_export_csv_columns_list(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1400 = Proto.ExportCSVColumn[] - cond1401 = match_lookahead_literal(parser, "(", 0) - while cond1401 - _t2201 = parse_export_csv_column(parser) - item1402 = _t2201 - push!(xs1400, item1402) - cond1401 = match_lookahead_literal(parser, "(", 0) - end - export_csv_columns1403 = xs1400 + xs1398 = Proto.ExportCSVColumn[] + cond1399 = match_lookahead_literal(parser, "(", 0) + while cond1399 + _t2198 = parse_export_csv_column(parser) + item1400 = _t2198 + push!(xs1398, item1400) + cond1399 = match_lookahead_literal(parser, "(", 0) + end + export_csv_columns1401 = xs1398 consume_literal!(parser, ")") - return export_csv_columns1403 + return export_csv_columns1401 end function parse_export_iceberg_config(parser::ParserState)::Proto.ExportIcebergConfig - span_start1409 = span_start(parser) + span_start1407 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg_config") - _t2202 = parse_iceberg_locator(parser) - iceberg_locator1404 = _t2202 - _t2203 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1405 = _t2203 - _t2204 = parse_export_iceberg_table_def(parser) - export_iceberg_table_def1406 = _t2204 - _t2205 = parse_iceberg_table_properties(parser) - iceberg_table_properties1407 = _t2205 + _t2199 = parse_iceberg_locator(parser) + iceberg_locator1402 = _t2199 + _t2200 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1403 = _t2200 + _t2201 = parse_export_iceberg_table_def(parser) + export_iceberg_table_def1404 = _t2201 + _t2202 = parse_iceberg_table_properties(parser) + iceberg_table_properties1405 = _t2202 if match_lookahead_literal(parser, "{", 0) - _t2207 = parse_config_dict(parser) - _t2206 = _t2207 + _t2204 = parse_config_dict(parser) + _t2203 = _t2204 else - _t2206 = nothing + _t2203 = nothing end - config_dict1408 = _t2206 + config_dict1406 = _t2203 consume_literal!(parser, ")") - _t2208 = construct_export_iceberg_config_full(parser, iceberg_locator1404, iceberg_catalog_config1405, export_iceberg_table_def1406, iceberg_table_properties1407, config_dict1408) - result1410 = _t2208 - record_span!(parser, span_start1409, "ExportIcebergConfig") - return result1410 + _t2205 = construct_export_iceberg_config_full(parser, iceberg_locator1402, iceberg_catalog_config1403, export_iceberg_table_def1404, iceberg_table_properties1405, config_dict1406) + result1408 = _t2205 + record_span!(parser, span_start1407, "ExportIcebergConfig") + return result1408 end function parse_export_iceberg_table_def(parser::ParserState)::Proto.RelationId - span_start1412 = span_start(parser) + span_start1410 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2209 = parse_relation_id(parser) - relation_id1411 = _t2209 + _t2206 = parse_relation_id(parser) + relation_id1409 = _t2206 consume_literal!(parser, ")") - result1413 = relation_id1411 - record_span!(parser, span_start1412, "RelationId") - return result1413 + result1411 = relation_id1409 + record_span!(parser, span_start1410, "RelationId") + return result1411 end function parse_iceberg_table_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "table_properties") - xs1414 = Tuple{String, String}[] - cond1415 = match_lookahead_literal(parser, "(", 0) - while cond1415 - _t2210 = parse_iceberg_property_entry(parser) - item1416 = _t2210 - push!(xs1414, item1416) - cond1415 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1417 = xs1414 + xs1412 = Tuple{String, String}[] + cond1413 = match_lookahead_literal(parser, "(", 0) + while cond1413 + _t2207 = parse_iceberg_property_entry(parser) + item1414 = _t2207 + push!(xs1412, item1414) + cond1413 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1415 = xs1412 consume_literal!(parser, ")") - return iceberg_property_entrys1417 + return iceberg_property_entrys1415 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index 5cf08b5a..af05871c 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -4237,7 +4237,7 @@ function pretty_relation_keys(pp::PrettyPrinter, msg::Tuple{Vector{Proto.NamedCo else _dollar_dollar = msg if _dollar_dollar[2] - _t1861 = "synthetic_key" + _t1861 = () else _t1861 = nothing end @@ -4245,12 +4245,8 @@ function pretty_relation_keys(pp::PrettyPrinter, msg::Tuple{Vector{Proto.NamedCo if !isnothing(deconstruct_result1493) unwrapped1494 = deconstruct_result1493 write(pp, "(keys") - indent_sexp!(pp) newline(pp) - write(pp, ":") - write(pp, unwrapped1494) - dedent!(pp) - write(pp, ")") + write(pp, "synthetic)") else throw(ParseError("No matching rule for relation_keys")) end diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index 6458b90f..0f8f318f 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -425,225 +425,218 @@ def _extract_value_int32(self, value: logic_pb2.Value | None, default: int) -> i if value is None: return int(default) else: - _t2211 = None + _t2208 = None assert value is not None if value.HasField("int32_value"): assert value is not None return value.int32_value else: - _t2212 = None + _t2209 = None raise ParseError("expected an int32 value (e.g. `1i32`) for this config field") def _extract_value_int64(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None - _t2213 = value.HasField("int_value") + _t2210 = value.HasField("int_value") else: - _t2213 = False - if _t2213: + _t2210 = False + if _t2210: assert value is not None return value.int_value else: - _t2214 = None + _t2211 = None return default def _extract_value_string(self, value: logic_pb2.Value | None, default: str) -> str: if value is not None: assert value is not None - _t2215 = value.HasField("string_value") + _t2212 = value.HasField("string_value") else: - _t2215 = False - if _t2215: + _t2212 = False + if _t2212: assert value is not None return value.string_value else: - _t2216 = None + _t2213 = None return default def _extract_value_boolean(self, value: logic_pb2.Value | None, default: bool) -> bool: if value is not None: assert value is not None - _t2217 = value.HasField("boolean_value") + _t2214 = value.HasField("boolean_value") else: - _t2217 = False - if _t2217: + _t2214 = False + if _t2214: assert value is not None return value.boolean_value else: - _t2218 = None + _t2215 = None return default def _extract_value_string_list(self, value: logic_pb2.Value | None, default: Sequence[str]) -> Sequence[str]: if value is not None: assert value is not None - _t2219 = value.HasField("string_value") + _t2216 = value.HasField("string_value") else: - _t2219 = False - if _t2219: + _t2216 = False + if _t2216: assert value is not None return [value.string_value] else: - _t2220 = None + _t2217 = None return default def _try_extract_value_int64(self, value: logic_pb2.Value | None) -> int | None: if value is not None: assert value is not None - _t2221 = value.HasField("int_value") + _t2218 = value.HasField("int_value") else: - _t2221 = False - if _t2221: + _t2218 = False + if _t2218: assert value is not None return value.int_value else: - _t2222 = None + _t2219 = None return None def _try_extract_value_float64(self, value: logic_pb2.Value | None) -> float | None: if value is not None: assert value is not None - _t2223 = value.HasField("float_value") + _t2220 = value.HasField("float_value") else: - _t2223 = False - if _t2223: + _t2220 = False + if _t2220: assert value is not None return value.float_value else: - _t2224 = None + _t2221 = None return None def _try_extract_value_bytes(self, value: logic_pb2.Value | None) -> bytes | None: if value is not None: assert value is not None - _t2225 = value.HasField("string_value") + _t2222 = value.HasField("string_value") else: - _t2225 = False - if _t2225: + _t2222 = False + if _t2222: assert value is not None return value.string_value.encode() else: - _t2226 = None + _t2223 = None return None def _try_extract_value_uint128(self, value: logic_pb2.Value | None) -> logic_pb2.UInt128Value | None: if value is not None: assert value is not None - _t2227 = value.HasField("uint128_value") + _t2224 = value.HasField("uint128_value") else: - _t2227 = False - if _t2227: + _t2224 = False + if _t2224: assert value is not None return value.uint128_value else: - _t2228 = None + _t2225 = None return None def construct_non_cdc_relations(self, targets: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2229 = logic_pb2.PlainTargets(targets=targets) - _t2230 = logic_pb2.TargetRelations(keys=[], plain=_t2229) - return _t2230 + _t2226 = logic_pb2.PlainTargets(targets=targets) + _t2227 = logic_pb2.TargetRelations(keys=[], plain=_t2226) + return _t2227 def construct_cdc_relations(self, inserts: Sequence[logic_pb2.TargetRelation], deletes: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2231 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) - _t2232 = logic_pb2.TargetRelations(keys=[], cdc=_t2231) - return _t2232 - - def construct_synthetic_keys(self, marker: str) -> tuple[Sequence[logic_pb2.NamedColumn], bool]: - if marker != "synthetic_key": - raise ParseError("expected the `:synthetic_key` marker in the relation keys clause") - else: - _t2233 = None - return ([], True,) + _t2228 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) + _t2229 = logic_pb2.TargetRelations(keys=[], cdc=_t2228) + return _t2229 def construct_relations(self, keys: tuple[Sequence[logic_pb2.NamedColumn], bool], body: logic_pb2.TargetRelations) -> logic_pb2.TargetRelations: if body.HasField("plain"): - _t2235 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], plain=body.plain) - return _t2235 + _t2231 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], plain=body.plain) + return _t2231 else: - _t2234 = None - _t2236 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], cdc=body.cdc) - return _t2236 + _t2230 = None + _t2232 = logic_pb2.TargetRelations(keys=keys[0], synthetic_key=keys[1], cdc=body.cdc) + return _t2232 def construct_csv_data(self, locator: logic_pb2.CSVLocator, config: logic_pb2.CSVConfig, columns_opt: Sequence[logic_pb2.GNFColumn] | None, relations_opt: logic_pb2.TargetRelations | None, asof: str) -> logic_pb2.CSVData: - _t2237 = logic_pb2.CSVData(locator=locator, config=config, columns=(columns_opt if columns_opt is not None else []), asof=asof, relations=relations_opt) - return _t2237 + _t2233 = logic_pb2.CSVData(locator=locator, config=config, columns=(columns_opt if columns_opt is not None else []), asof=asof, relations=relations_opt) + return _t2233 def construct_csv_config(self, config_dict: Sequence[tuple[str, logic_pb2.Value]], storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.CSVConfig: config = dict(config_dict) - _t2238 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2238 - _t2239 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2239 - _t2240 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2240 - _t2241 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2241 - _t2242 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2242 - _t2243 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2243 - _t2244 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2244 - _t2245 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2245 - _t2246 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2246 - _t2247 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2247 - _t2248 = self._extract_value_string(config.get("csv_compression"), "") - compression = _t2248 - _t2249 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2249 - _t2250 = self.construct_csv_storage_integration(storage_integration_opt) - storage_integration = _t2250 - _t2251 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) - return _t2251 + _t2234 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t2234 + _t2235 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t2235 + _t2236 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t2236 + _t2237 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t2237 + _t2238 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t2238 + _t2239 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t2239 + _t2240 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t2240 + _t2241 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t2241 + _t2242 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t2242 + _t2243 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t2243 + _t2244 = self._extract_value_string(config.get("csv_compression"), "") + compression = _t2244 + _t2245 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) + partition_size_mb = _t2245 + _t2246 = self.construct_csv_storage_integration(storage_integration_opt) + storage_integration = _t2246 + _t2247 = logic_pb2.CSVConfig(header_row=header_row, skip=skip, new_line=new_line, delimiter=delimiter, quotechar=quotechar, escapechar=escapechar, comment=comment, missing_strings=missing_strings, decimal_separator=decimal_separator, encoding=encoding, compression=compression, partition_size_mb=partition_size_mb, storage_integration=storage_integration) + return _t2247 def construct_csv_storage_integration(self, storage_integration_opt: Sequence[tuple[str, logic_pb2.Value]] | None) -> logic_pb2.StorageIntegration | None: if storage_integration_opt is None: return None else: - _t2252 = None + _t2248 = None assert storage_integration_opt is not None config = dict(storage_integration_opt) - _t2253 = self._extract_value_string(config.get("provider"), "") - _t2254 = self._extract_value_string(config.get("azure_sas_token"), "") - _t2255 = self._extract_value_string(config.get("s3_region"), "") - _t2256 = self._extract_value_string(config.get("s3_access_key_id"), "") - _t2257 = self._extract_value_string(config.get("s3_secret_access_key"), "") - _t2258 = logic_pb2.StorageIntegration(provider=_t2253, azure_sas_token=_t2254, s3_region=_t2255, s3_access_key_id=_t2256, s3_secret_access_key=_t2257) - return _t2258 + _t2249 = self._extract_value_string(config.get("provider"), "") + _t2250 = self._extract_value_string(config.get("azure_sas_token"), "") + _t2251 = self._extract_value_string(config.get("s3_region"), "") + _t2252 = self._extract_value_string(config.get("s3_access_key_id"), "") + _t2253 = self._extract_value_string(config.get("s3_secret_access_key"), "") + _t2254 = logic_pb2.StorageIntegration(provider=_t2249, azure_sas_token=_t2250, s3_region=_t2251, s3_access_key_id=_t2252, s3_secret_access_key=_t2253) + return _t2254 def construct_betree_info(self, key_types: Sequence[logic_pb2.Type], value_types: Sequence[logic_pb2.Type], config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> logic_pb2.BeTreeInfo: config = dict(config_dict) - _t2259 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2259 - _t2260 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2260 - _t2261 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2261 - _t2262 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2262 - _t2263 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2263 - _t2264 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2264 - _t2265 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2265 - _t2266 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2266 - _t2267 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2267 - _t2268 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2268 - _t2269 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2269 + _t2255 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t2255 + _t2256 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t2256 + _t2257 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t2257 + _t2258 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t2258 + _t2259 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2259 + _t2260 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t2260 + _t2261 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t2261 + _t2262 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t2262 + _t2263 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t2263 + _t2264 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t2264 + _t2265 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2265 def default_configure(self) -> transactions_pb2.Configure: - _t2270 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2270 - _t2271 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2271 + _t2266 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2266 + _t2267 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2267 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -660,3588 +653,3586 @@ def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]] maintenance_level = transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL else: maintenance_level = transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t2272 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2272 - _t2273 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2273 - _t2274 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2274 + _t2268 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t2268 + _t2269 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t2269 + _t2270 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2270 def construct_export_csv_config(self, path: str, columns: Sequence[transactions_pb2.ExportCSVColumn], config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.ExportCSVConfig: config = dict(config_dict) - _t2275 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2275 - _t2276 = self._extract_value_string(config.get("compression"), "") - compression = _t2276 - _t2277 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2277 - _t2278 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2278 - _t2279 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2279 - _t2280 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2280 - _t2281 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2281 - _t2282 = transactions_pb2.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) - return _t2282 + _t2271 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t2271 + _t2272 = self._extract_value_string(config.get("compression"), "") + compression = _t2272 + _t2273 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t2273 + _t2274 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t2274 + _t2275 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t2275 + _t2276 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t2276 + _t2277 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t2277 + _t2278 = transactions_pb2.ExportCSVConfig(path=path, data_columns=columns, partition_size=partition_size, compression=compression, syntax_header_row=syntax_header_row, syntax_missing_string=syntax_missing_string, syntax_delim=syntax_delim, syntax_quotechar=syntax_quotechar, syntax_escapechar=syntax_escapechar) + return _t2278 def construct_export_csv_config_with_location(self, location: tuple[str, str], csv_source: transactions_pb2.ExportCSVSource, csv_config: logic_pb2.CSVConfig) -> transactions_pb2.ExportCSVConfig: - _t2283 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) - return _t2283 + _t2279 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) + return _t2279 def construct_iceberg_catalog_config(self, catalog_uri: str, scope_opt: str | None, property_pairs: Sequence[tuple[str, str]], auth_property_pairs: Sequence[tuple[str, str]]) -> logic_pb2.IcebergCatalogConfig: props = dict(property_pairs) auth_props = dict(auth_property_pairs) - _t2284 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2284 + _t2280 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) + return _t2280 def construct_iceberg_data(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, columns: Sequence[logic_pb2.GNFColumn], from_snapshot_opt: str | None, to_snapshot_opt: str | None, returns_delta: bool) -> logic_pb2.IcebergData: - _t2285 = logic_pb2.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(from_snapshot_opt if from_snapshot_opt is not None else ""), to_snapshot=(to_snapshot_opt if to_snapshot_opt is not None else ""), returns_delta=returns_delta) - return _t2285 + _t2281 = logic_pb2.IcebergData(locator=locator, config=config, columns=columns, from_snapshot=(from_snapshot_opt if from_snapshot_opt is not None else ""), to_snapshot=(to_snapshot_opt if to_snapshot_opt is not None else ""), returns_delta=returns_delta) + return _t2281 def construct_export_iceberg_config_full(self, locator: logic_pb2.IcebergLocator, config: logic_pb2.IcebergCatalogConfig, table_def: logic_pb2.RelationId, table_property_pairs: Sequence[tuple[str, str]], config_dict: Sequence[tuple[str, logic_pb2.Value]] | None) -> transactions_pb2.ExportIcebergConfig: cfg = dict((config_dict if config_dict is not None else [])) - _t2286 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2286 - _t2287 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2287 - _t2288 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2288 + _t2282 = self._extract_value_string(cfg.get("prefix"), "") + prefix = _t2282 + _t2283 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) + target_file_size_bytes = _t2283 + _t2284 = self._extract_value_string(cfg.get("compression"), "") + compression = _t2284 table_props = dict(table_property_pairs) - _t2289 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) - return _t2289 + _t2285 = transactions_pb2.ExportIcebergConfig(locator=locator, config=config, table_def=table_def, prefix=prefix, target_file_size_bytes=target_file_size_bytes, compression=compression, table_properties=table_props) + return _t2285 # --- Parse methods --- def parse_transaction(self) -> transactions_pb2.Transaction: - span_start715 = self.span_start() + span_start714 = self.span_start() self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t1419 = self.parse_configure() - _t1418 = _t1419 + _t1417 = self.parse_configure() + _t1416 = _t1417 else: - _t1418 = None - configure709 = _t1418 + _t1416 = None + configure708 = _t1416 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t1421 = self.parse_sync() - _t1420 = _t1421 + _t1419 = self.parse_sync() + _t1418 = _t1419 else: - _t1420 = None - sync710 = _t1420 - xs711 = [] - cond712 = self.match_lookahead_literal("(", 0) - while cond712: - _t1422 = self.parse_epoch() - item713 = _t1422 - xs711.append(item713) - cond712 = self.match_lookahead_literal("(", 0) - epochs714 = xs711 + _t1418 = None + sync709 = _t1418 + xs710 = [] + cond711 = self.match_lookahead_literal("(", 0) + while cond711: + _t1420 = self.parse_epoch() + item712 = _t1420 + xs710.append(item712) + cond711 = self.match_lookahead_literal("(", 0) + epochs713 = xs710 self.consume_literal(")") - _t1423 = self.default_configure() - _t1424 = transactions_pb2.Transaction(epochs=epochs714, configure=(configure709 if configure709 is not None else _t1423), sync=sync710) - result716 = _t1424 - self.record_span(span_start715, "Transaction") - return result716 + _t1421 = self.default_configure() + _t1422 = transactions_pb2.Transaction(epochs=epochs713, configure=(configure708 if configure708 is not None else _t1421), sync=sync709) + result715 = _t1422 + self.record_span(span_start714, "Transaction") + return result715 def parse_configure(self) -> transactions_pb2.Configure: - span_start718 = self.span_start() + span_start717 = self.span_start() self.consume_literal("(") self.consume_literal("configure") - _t1425 = self.parse_config_dict() - config_dict717 = _t1425 + _t1423 = self.parse_config_dict() + config_dict716 = _t1423 self.consume_literal(")") - _t1426 = self.construct_configure(config_dict717) - result719 = _t1426 - self.record_span(span_start718, "Configure") - return result719 + _t1424 = self.construct_configure(config_dict716) + result718 = _t1424 + self.record_span(span_start717, "Configure") + return result718 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs720 = [] - cond721 = self.match_lookahead_literal(":", 0) - while cond721: - _t1427 = self.parse_config_key_value() - item722 = _t1427 - xs720.append(item722) - cond721 = self.match_lookahead_literal(":", 0) - config_key_values723 = xs720 + xs719 = [] + cond720 = self.match_lookahead_literal(":", 0) + while cond720: + _t1425 = self.parse_config_key_value() + item721 = _t1425 + xs719.append(item721) + cond720 = self.match_lookahead_literal(":", 0) + config_key_values722 = xs719 self.consume_literal("}") - return config_key_values723 + return config_key_values722 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol724 = self.consume_terminal("SYMBOL") - _t1428 = self.parse_raw_value() - raw_value725 = _t1428 - return (symbol724, raw_value725,) + symbol723 = self.consume_terminal("SYMBOL") + _t1426 = self.parse_raw_value() + raw_value724 = _t1426 + return (symbol723, raw_value724,) def parse_raw_value(self) -> logic_pb2.Value: - span_start739 = self.span_start() + span_start738 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1429 = 12 + _t1427 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1430 = 11 + _t1428 = 11 else: if self.match_lookahead_literal("false", 0): - _t1431 = 12 + _t1429 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1433 = 1 + _t1431 = 1 else: if self.match_lookahead_literal("date", 1): - _t1434 = 0 + _t1432 = 0 else: - _t1434 = -1 - _t1433 = _t1434 - _t1432 = _t1433 + _t1432 = -1 + _t1431 = _t1432 + _t1430 = _t1431 else: if self.match_lookahead_terminal("UINT32", 0): - _t1435 = 7 + _t1433 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1436 = 8 + _t1434 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1437 = 2 + _t1435 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1438 = 3 + _t1436 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1439 = 9 + _t1437 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1440 = 4 + _t1438 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1441 = 5 + _t1439 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1442 = 6 + _t1440 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1443 = 10 + _t1441 = 10 else: - _t1443 = -1 - _t1442 = _t1443 - _t1441 = _t1442 - _t1440 = _t1441 - _t1439 = _t1440 - _t1438 = _t1439 - _t1437 = _t1438 - _t1436 = _t1437 - _t1435 = _t1436 - _t1432 = _t1435 - _t1431 = _t1432 - _t1430 = _t1431 - _t1429 = _t1430 - prediction726 = _t1429 - if prediction726 == 12: - _t1445 = self.parse_boolean_value() - boolean_value738 = _t1445 - _t1446 = logic_pb2.Value(boolean_value=boolean_value738) - _t1444 = _t1446 + _t1441 = -1 + _t1440 = _t1441 + _t1439 = _t1440 + _t1438 = _t1439 + _t1437 = _t1438 + _t1436 = _t1437 + _t1435 = _t1436 + _t1434 = _t1435 + _t1433 = _t1434 + _t1430 = _t1433 + _t1429 = _t1430 + _t1428 = _t1429 + _t1427 = _t1428 + prediction725 = _t1427 + if prediction725 == 12: + _t1443 = self.parse_boolean_value() + boolean_value737 = _t1443 + _t1444 = logic_pb2.Value(boolean_value=boolean_value737) + _t1442 = _t1444 else: - if prediction726 == 11: + if prediction725 == 11: self.consume_literal("missing") - _t1448 = logic_pb2.MissingValue() - _t1449 = logic_pb2.Value(missing_value=_t1448) - _t1447 = _t1449 + _t1446 = logic_pb2.MissingValue() + _t1447 = logic_pb2.Value(missing_value=_t1446) + _t1445 = _t1447 else: - if prediction726 == 10: - decimal737 = self.consume_terminal("DECIMAL") - _t1451 = logic_pb2.Value(decimal_value=decimal737) - _t1450 = _t1451 + if prediction725 == 10: + decimal736 = self.consume_terminal("DECIMAL") + _t1449 = logic_pb2.Value(decimal_value=decimal736) + _t1448 = _t1449 else: - if prediction726 == 9: - int128736 = self.consume_terminal("INT128") - _t1453 = logic_pb2.Value(int128_value=int128736) - _t1452 = _t1453 + if prediction725 == 9: + int128735 = self.consume_terminal("INT128") + _t1451 = logic_pb2.Value(int128_value=int128735) + _t1450 = _t1451 else: - if prediction726 == 8: - uint128735 = self.consume_terminal("UINT128") - _t1455 = logic_pb2.Value(uint128_value=uint128735) - _t1454 = _t1455 + if prediction725 == 8: + uint128734 = self.consume_terminal("UINT128") + _t1453 = logic_pb2.Value(uint128_value=uint128734) + _t1452 = _t1453 else: - if prediction726 == 7: - uint32734 = self.consume_terminal("UINT32") - _t1457 = logic_pb2.Value(uint32_value=uint32734) - _t1456 = _t1457 + if prediction725 == 7: + uint32733 = self.consume_terminal("UINT32") + _t1455 = logic_pb2.Value(uint32_value=uint32733) + _t1454 = _t1455 else: - if prediction726 == 6: - float733 = self.consume_terminal("FLOAT") - _t1459 = logic_pb2.Value(float_value=float733) - _t1458 = _t1459 + if prediction725 == 6: + float732 = self.consume_terminal("FLOAT") + _t1457 = logic_pb2.Value(float_value=float732) + _t1456 = _t1457 else: - if prediction726 == 5: - float32732 = self.consume_terminal("FLOAT32") - _t1461 = logic_pb2.Value(float32_value=float32732) - _t1460 = _t1461 + if prediction725 == 5: + float32731 = self.consume_terminal("FLOAT32") + _t1459 = logic_pb2.Value(float32_value=float32731) + _t1458 = _t1459 else: - if prediction726 == 4: - int731 = self.consume_terminal("INT") - _t1463 = logic_pb2.Value(int_value=int731) - _t1462 = _t1463 + if prediction725 == 4: + int730 = self.consume_terminal("INT") + _t1461 = logic_pb2.Value(int_value=int730) + _t1460 = _t1461 else: - if prediction726 == 3: - int32730 = self.consume_terminal("INT32") - _t1465 = logic_pb2.Value(int32_value=int32730) - _t1464 = _t1465 + if prediction725 == 3: + int32729 = self.consume_terminal("INT32") + _t1463 = logic_pb2.Value(int32_value=int32729) + _t1462 = _t1463 else: - if prediction726 == 2: - string729 = self.consume_terminal("STRING") - _t1467 = logic_pb2.Value(string_value=string729) - _t1466 = _t1467 + if prediction725 == 2: + string728 = self.consume_terminal("STRING") + _t1465 = logic_pb2.Value(string_value=string728) + _t1464 = _t1465 else: - if prediction726 == 1: - _t1469 = self.parse_raw_datetime() - raw_datetime728 = _t1469 - _t1470 = logic_pb2.Value(datetime_value=raw_datetime728) - _t1468 = _t1470 + if prediction725 == 1: + _t1467 = self.parse_raw_datetime() + raw_datetime727 = _t1467 + _t1468 = logic_pb2.Value(datetime_value=raw_datetime727) + _t1466 = _t1468 else: - if prediction726 == 0: - _t1472 = self.parse_raw_date() - raw_date727 = _t1472 - _t1473 = logic_pb2.Value(date_value=raw_date727) - _t1471 = _t1473 + if prediction725 == 0: + _t1470 = self.parse_raw_date() + raw_date726 = _t1470 + _t1471 = logic_pb2.Value(date_value=raw_date726) + _t1469 = _t1471 else: raise ParseError("Unexpected token in raw_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1468 = _t1471 - _t1466 = _t1468 - _t1464 = _t1466 - _t1462 = _t1464 - _t1460 = _t1462 - _t1458 = _t1460 - _t1456 = _t1458 - _t1454 = _t1456 - _t1452 = _t1454 - _t1450 = _t1452 - _t1447 = _t1450 - _t1444 = _t1447 - result740 = _t1444 - self.record_span(span_start739, "Value") - return result740 + _t1466 = _t1469 + _t1464 = _t1466 + _t1462 = _t1464 + _t1460 = _t1462 + _t1458 = _t1460 + _t1456 = _t1458 + _t1454 = _t1456 + _t1452 = _t1454 + _t1450 = _t1452 + _t1448 = _t1450 + _t1445 = _t1448 + _t1442 = _t1445 + result739 = _t1442 + self.record_span(span_start738, "Value") + return result739 def parse_raw_date(self) -> logic_pb2.DateValue: - span_start744 = self.span_start() + span_start743 = self.span_start() self.consume_literal("(") self.consume_literal("date") - int741 = self.consume_terminal("INT") - int_3742 = self.consume_terminal("INT") - int_4743 = self.consume_terminal("INT") + int740 = self.consume_terminal("INT") + int_3741 = self.consume_terminal("INT") + int_4742 = self.consume_terminal("INT") self.consume_literal(")") - _t1474 = logic_pb2.DateValue(year=int(int741), month=int(int_3742), day=int(int_4743)) - result745 = _t1474 - self.record_span(span_start744, "DateValue") - return result745 + _t1472 = logic_pb2.DateValue(year=int(int740), month=int(int_3741), day=int(int_4742)) + result744 = _t1472 + self.record_span(span_start743, "DateValue") + return result744 def parse_raw_datetime(self) -> logic_pb2.DateTimeValue: - span_start753 = self.span_start() + span_start752 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - int746 = self.consume_terminal("INT") - int_3747 = self.consume_terminal("INT") - int_4748 = self.consume_terminal("INT") - int_5749 = self.consume_terminal("INT") - int_6750 = self.consume_terminal("INT") - int_7751 = self.consume_terminal("INT") + int745 = self.consume_terminal("INT") + int_3746 = self.consume_terminal("INT") + int_4747 = self.consume_terminal("INT") + int_5748 = self.consume_terminal("INT") + int_6749 = self.consume_terminal("INT") + int_7750 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1475 = self.consume_terminal("INT") + _t1473 = self.consume_terminal("INT") else: - _t1475 = None - int_8752 = _t1475 + _t1473 = None + int_8751 = _t1473 self.consume_literal(")") - _t1476 = logic_pb2.DateTimeValue(year=int(int746), month=int(int_3747), day=int(int_4748), hour=int(int_5749), minute=int(int_6750), second=int(int_7751), microsecond=int((int_8752 if int_8752 is not None else 0))) - result754 = _t1476 - self.record_span(span_start753, "DateTimeValue") - return result754 + _t1474 = logic_pb2.DateTimeValue(year=int(int745), month=int(int_3746), day=int(int_4747), hour=int(int_5748), minute=int(int_6749), second=int(int_7750), microsecond=int((int_8751 if int_8751 is not None else 0))) + result753 = _t1474 + self.record_span(span_start752, "DateTimeValue") + return result753 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t1477 = 0 + _t1475 = 0 else: if self.match_lookahead_literal("false", 0): - _t1478 = 1 + _t1476 = 1 else: - _t1478 = -1 - _t1477 = _t1478 - prediction755 = _t1477 - if prediction755 == 1: + _t1476 = -1 + _t1475 = _t1476 + prediction754 = _t1475 + if prediction754 == 1: self.consume_literal("false") - _t1479 = False + _t1477 = False else: - if prediction755 == 0: + if prediction754 == 0: self.consume_literal("true") - _t1480 = True + _t1478 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1479 = _t1480 - return _t1479 + _t1477 = _t1478 + return _t1477 def parse_sync(self) -> transactions_pb2.Sync: - span_start760 = self.span_start() + span_start759 = self.span_start() self.consume_literal("(") self.consume_literal("sync") - xs756 = [] - cond757 = self.match_lookahead_literal(":", 0) - while cond757: - _t1481 = self.parse_fragment_id() - item758 = _t1481 - xs756.append(item758) - cond757 = self.match_lookahead_literal(":", 0) - fragment_ids759 = xs756 + xs755 = [] + cond756 = self.match_lookahead_literal(":", 0) + while cond756: + _t1479 = self.parse_fragment_id() + item757 = _t1479 + xs755.append(item757) + cond756 = self.match_lookahead_literal(":", 0) + fragment_ids758 = xs755 self.consume_literal(")") - _t1482 = transactions_pb2.Sync(fragments=fragment_ids759) - result761 = _t1482 - self.record_span(span_start760, "Sync") - return result761 + _t1480 = transactions_pb2.Sync(fragments=fragment_ids758) + result760 = _t1480 + self.record_span(span_start759, "Sync") + return result760 def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start763 = self.span_start() + span_start762 = self.span_start() self.consume_literal(":") - symbol762 = self.consume_terminal("SYMBOL") - result764 = fragments_pb2.FragmentId(id=symbol762.encode()) - self.record_span(span_start763, "FragmentId") - return result764 + symbol761 = self.consume_terminal("SYMBOL") + result763 = fragments_pb2.FragmentId(id=symbol761.encode()) + self.record_span(span_start762, "FragmentId") + return result763 def parse_epoch(self) -> transactions_pb2.Epoch: - span_start767 = self.span_start() + span_start766 = self.span_start() self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t1484 = self.parse_epoch_writes() - _t1483 = _t1484 + _t1482 = self.parse_epoch_writes() + _t1481 = _t1482 else: - _t1483 = None - epoch_writes765 = _t1483 + _t1481 = None + epoch_writes764 = _t1481 if self.match_lookahead_literal("(", 0): - _t1486 = self.parse_epoch_reads() - _t1485 = _t1486 + _t1484 = self.parse_epoch_reads() + _t1483 = _t1484 else: - _t1485 = None - epoch_reads766 = _t1485 + _t1483 = None + epoch_reads765 = _t1483 self.consume_literal(")") - _t1487 = transactions_pb2.Epoch(writes=(epoch_writes765 if epoch_writes765 is not None else []), reads=(epoch_reads766 if epoch_reads766 is not None else [])) - result768 = _t1487 - self.record_span(span_start767, "Epoch") - return result768 + _t1485 = transactions_pb2.Epoch(writes=(epoch_writes764 if epoch_writes764 is not None else []), reads=(epoch_reads765 if epoch_reads765 is not None else [])) + result767 = _t1485 + self.record_span(span_start766, "Epoch") + return result767 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs769 = [] - cond770 = self.match_lookahead_literal("(", 0) - while cond770: - _t1488 = self.parse_write() - item771 = _t1488 - xs769.append(item771) - cond770 = self.match_lookahead_literal("(", 0) - writes772 = xs769 + xs768 = [] + cond769 = self.match_lookahead_literal("(", 0) + while cond769: + _t1486 = self.parse_write() + item770 = _t1486 + xs768.append(item770) + cond769 = self.match_lookahead_literal("(", 0) + writes771 = xs768 self.consume_literal(")") - return writes772 + return writes771 def parse_write(self) -> transactions_pb2.Write: - span_start778 = self.span_start() + span_start777 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t1490 = 1 + _t1488 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t1491 = 3 + _t1489 = 3 else: if self.match_lookahead_literal("define", 1): - _t1492 = 0 + _t1490 = 0 else: if self.match_lookahead_literal("context", 1): - _t1493 = 2 + _t1491 = 2 else: - _t1493 = -1 - _t1492 = _t1493 - _t1491 = _t1492 - _t1490 = _t1491 - _t1489 = _t1490 + _t1491 = -1 + _t1490 = _t1491 + _t1489 = _t1490 + _t1488 = _t1489 + _t1487 = _t1488 else: - _t1489 = -1 - prediction773 = _t1489 - if prediction773 == 3: - _t1495 = self.parse_snapshot() - snapshot777 = _t1495 - _t1496 = transactions_pb2.Write(snapshot=snapshot777) - _t1494 = _t1496 + _t1487 = -1 + prediction772 = _t1487 + if prediction772 == 3: + _t1493 = self.parse_snapshot() + snapshot776 = _t1493 + _t1494 = transactions_pb2.Write(snapshot=snapshot776) + _t1492 = _t1494 else: - if prediction773 == 2: - _t1498 = self.parse_context() - context776 = _t1498 - _t1499 = transactions_pb2.Write(context=context776) - _t1497 = _t1499 + if prediction772 == 2: + _t1496 = self.parse_context() + context775 = _t1496 + _t1497 = transactions_pb2.Write(context=context775) + _t1495 = _t1497 else: - if prediction773 == 1: - _t1501 = self.parse_undefine() - undefine775 = _t1501 - _t1502 = transactions_pb2.Write(undefine=undefine775) - _t1500 = _t1502 + if prediction772 == 1: + _t1499 = self.parse_undefine() + undefine774 = _t1499 + _t1500 = transactions_pb2.Write(undefine=undefine774) + _t1498 = _t1500 else: - if prediction773 == 0: - _t1504 = self.parse_define() - define774 = _t1504 - _t1505 = transactions_pb2.Write(define=define774) - _t1503 = _t1505 + if prediction772 == 0: + _t1502 = self.parse_define() + define773 = _t1502 + _t1503 = transactions_pb2.Write(define=define773) + _t1501 = _t1503 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1500 = _t1503 - _t1497 = _t1500 - _t1494 = _t1497 - result779 = _t1494 - self.record_span(span_start778, "Write") - return result779 + _t1498 = _t1501 + _t1495 = _t1498 + _t1492 = _t1495 + result778 = _t1492 + self.record_span(span_start777, "Write") + return result778 def parse_define(self) -> transactions_pb2.Define: - span_start781 = self.span_start() + span_start780 = self.span_start() self.consume_literal("(") self.consume_literal("define") - _t1506 = self.parse_fragment() - fragment780 = _t1506 + _t1504 = self.parse_fragment() + fragment779 = _t1504 self.consume_literal(")") - _t1507 = transactions_pb2.Define(fragment=fragment780) - result782 = _t1507 - self.record_span(span_start781, "Define") - return result782 + _t1505 = transactions_pb2.Define(fragment=fragment779) + result781 = _t1505 + self.record_span(span_start780, "Define") + return result781 def parse_fragment(self) -> fragments_pb2.Fragment: - span_start788 = self.span_start() + span_start787 = self.span_start() self.consume_literal("(") self.consume_literal("fragment") - _t1508 = self.parse_new_fragment_id() - new_fragment_id783 = _t1508 - xs784 = [] - cond785 = self.match_lookahead_literal("(", 0) - while cond785: - _t1509 = self.parse_declaration() - item786 = _t1509 - xs784.append(item786) - cond785 = self.match_lookahead_literal("(", 0) - declarations787 = xs784 + _t1506 = self.parse_new_fragment_id() + new_fragment_id782 = _t1506 + xs783 = [] + cond784 = self.match_lookahead_literal("(", 0) + while cond784: + _t1507 = self.parse_declaration() + item785 = _t1507 + xs783.append(item785) + cond784 = self.match_lookahead_literal("(", 0) + declarations786 = xs783 self.consume_literal(")") - result789 = self.construct_fragment(new_fragment_id783, declarations787) - self.record_span(span_start788, "Fragment") - return result789 + result788 = self.construct_fragment(new_fragment_id782, declarations786) + self.record_span(span_start787, "Fragment") + return result788 def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - span_start791 = self.span_start() - _t1510 = self.parse_fragment_id() - fragment_id790 = _t1510 - self.start_fragment(fragment_id790) - result792 = fragment_id790 - self.record_span(span_start791, "FragmentId") - return result792 + span_start790 = self.span_start() + _t1508 = self.parse_fragment_id() + fragment_id789 = _t1508 + self.start_fragment(fragment_id789) + result791 = fragment_id789 + self.record_span(span_start790, "FragmentId") + return result791 def parse_declaration(self) -> logic_pb2.Declaration: - span_start798 = self.span_start() + span_start797 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1512 = 3 + _t1510 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t1513 = 2 + _t1511 = 2 else: if self.match_lookahead_literal("edb", 1): - _t1514 = 3 + _t1512 = 3 else: if self.match_lookahead_literal("def", 1): - _t1515 = 0 + _t1513 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1516 = 3 + _t1514 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t1517 = 3 + _t1515 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t1518 = 1 + _t1516 = 1 else: - _t1518 = -1 - _t1517 = _t1518 - _t1516 = _t1517 - _t1515 = _t1516 - _t1514 = _t1515 - _t1513 = _t1514 - _t1512 = _t1513 - _t1511 = _t1512 + _t1516 = -1 + _t1515 = _t1516 + _t1514 = _t1515 + _t1513 = _t1514 + _t1512 = _t1513 + _t1511 = _t1512 + _t1510 = _t1511 + _t1509 = _t1510 else: - _t1511 = -1 - prediction793 = _t1511 - if prediction793 == 3: - _t1520 = self.parse_data() - data797 = _t1520 - _t1521 = logic_pb2.Declaration(data=data797) - _t1519 = _t1521 + _t1509 = -1 + prediction792 = _t1509 + if prediction792 == 3: + _t1518 = self.parse_data() + data796 = _t1518 + _t1519 = logic_pb2.Declaration(data=data796) + _t1517 = _t1519 else: - if prediction793 == 2: - _t1523 = self.parse_constraint() - constraint796 = _t1523 - _t1524 = logic_pb2.Declaration(constraint=constraint796) - _t1522 = _t1524 + if prediction792 == 2: + _t1521 = self.parse_constraint() + constraint795 = _t1521 + _t1522 = logic_pb2.Declaration(constraint=constraint795) + _t1520 = _t1522 else: - if prediction793 == 1: - _t1526 = self.parse_algorithm() - algorithm795 = _t1526 - _t1527 = logic_pb2.Declaration(algorithm=algorithm795) - _t1525 = _t1527 + if prediction792 == 1: + _t1524 = self.parse_algorithm() + algorithm794 = _t1524 + _t1525 = logic_pb2.Declaration(algorithm=algorithm794) + _t1523 = _t1525 else: - if prediction793 == 0: - _t1529 = self.parse_def() - def794 = _t1529 - _t1530 = logic_pb2.Declaration() - getattr(_t1530, 'def').CopyFrom(def794) - _t1528 = _t1530 + if prediction792 == 0: + _t1527 = self.parse_def() + def793 = _t1527 + _t1528 = logic_pb2.Declaration() + getattr(_t1528, 'def').CopyFrom(def793) + _t1526 = _t1528 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1525 = _t1528 - _t1522 = _t1525 - _t1519 = _t1522 - result799 = _t1519 - self.record_span(span_start798, "Declaration") - return result799 + _t1523 = _t1526 + _t1520 = _t1523 + _t1517 = _t1520 + result798 = _t1517 + self.record_span(span_start797, "Declaration") + return result798 def parse_def(self) -> logic_pb2.Def: - span_start803 = self.span_start() + span_start802 = self.span_start() self.consume_literal("(") self.consume_literal("def") - _t1531 = self.parse_relation_id() - relation_id800 = _t1531 - _t1532 = self.parse_abstraction() - abstraction801 = _t1532 + _t1529 = self.parse_relation_id() + relation_id799 = _t1529 + _t1530 = self.parse_abstraction() + abstraction800 = _t1530 if self.match_lookahead_literal("(", 0): - _t1534 = self.parse_attrs() - _t1533 = _t1534 + _t1532 = self.parse_attrs() + _t1531 = _t1532 else: - _t1533 = None - attrs802 = _t1533 + _t1531 = None + attrs801 = _t1531 self.consume_literal(")") - _t1535 = logic_pb2.Def(name=relation_id800, body=abstraction801, attrs=(attrs802 if attrs802 is not None else [])) - result804 = _t1535 - self.record_span(span_start803, "Def") - return result804 + _t1533 = logic_pb2.Def(name=relation_id799, body=abstraction800, attrs=(attrs801 if attrs801 is not None else [])) + result803 = _t1533 + self.record_span(span_start802, "Def") + return result803 def parse_relation_id(self) -> logic_pb2.RelationId: - span_start808 = self.span_start() + span_start807 = self.span_start() if self.match_lookahead_literal(":", 0): - _t1536 = 0 + _t1534 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1537 = 1 + _t1535 = 1 else: - _t1537 = -1 - _t1536 = _t1537 - prediction805 = _t1536 - if prediction805 == 1: - uint128807 = self.consume_terminal("UINT128") - _t1538 = logic_pb2.RelationId(id_low=uint128807.low, id_high=uint128807.high) + _t1535 = -1 + _t1534 = _t1535 + prediction804 = _t1534 + if prediction804 == 1: + uint128806 = self.consume_terminal("UINT128") + _t1536 = logic_pb2.RelationId(id_low=uint128806.low, id_high=uint128806.high) else: - if prediction805 == 0: + if prediction804 == 0: self.consume_literal(":") - symbol806 = self.consume_terminal("SYMBOL") - _t1539 = self.relation_id_from_string(symbol806) + symbol805 = self.consume_terminal("SYMBOL") + _t1537 = self.relation_id_from_string(symbol805) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1538 = _t1539 - result809 = _t1538 - self.record_span(span_start808, "RelationId") - return result809 + _t1536 = _t1537 + result808 = _t1536 + self.record_span(span_start807, "RelationId") + return result808 def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start812 = self.span_start() + span_start811 = self.span_start() self.consume_literal("(") - _t1540 = self.parse_bindings() - bindings810 = _t1540 - _t1541 = self.parse_formula() - formula811 = _t1541 + _t1538 = self.parse_bindings() + bindings809 = _t1538 + _t1539 = self.parse_formula() + formula810 = _t1539 self.consume_literal(")") - _t1542 = logic_pb2.Abstraction(vars=(list(bindings810[0]) + list(bindings810[1] if bindings810[1] is not None else [])), value=formula811) - result813 = _t1542 - self.record_span(span_start812, "Abstraction") - return result813 + _t1540 = logic_pb2.Abstraction(vars=(list(bindings809[0]) + list(bindings809[1] if bindings809[1] is not None else [])), value=formula810) + result812 = _t1540 + self.record_span(span_start811, "Abstraction") + return result812 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs814 = [] - cond815 = self.match_lookahead_terminal("SYMBOL", 0) - while cond815: - _t1543 = self.parse_binding() - item816 = _t1543 - xs814.append(item816) - cond815 = self.match_lookahead_terminal("SYMBOL", 0) - bindings817 = xs814 + xs813 = [] + cond814 = self.match_lookahead_terminal("SYMBOL", 0) + while cond814: + _t1541 = self.parse_binding() + item815 = _t1541 + xs813.append(item815) + cond814 = self.match_lookahead_terminal("SYMBOL", 0) + bindings816 = xs813 if self.match_lookahead_literal("|", 0): - _t1545 = self.parse_value_bindings() - _t1544 = _t1545 + _t1543 = self.parse_value_bindings() + _t1542 = _t1543 else: - _t1544 = None - value_bindings818 = _t1544 + _t1542 = None + value_bindings817 = _t1542 self.consume_literal("]") - return (bindings817, (value_bindings818 if value_bindings818 is not None else []),) + return (bindings816, (value_bindings817 if value_bindings817 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - span_start821 = self.span_start() - symbol819 = self.consume_terminal("SYMBOL") + span_start820 = self.span_start() + symbol818 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t1546 = self.parse_type() - type820 = _t1546 - _t1547 = logic_pb2.Var(name=symbol819) - _t1548 = logic_pb2.Binding(var=_t1547, type=type820) - result822 = _t1548 - self.record_span(span_start821, "Binding") - return result822 + _t1544 = self.parse_type() + type819 = _t1544 + _t1545 = logic_pb2.Var(name=symbol818) + _t1546 = logic_pb2.Binding(var=_t1545, type=type819) + result821 = _t1546 + self.record_span(span_start820, "Binding") + return result821 def parse_type(self) -> logic_pb2.Type: - span_start838 = self.span_start() + span_start837 = self.span_start() if self.match_lookahead_literal("UNKNOWN", 0): - _t1549 = 0 + _t1547 = 0 else: if self.match_lookahead_literal("UINT32", 0): - _t1550 = 13 + _t1548 = 13 else: if self.match_lookahead_literal("UINT128", 0): - _t1551 = 4 + _t1549 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t1552 = 1 + _t1550 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t1553 = 8 + _t1551 = 8 else: if self.match_lookahead_literal("INT32", 0): - _t1554 = 11 + _t1552 = 11 else: if self.match_lookahead_literal("INT128", 0): - _t1555 = 5 + _t1553 = 5 else: if self.match_lookahead_literal("INT", 0): - _t1556 = 2 + _t1554 = 2 else: if self.match_lookahead_literal("FLOAT32", 0): - _t1557 = 12 + _t1555 = 12 else: if self.match_lookahead_literal("FLOAT", 0): - _t1558 = 3 + _t1556 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t1559 = 7 + _t1557 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t1560 = 6 + _t1558 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t1561 = 10 + _t1559 = 10 else: if self.match_lookahead_literal("(", 0): - _t1562 = 9 + _t1560 = 9 else: - _t1562 = -1 - _t1561 = _t1562 - _t1560 = _t1561 - _t1559 = _t1560 - _t1558 = _t1559 - _t1557 = _t1558 - _t1556 = _t1557 - _t1555 = _t1556 - _t1554 = _t1555 - _t1553 = _t1554 - _t1552 = _t1553 - _t1551 = _t1552 - _t1550 = _t1551 - _t1549 = _t1550 - prediction823 = _t1549 - if prediction823 == 13: - _t1564 = self.parse_uint32_type() - uint32_type837 = _t1564 - _t1565 = logic_pb2.Type(uint32_type=uint32_type837) - _t1563 = _t1565 + _t1560 = -1 + _t1559 = _t1560 + _t1558 = _t1559 + _t1557 = _t1558 + _t1556 = _t1557 + _t1555 = _t1556 + _t1554 = _t1555 + _t1553 = _t1554 + _t1552 = _t1553 + _t1551 = _t1552 + _t1550 = _t1551 + _t1549 = _t1550 + _t1548 = _t1549 + _t1547 = _t1548 + prediction822 = _t1547 + if prediction822 == 13: + _t1562 = self.parse_uint32_type() + uint32_type836 = _t1562 + _t1563 = logic_pb2.Type(uint32_type=uint32_type836) + _t1561 = _t1563 else: - if prediction823 == 12: - _t1567 = self.parse_float32_type() - float32_type836 = _t1567 - _t1568 = logic_pb2.Type(float32_type=float32_type836) - _t1566 = _t1568 + if prediction822 == 12: + _t1565 = self.parse_float32_type() + float32_type835 = _t1565 + _t1566 = logic_pb2.Type(float32_type=float32_type835) + _t1564 = _t1566 else: - if prediction823 == 11: - _t1570 = self.parse_int32_type() - int32_type835 = _t1570 - _t1571 = logic_pb2.Type(int32_type=int32_type835) - _t1569 = _t1571 + if prediction822 == 11: + _t1568 = self.parse_int32_type() + int32_type834 = _t1568 + _t1569 = logic_pb2.Type(int32_type=int32_type834) + _t1567 = _t1569 else: - if prediction823 == 10: - _t1573 = self.parse_boolean_type() - boolean_type834 = _t1573 - _t1574 = logic_pb2.Type(boolean_type=boolean_type834) - _t1572 = _t1574 + if prediction822 == 10: + _t1571 = self.parse_boolean_type() + boolean_type833 = _t1571 + _t1572 = logic_pb2.Type(boolean_type=boolean_type833) + _t1570 = _t1572 else: - if prediction823 == 9: - _t1576 = self.parse_decimal_type() - decimal_type833 = _t1576 - _t1577 = logic_pb2.Type(decimal_type=decimal_type833) - _t1575 = _t1577 + if prediction822 == 9: + _t1574 = self.parse_decimal_type() + decimal_type832 = _t1574 + _t1575 = logic_pb2.Type(decimal_type=decimal_type832) + _t1573 = _t1575 else: - if prediction823 == 8: - _t1579 = self.parse_missing_type() - missing_type832 = _t1579 - _t1580 = logic_pb2.Type(missing_type=missing_type832) - _t1578 = _t1580 + if prediction822 == 8: + _t1577 = self.parse_missing_type() + missing_type831 = _t1577 + _t1578 = logic_pb2.Type(missing_type=missing_type831) + _t1576 = _t1578 else: - if prediction823 == 7: - _t1582 = self.parse_datetime_type() - datetime_type831 = _t1582 - _t1583 = logic_pb2.Type(datetime_type=datetime_type831) - _t1581 = _t1583 + if prediction822 == 7: + _t1580 = self.parse_datetime_type() + datetime_type830 = _t1580 + _t1581 = logic_pb2.Type(datetime_type=datetime_type830) + _t1579 = _t1581 else: - if prediction823 == 6: - _t1585 = self.parse_date_type() - date_type830 = _t1585 - _t1586 = logic_pb2.Type(date_type=date_type830) - _t1584 = _t1586 + if prediction822 == 6: + _t1583 = self.parse_date_type() + date_type829 = _t1583 + _t1584 = logic_pb2.Type(date_type=date_type829) + _t1582 = _t1584 else: - if prediction823 == 5: - _t1588 = self.parse_int128_type() - int128_type829 = _t1588 - _t1589 = logic_pb2.Type(int128_type=int128_type829) - _t1587 = _t1589 + if prediction822 == 5: + _t1586 = self.parse_int128_type() + int128_type828 = _t1586 + _t1587 = logic_pb2.Type(int128_type=int128_type828) + _t1585 = _t1587 else: - if prediction823 == 4: - _t1591 = self.parse_uint128_type() - uint128_type828 = _t1591 - _t1592 = logic_pb2.Type(uint128_type=uint128_type828) - _t1590 = _t1592 + if prediction822 == 4: + _t1589 = self.parse_uint128_type() + uint128_type827 = _t1589 + _t1590 = logic_pb2.Type(uint128_type=uint128_type827) + _t1588 = _t1590 else: - if prediction823 == 3: - _t1594 = self.parse_float_type() - float_type827 = _t1594 - _t1595 = logic_pb2.Type(float_type=float_type827) - _t1593 = _t1595 + if prediction822 == 3: + _t1592 = self.parse_float_type() + float_type826 = _t1592 + _t1593 = logic_pb2.Type(float_type=float_type826) + _t1591 = _t1593 else: - if prediction823 == 2: - _t1597 = self.parse_int_type() - int_type826 = _t1597 - _t1598 = logic_pb2.Type(int_type=int_type826) - _t1596 = _t1598 + if prediction822 == 2: + _t1595 = self.parse_int_type() + int_type825 = _t1595 + _t1596 = logic_pb2.Type(int_type=int_type825) + _t1594 = _t1596 else: - if prediction823 == 1: - _t1600 = self.parse_string_type() - string_type825 = _t1600 - _t1601 = logic_pb2.Type(string_type=string_type825) - _t1599 = _t1601 + if prediction822 == 1: + _t1598 = self.parse_string_type() + string_type824 = _t1598 + _t1599 = logic_pb2.Type(string_type=string_type824) + _t1597 = _t1599 else: - if prediction823 == 0: - _t1603 = self.parse_unspecified_type() - unspecified_type824 = _t1603 - _t1604 = logic_pb2.Type(unspecified_type=unspecified_type824) - _t1602 = _t1604 + if prediction822 == 0: + _t1601 = self.parse_unspecified_type() + unspecified_type823 = _t1601 + _t1602 = logic_pb2.Type(unspecified_type=unspecified_type823) + _t1600 = _t1602 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1599 = _t1602 - _t1596 = _t1599 - _t1593 = _t1596 - _t1590 = _t1593 - _t1587 = _t1590 - _t1584 = _t1587 - _t1581 = _t1584 - _t1578 = _t1581 - _t1575 = _t1578 - _t1572 = _t1575 - _t1569 = _t1572 - _t1566 = _t1569 - _t1563 = _t1566 - result839 = _t1563 - self.record_span(span_start838, "Type") - return result839 + _t1597 = _t1600 + _t1594 = _t1597 + _t1591 = _t1594 + _t1588 = _t1591 + _t1585 = _t1588 + _t1582 = _t1585 + _t1579 = _t1582 + _t1576 = _t1579 + _t1573 = _t1576 + _t1570 = _t1573 + _t1567 = _t1570 + _t1564 = _t1567 + _t1561 = _t1564 + result838 = _t1561 + self.record_span(span_start837, "Type") + return result838 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: - span_start840 = self.span_start() + span_start839 = self.span_start() self.consume_literal("UNKNOWN") - _t1605 = logic_pb2.UnspecifiedType() - result841 = _t1605 - self.record_span(span_start840, "UnspecifiedType") - return result841 + _t1603 = logic_pb2.UnspecifiedType() + result840 = _t1603 + self.record_span(span_start839, "UnspecifiedType") + return result840 def parse_string_type(self) -> logic_pb2.StringType: - span_start842 = self.span_start() + span_start841 = self.span_start() self.consume_literal("STRING") - _t1606 = logic_pb2.StringType() - result843 = _t1606 - self.record_span(span_start842, "StringType") - return result843 + _t1604 = logic_pb2.StringType() + result842 = _t1604 + self.record_span(span_start841, "StringType") + return result842 def parse_int_type(self) -> logic_pb2.IntType: - span_start844 = self.span_start() + span_start843 = self.span_start() self.consume_literal("INT") - _t1607 = logic_pb2.IntType() - result845 = _t1607 - self.record_span(span_start844, "IntType") - return result845 + _t1605 = logic_pb2.IntType() + result844 = _t1605 + self.record_span(span_start843, "IntType") + return result844 def parse_float_type(self) -> logic_pb2.FloatType: - span_start846 = self.span_start() + span_start845 = self.span_start() self.consume_literal("FLOAT") - _t1608 = logic_pb2.FloatType() - result847 = _t1608 - self.record_span(span_start846, "FloatType") - return result847 + _t1606 = logic_pb2.FloatType() + result846 = _t1606 + self.record_span(span_start845, "FloatType") + return result846 def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start848 = self.span_start() + span_start847 = self.span_start() self.consume_literal("UINT128") - _t1609 = logic_pb2.UInt128Type() - result849 = _t1609 - self.record_span(span_start848, "UInt128Type") - return result849 + _t1607 = logic_pb2.UInt128Type() + result848 = _t1607 + self.record_span(span_start847, "UInt128Type") + return result848 def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start850 = self.span_start() + span_start849 = self.span_start() self.consume_literal("INT128") - _t1610 = logic_pb2.Int128Type() - result851 = _t1610 - self.record_span(span_start850, "Int128Type") - return result851 + _t1608 = logic_pb2.Int128Type() + result850 = _t1608 + self.record_span(span_start849, "Int128Type") + return result850 def parse_date_type(self) -> logic_pb2.DateType: - span_start852 = self.span_start() + span_start851 = self.span_start() self.consume_literal("DATE") - _t1611 = logic_pb2.DateType() - result853 = _t1611 - self.record_span(span_start852, "DateType") - return result853 + _t1609 = logic_pb2.DateType() + result852 = _t1609 + self.record_span(span_start851, "DateType") + return result852 def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start854 = self.span_start() + span_start853 = self.span_start() self.consume_literal("DATETIME") - _t1612 = logic_pb2.DateTimeType() - result855 = _t1612 - self.record_span(span_start854, "DateTimeType") - return result855 + _t1610 = logic_pb2.DateTimeType() + result854 = _t1610 + self.record_span(span_start853, "DateTimeType") + return result854 def parse_missing_type(self) -> logic_pb2.MissingType: - span_start856 = self.span_start() + span_start855 = self.span_start() self.consume_literal("MISSING") - _t1613 = logic_pb2.MissingType() - result857 = _t1613 - self.record_span(span_start856, "MissingType") - return result857 + _t1611 = logic_pb2.MissingType() + result856 = _t1611 + self.record_span(span_start855, "MissingType") + return result856 def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start860 = self.span_start() + span_start859 = self.span_start() self.consume_literal("(") self.consume_literal("DECIMAL") - int858 = self.consume_terminal("INT") - int_3859 = self.consume_terminal("INT") + int857 = self.consume_terminal("INT") + int_3858 = self.consume_terminal("INT") self.consume_literal(")") - _t1614 = logic_pb2.DecimalType(precision=int(int858), scale=int(int_3859)) - result861 = _t1614 - self.record_span(span_start860, "DecimalType") - return result861 + _t1612 = logic_pb2.DecimalType(precision=int(int857), scale=int(int_3858)) + result860 = _t1612 + self.record_span(span_start859, "DecimalType") + return result860 def parse_boolean_type(self) -> logic_pb2.BooleanType: - span_start862 = self.span_start() + span_start861 = self.span_start() self.consume_literal("BOOLEAN") - _t1615 = logic_pb2.BooleanType() - result863 = _t1615 - self.record_span(span_start862, "BooleanType") - return result863 + _t1613 = logic_pb2.BooleanType() + result862 = _t1613 + self.record_span(span_start861, "BooleanType") + return result862 def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start864 = self.span_start() + span_start863 = self.span_start() self.consume_literal("INT32") - _t1616 = logic_pb2.Int32Type() - result865 = _t1616 - self.record_span(span_start864, "Int32Type") - return result865 + _t1614 = logic_pb2.Int32Type() + result864 = _t1614 + self.record_span(span_start863, "Int32Type") + return result864 def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start866 = self.span_start() + span_start865 = self.span_start() self.consume_literal("FLOAT32") - _t1617 = logic_pb2.Float32Type() - result867 = _t1617 - self.record_span(span_start866, "Float32Type") - return result867 + _t1615 = logic_pb2.Float32Type() + result866 = _t1615 + self.record_span(span_start865, "Float32Type") + return result866 def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start868 = self.span_start() + span_start867 = self.span_start() self.consume_literal("UINT32") - _t1618 = logic_pb2.UInt32Type() - result869 = _t1618 - self.record_span(span_start868, "UInt32Type") - return result869 + _t1616 = logic_pb2.UInt32Type() + result868 = _t1616 + self.record_span(span_start867, "UInt32Type") + return result868 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs870 = [] - cond871 = self.match_lookahead_terminal("SYMBOL", 0) - while cond871: - _t1619 = self.parse_binding() - item872 = _t1619 - xs870.append(item872) - cond871 = self.match_lookahead_terminal("SYMBOL", 0) - bindings873 = xs870 - return bindings873 + xs869 = [] + cond870 = self.match_lookahead_terminal("SYMBOL", 0) + while cond870: + _t1617 = self.parse_binding() + item871 = _t1617 + xs869.append(item871) + cond870 = self.match_lookahead_terminal("SYMBOL", 0) + bindings872 = xs869 + return bindings872 def parse_formula(self) -> logic_pb2.Formula: - span_start888 = self.span_start() + span_start887 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t1621 = 0 + _t1619 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t1622 = 11 + _t1620 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t1623 = 3 + _t1621 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t1624 = 10 + _t1622 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t1625 = 9 + _t1623 = 9 else: if self.match_lookahead_literal("or", 1): - _t1626 = 5 + _t1624 = 5 else: if self.match_lookahead_literal("not", 1): - _t1627 = 6 + _t1625 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t1628 = 7 + _t1626 = 7 else: if self.match_lookahead_literal("false", 1): - _t1629 = 1 + _t1627 = 1 else: if self.match_lookahead_literal("exists", 1): - _t1630 = 2 + _t1628 = 2 else: if self.match_lookahead_literal("cast", 1): - _t1631 = 12 + _t1629 = 12 else: if self.match_lookahead_literal("atom", 1): - _t1632 = 8 + _t1630 = 8 else: if self.match_lookahead_literal("and", 1): - _t1633 = 4 + _t1631 = 4 else: if self.match_lookahead_literal(">=", 1): - _t1634 = 10 + _t1632 = 10 else: if self.match_lookahead_literal(">", 1): - _t1635 = 10 + _t1633 = 10 else: if self.match_lookahead_literal("=", 1): - _t1636 = 10 + _t1634 = 10 else: if self.match_lookahead_literal("<=", 1): - _t1637 = 10 + _t1635 = 10 else: if self.match_lookahead_literal("<", 1): - _t1638 = 10 + _t1636 = 10 else: if self.match_lookahead_literal("/", 1): - _t1639 = 10 + _t1637 = 10 else: if self.match_lookahead_literal("-", 1): - _t1640 = 10 + _t1638 = 10 else: if self.match_lookahead_literal("+", 1): - _t1641 = 10 + _t1639 = 10 else: if self.match_lookahead_literal("*", 1): - _t1642 = 10 + _t1640 = 10 else: - _t1642 = -1 - _t1641 = _t1642 - _t1640 = _t1641 - _t1639 = _t1640 - _t1638 = _t1639 - _t1637 = _t1638 - _t1636 = _t1637 - _t1635 = _t1636 - _t1634 = _t1635 - _t1633 = _t1634 - _t1632 = _t1633 - _t1631 = _t1632 - _t1630 = _t1631 - _t1629 = _t1630 - _t1628 = _t1629 - _t1627 = _t1628 - _t1626 = _t1627 - _t1625 = _t1626 - _t1624 = _t1625 - _t1623 = _t1624 - _t1622 = _t1623 - _t1621 = _t1622 - _t1620 = _t1621 + _t1640 = -1 + _t1639 = _t1640 + _t1638 = _t1639 + _t1637 = _t1638 + _t1636 = _t1637 + _t1635 = _t1636 + _t1634 = _t1635 + _t1633 = _t1634 + _t1632 = _t1633 + _t1631 = _t1632 + _t1630 = _t1631 + _t1629 = _t1630 + _t1628 = _t1629 + _t1627 = _t1628 + _t1626 = _t1627 + _t1625 = _t1626 + _t1624 = _t1625 + _t1623 = _t1624 + _t1622 = _t1623 + _t1621 = _t1622 + _t1620 = _t1621 + _t1619 = _t1620 + _t1618 = _t1619 else: - _t1620 = -1 - prediction874 = _t1620 - if prediction874 == 12: - _t1644 = self.parse_cast() - cast887 = _t1644 - _t1645 = logic_pb2.Formula(cast=cast887) - _t1643 = _t1645 + _t1618 = -1 + prediction873 = _t1618 + if prediction873 == 12: + _t1642 = self.parse_cast() + cast886 = _t1642 + _t1643 = logic_pb2.Formula(cast=cast886) + _t1641 = _t1643 else: - if prediction874 == 11: - _t1647 = self.parse_rel_atom() - rel_atom886 = _t1647 - _t1648 = logic_pb2.Formula(rel_atom=rel_atom886) - _t1646 = _t1648 + if prediction873 == 11: + _t1645 = self.parse_rel_atom() + rel_atom885 = _t1645 + _t1646 = logic_pb2.Formula(rel_atom=rel_atom885) + _t1644 = _t1646 else: - if prediction874 == 10: - _t1650 = self.parse_primitive() - primitive885 = _t1650 - _t1651 = logic_pb2.Formula(primitive=primitive885) - _t1649 = _t1651 + if prediction873 == 10: + _t1648 = self.parse_primitive() + primitive884 = _t1648 + _t1649 = logic_pb2.Formula(primitive=primitive884) + _t1647 = _t1649 else: - if prediction874 == 9: - _t1653 = self.parse_pragma() - pragma884 = _t1653 - _t1654 = logic_pb2.Formula(pragma=pragma884) - _t1652 = _t1654 + if prediction873 == 9: + _t1651 = self.parse_pragma() + pragma883 = _t1651 + _t1652 = logic_pb2.Formula(pragma=pragma883) + _t1650 = _t1652 else: - if prediction874 == 8: - _t1656 = self.parse_atom() - atom883 = _t1656 - _t1657 = logic_pb2.Formula(atom=atom883) - _t1655 = _t1657 + if prediction873 == 8: + _t1654 = self.parse_atom() + atom882 = _t1654 + _t1655 = logic_pb2.Formula(atom=atom882) + _t1653 = _t1655 else: - if prediction874 == 7: - _t1659 = self.parse_ffi() - ffi882 = _t1659 - _t1660 = logic_pb2.Formula(ffi=ffi882) - _t1658 = _t1660 + if prediction873 == 7: + _t1657 = self.parse_ffi() + ffi881 = _t1657 + _t1658 = logic_pb2.Formula(ffi=ffi881) + _t1656 = _t1658 else: - if prediction874 == 6: - _t1662 = self.parse_not() - not881 = _t1662 - _t1663 = logic_pb2.Formula() - getattr(_t1663, 'not').CopyFrom(not881) - _t1661 = _t1663 + if prediction873 == 6: + _t1660 = self.parse_not() + not880 = _t1660 + _t1661 = logic_pb2.Formula() + getattr(_t1661, 'not').CopyFrom(not880) + _t1659 = _t1661 else: - if prediction874 == 5: - _t1665 = self.parse_disjunction() - disjunction880 = _t1665 - _t1666 = logic_pb2.Formula(disjunction=disjunction880) - _t1664 = _t1666 + if prediction873 == 5: + _t1663 = self.parse_disjunction() + disjunction879 = _t1663 + _t1664 = logic_pb2.Formula(disjunction=disjunction879) + _t1662 = _t1664 else: - if prediction874 == 4: - _t1668 = self.parse_conjunction() - conjunction879 = _t1668 - _t1669 = logic_pb2.Formula(conjunction=conjunction879) - _t1667 = _t1669 + if prediction873 == 4: + _t1666 = self.parse_conjunction() + conjunction878 = _t1666 + _t1667 = logic_pb2.Formula(conjunction=conjunction878) + _t1665 = _t1667 else: - if prediction874 == 3: - _t1671 = self.parse_reduce() - reduce878 = _t1671 - _t1672 = logic_pb2.Formula(reduce=reduce878) - _t1670 = _t1672 + if prediction873 == 3: + _t1669 = self.parse_reduce() + reduce877 = _t1669 + _t1670 = logic_pb2.Formula(reduce=reduce877) + _t1668 = _t1670 else: - if prediction874 == 2: - _t1674 = self.parse_exists() - exists877 = _t1674 - _t1675 = logic_pb2.Formula(exists=exists877) - _t1673 = _t1675 + if prediction873 == 2: + _t1672 = self.parse_exists() + exists876 = _t1672 + _t1673 = logic_pb2.Formula(exists=exists876) + _t1671 = _t1673 else: - if prediction874 == 1: - _t1677 = self.parse_false() - false876 = _t1677 - _t1678 = logic_pb2.Formula(disjunction=false876) - _t1676 = _t1678 + if prediction873 == 1: + _t1675 = self.parse_false() + false875 = _t1675 + _t1676 = logic_pb2.Formula(disjunction=false875) + _t1674 = _t1676 else: - if prediction874 == 0: - _t1680 = self.parse_true() - true875 = _t1680 - _t1681 = logic_pb2.Formula(conjunction=true875) - _t1679 = _t1681 + if prediction873 == 0: + _t1678 = self.parse_true() + true874 = _t1678 + _t1679 = logic_pb2.Formula(conjunction=true874) + _t1677 = _t1679 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1676 = _t1679 - _t1673 = _t1676 - _t1670 = _t1673 - _t1667 = _t1670 - _t1664 = _t1667 - _t1661 = _t1664 - _t1658 = _t1661 - _t1655 = _t1658 - _t1652 = _t1655 - _t1649 = _t1652 - _t1646 = _t1649 - _t1643 = _t1646 - result889 = _t1643 - self.record_span(span_start888, "Formula") - return result889 + _t1674 = _t1677 + _t1671 = _t1674 + _t1668 = _t1671 + _t1665 = _t1668 + _t1662 = _t1665 + _t1659 = _t1662 + _t1656 = _t1659 + _t1653 = _t1656 + _t1650 = _t1653 + _t1647 = _t1650 + _t1644 = _t1647 + _t1641 = _t1644 + result888 = _t1641 + self.record_span(span_start887, "Formula") + return result888 def parse_true(self) -> logic_pb2.Conjunction: - span_start890 = self.span_start() + span_start889 = self.span_start() self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t1682 = logic_pb2.Conjunction(args=[]) - result891 = _t1682 - self.record_span(span_start890, "Conjunction") - return result891 + _t1680 = logic_pb2.Conjunction(args=[]) + result890 = _t1680 + self.record_span(span_start889, "Conjunction") + return result890 def parse_false(self) -> logic_pb2.Disjunction: - span_start892 = self.span_start() + span_start891 = self.span_start() self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t1683 = logic_pb2.Disjunction(args=[]) - result893 = _t1683 - self.record_span(span_start892, "Disjunction") - return result893 + _t1681 = logic_pb2.Disjunction(args=[]) + result892 = _t1681 + self.record_span(span_start891, "Disjunction") + return result892 def parse_exists(self) -> logic_pb2.Exists: - span_start896 = self.span_start() + span_start895 = self.span_start() self.consume_literal("(") self.consume_literal("exists") - _t1684 = self.parse_bindings() - bindings894 = _t1684 - _t1685 = self.parse_formula() - formula895 = _t1685 + _t1682 = self.parse_bindings() + bindings893 = _t1682 + _t1683 = self.parse_formula() + formula894 = _t1683 self.consume_literal(")") - _t1686 = logic_pb2.Abstraction(vars=(list(bindings894[0]) + list(bindings894[1] if bindings894[1] is not None else [])), value=formula895) - _t1687 = logic_pb2.Exists(body=_t1686) - result897 = _t1687 - self.record_span(span_start896, "Exists") - return result897 + _t1684 = logic_pb2.Abstraction(vars=(list(bindings893[0]) + list(bindings893[1] if bindings893[1] is not None else [])), value=formula894) + _t1685 = logic_pb2.Exists(body=_t1684) + result896 = _t1685 + self.record_span(span_start895, "Exists") + return result896 def parse_reduce(self) -> logic_pb2.Reduce: - span_start901 = self.span_start() + span_start900 = self.span_start() self.consume_literal("(") self.consume_literal("reduce") - _t1688 = self.parse_abstraction() - abstraction898 = _t1688 - _t1689 = self.parse_abstraction() - abstraction_3899 = _t1689 - _t1690 = self.parse_terms() - terms900 = _t1690 + _t1686 = self.parse_abstraction() + abstraction897 = _t1686 + _t1687 = self.parse_abstraction() + abstraction_3898 = _t1687 + _t1688 = self.parse_terms() + terms899 = _t1688 self.consume_literal(")") - _t1691 = logic_pb2.Reduce(op=abstraction898, body=abstraction_3899, terms=terms900) - result902 = _t1691 - self.record_span(span_start901, "Reduce") - return result902 + _t1689 = logic_pb2.Reduce(op=abstraction897, body=abstraction_3898, terms=terms899) + result901 = _t1689 + self.record_span(span_start900, "Reduce") + return result901 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs903 = [] - cond904 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond904: - _t1692 = self.parse_term() - item905 = _t1692 - xs903.append(item905) - cond904 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - terms906 = xs903 + xs902 = [] + cond903 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond903: + _t1690 = self.parse_term() + item904 = _t1690 + xs902.append(item904) + cond903 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + terms905 = xs902 self.consume_literal(")") - return terms906 + return terms905 def parse_term(self) -> logic_pb2.Term: - span_start910 = self.span_start() + span_start909 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1693 = 1 + _t1691 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1694 = 1 + _t1692 = 1 else: if self.match_lookahead_literal("false", 0): - _t1695 = 1 + _t1693 = 1 else: if self.match_lookahead_literal("(", 0): - _t1696 = 1 + _t1694 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1697 = 0 + _t1695 = 0 else: if self.match_lookahead_terminal("UINT32", 0): - _t1698 = 1 + _t1696 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1699 = 1 + _t1697 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1700 = 1 + _t1698 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1701 = 1 + _t1699 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1702 = 1 + _t1700 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1703 = 1 + _t1701 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1704 = 1 + _t1702 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1705 = 1 + _t1703 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1706 = 1 + _t1704 = 1 else: - _t1706 = -1 - _t1705 = _t1706 - _t1704 = _t1705 - _t1703 = _t1704 - _t1702 = _t1703 - _t1701 = _t1702 - _t1700 = _t1701 - _t1699 = _t1700 - _t1698 = _t1699 - _t1697 = _t1698 - _t1696 = _t1697 - _t1695 = _t1696 - _t1694 = _t1695 - _t1693 = _t1694 - prediction907 = _t1693 - if prediction907 == 1: - _t1708 = self.parse_value() - value909 = _t1708 - _t1709 = logic_pb2.Term(constant=value909) - _t1707 = _t1709 + _t1704 = -1 + _t1703 = _t1704 + _t1702 = _t1703 + _t1701 = _t1702 + _t1700 = _t1701 + _t1699 = _t1700 + _t1698 = _t1699 + _t1697 = _t1698 + _t1696 = _t1697 + _t1695 = _t1696 + _t1694 = _t1695 + _t1693 = _t1694 + _t1692 = _t1693 + _t1691 = _t1692 + prediction906 = _t1691 + if prediction906 == 1: + _t1706 = self.parse_value() + value908 = _t1706 + _t1707 = logic_pb2.Term(constant=value908) + _t1705 = _t1707 else: - if prediction907 == 0: - _t1711 = self.parse_var() - var908 = _t1711 - _t1712 = logic_pb2.Term(var=var908) - _t1710 = _t1712 + if prediction906 == 0: + _t1709 = self.parse_var() + var907 = _t1709 + _t1710 = logic_pb2.Term(var=var907) + _t1708 = _t1710 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1707 = _t1710 - result911 = _t1707 - self.record_span(span_start910, "Term") - return result911 + _t1705 = _t1708 + result910 = _t1705 + self.record_span(span_start909, "Term") + return result910 def parse_var(self) -> logic_pb2.Var: - span_start913 = self.span_start() - symbol912 = self.consume_terminal("SYMBOL") - _t1713 = logic_pb2.Var(name=symbol912) - result914 = _t1713 - self.record_span(span_start913, "Var") - return result914 + span_start912 = self.span_start() + symbol911 = self.consume_terminal("SYMBOL") + _t1711 = logic_pb2.Var(name=symbol911) + result913 = _t1711 + self.record_span(span_start912, "Var") + return result913 def parse_value(self) -> logic_pb2.Value: - span_start928 = self.span_start() + span_start927 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1714 = 12 + _t1712 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1715 = 11 + _t1713 = 11 else: if self.match_lookahead_literal("false", 0): - _t1716 = 12 + _t1714 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1718 = 1 + _t1716 = 1 else: if self.match_lookahead_literal("date", 1): - _t1719 = 0 + _t1717 = 0 else: - _t1719 = -1 - _t1718 = _t1719 - _t1717 = _t1718 + _t1717 = -1 + _t1716 = _t1717 + _t1715 = _t1716 else: if self.match_lookahead_terminal("UINT32", 0): - _t1720 = 7 + _t1718 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1721 = 8 + _t1719 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1722 = 2 + _t1720 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1723 = 3 + _t1721 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1724 = 9 + _t1722 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1725 = 4 + _t1723 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1726 = 5 + _t1724 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1727 = 6 + _t1725 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1728 = 10 + _t1726 = 10 else: - _t1728 = -1 - _t1727 = _t1728 - _t1726 = _t1727 - _t1725 = _t1726 - _t1724 = _t1725 - _t1723 = _t1724 - _t1722 = _t1723 - _t1721 = _t1722 - _t1720 = _t1721 - _t1717 = _t1720 - _t1716 = _t1717 - _t1715 = _t1716 - _t1714 = _t1715 - prediction915 = _t1714 - if prediction915 == 12: - _t1730 = self.parse_boolean_value() - boolean_value927 = _t1730 - _t1731 = logic_pb2.Value(boolean_value=boolean_value927) - _t1729 = _t1731 + _t1726 = -1 + _t1725 = _t1726 + _t1724 = _t1725 + _t1723 = _t1724 + _t1722 = _t1723 + _t1721 = _t1722 + _t1720 = _t1721 + _t1719 = _t1720 + _t1718 = _t1719 + _t1715 = _t1718 + _t1714 = _t1715 + _t1713 = _t1714 + _t1712 = _t1713 + prediction914 = _t1712 + if prediction914 == 12: + _t1728 = self.parse_boolean_value() + boolean_value926 = _t1728 + _t1729 = logic_pb2.Value(boolean_value=boolean_value926) + _t1727 = _t1729 else: - if prediction915 == 11: + if prediction914 == 11: self.consume_literal("missing") - _t1733 = logic_pb2.MissingValue() - _t1734 = logic_pb2.Value(missing_value=_t1733) - _t1732 = _t1734 + _t1731 = logic_pb2.MissingValue() + _t1732 = logic_pb2.Value(missing_value=_t1731) + _t1730 = _t1732 else: - if prediction915 == 10: - formatted_decimal926 = self.consume_terminal("DECIMAL") - _t1736 = logic_pb2.Value(decimal_value=formatted_decimal926) - _t1735 = _t1736 + if prediction914 == 10: + formatted_decimal925 = self.consume_terminal("DECIMAL") + _t1734 = logic_pb2.Value(decimal_value=formatted_decimal925) + _t1733 = _t1734 else: - if prediction915 == 9: - formatted_int128925 = self.consume_terminal("INT128") - _t1738 = logic_pb2.Value(int128_value=formatted_int128925) - _t1737 = _t1738 + if prediction914 == 9: + formatted_int128924 = self.consume_terminal("INT128") + _t1736 = logic_pb2.Value(int128_value=formatted_int128924) + _t1735 = _t1736 else: - if prediction915 == 8: - formatted_uint128924 = self.consume_terminal("UINT128") - _t1740 = logic_pb2.Value(uint128_value=formatted_uint128924) - _t1739 = _t1740 + if prediction914 == 8: + formatted_uint128923 = self.consume_terminal("UINT128") + _t1738 = logic_pb2.Value(uint128_value=formatted_uint128923) + _t1737 = _t1738 else: - if prediction915 == 7: - formatted_uint32923 = self.consume_terminal("UINT32") - _t1742 = logic_pb2.Value(uint32_value=formatted_uint32923) - _t1741 = _t1742 + if prediction914 == 7: + formatted_uint32922 = self.consume_terminal("UINT32") + _t1740 = logic_pb2.Value(uint32_value=formatted_uint32922) + _t1739 = _t1740 else: - if prediction915 == 6: - formatted_float922 = self.consume_terminal("FLOAT") - _t1744 = logic_pb2.Value(float_value=formatted_float922) - _t1743 = _t1744 + if prediction914 == 6: + formatted_float921 = self.consume_terminal("FLOAT") + _t1742 = logic_pb2.Value(float_value=formatted_float921) + _t1741 = _t1742 else: - if prediction915 == 5: - formatted_float32921 = self.consume_terminal("FLOAT32") - _t1746 = logic_pb2.Value(float32_value=formatted_float32921) - _t1745 = _t1746 + if prediction914 == 5: + formatted_float32920 = self.consume_terminal("FLOAT32") + _t1744 = logic_pb2.Value(float32_value=formatted_float32920) + _t1743 = _t1744 else: - if prediction915 == 4: - formatted_int920 = self.consume_terminal("INT") - _t1748 = logic_pb2.Value(int_value=formatted_int920) - _t1747 = _t1748 + if prediction914 == 4: + formatted_int919 = self.consume_terminal("INT") + _t1746 = logic_pb2.Value(int_value=formatted_int919) + _t1745 = _t1746 else: - if prediction915 == 3: - formatted_int32919 = self.consume_terminal("INT32") - _t1750 = logic_pb2.Value(int32_value=formatted_int32919) - _t1749 = _t1750 + if prediction914 == 3: + formatted_int32918 = self.consume_terminal("INT32") + _t1748 = logic_pb2.Value(int32_value=formatted_int32918) + _t1747 = _t1748 else: - if prediction915 == 2: - formatted_string918 = self.consume_terminal("STRING") - _t1752 = logic_pb2.Value(string_value=formatted_string918) - _t1751 = _t1752 + if prediction914 == 2: + formatted_string917 = self.consume_terminal("STRING") + _t1750 = logic_pb2.Value(string_value=formatted_string917) + _t1749 = _t1750 else: - if prediction915 == 1: - _t1754 = self.parse_datetime() - datetime917 = _t1754 - _t1755 = logic_pb2.Value(datetime_value=datetime917) - _t1753 = _t1755 + if prediction914 == 1: + _t1752 = self.parse_datetime() + datetime916 = _t1752 + _t1753 = logic_pb2.Value(datetime_value=datetime916) + _t1751 = _t1753 else: - if prediction915 == 0: - _t1757 = self.parse_date() - date916 = _t1757 - _t1758 = logic_pb2.Value(date_value=date916) - _t1756 = _t1758 + if prediction914 == 0: + _t1755 = self.parse_date() + date915 = _t1755 + _t1756 = logic_pb2.Value(date_value=date915) + _t1754 = _t1756 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1753 = _t1756 - _t1751 = _t1753 - _t1749 = _t1751 - _t1747 = _t1749 - _t1745 = _t1747 - _t1743 = _t1745 - _t1741 = _t1743 - _t1739 = _t1741 - _t1737 = _t1739 - _t1735 = _t1737 - _t1732 = _t1735 - _t1729 = _t1732 - result929 = _t1729 - self.record_span(span_start928, "Value") - return result929 + _t1751 = _t1754 + _t1749 = _t1751 + _t1747 = _t1749 + _t1745 = _t1747 + _t1743 = _t1745 + _t1741 = _t1743 + _t1739 = _t1741 + _t1737 = _t1739 + _t1735 = _t1737 + _t1733 = _t1735 + _t1730 = _t1733 + _t1727 = _t1730 + result928 = _t1727 + self.record_span(span_start927, "Value") + return result928 def parse_date(self) -> logic_pb2.DateValue: - span_start933 = self.span_start() + span_start932 = self.span_start() self.consume_literal("(") self.consume_literal("date") - formatted_int930 = self.consume_terminal("INT") - formatted_int_3931 = self.consume_terminal("INT") - formatted_int_4932 = self.consume_terminal("INT") + formatted_int929 = self.consume_terminal("INT") + formatted_int_3930 = self.consume_terminal("INT") + formatted_int_4931 = self.consume_terminal("INT") self.consume_literal(")") - _t1759 = logic_pb2.DateValue(year=int(formatted_int930), month=int(formatted_int_3931), day=int(formatted_int_4932)) - result934 = _t1759 - self.record_span(span_start933, "DateValue") - return result934 + _t1757 = logic_pb2.DateValue(year=int(formatted_int929), month=int(formatted_int_3930), day=int(formatted_int_4931)) + result933 = _t1757 + self.record_span(span_start932, "DateValue") + return result933 def parse_datetime(self) -> logic_pb2.DateTimeValue: - span_start942 = self.span_start() + span_start941 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - formatted_int935 = self.consume_terminal("INT") - formatted_int_3936 = self.consume_terminal("INT") - formatted_int_4937 = self.consume_terminal("INT") - formatted_int_5938 = self.consume_terminal("INT") - formatted_int_6939 = self.consume_terminal("INT") - formatted_int_7940 = self.consume_terminal("INT") + formatted_int934 = self.consume_terminal("INT") + formatted_int_3935 = self.consume_terminal("INT") + formatted_int_4936 = self.consume_terminal("INT") + formatted_int_5937 = self.consume_terminal("INT") + formatted_int_6938 = self.consume_terminal("INT") + formatted_int_7939 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1760 = self.consume_terminal("INT") + _t1758 = self.consume_terminal("INT") else: - _t1760 = None - formatted_int_8941 = _t1760 + _t1758 = None + formatted_int_8940 = _t1758 self.consume_literal(")") - _t1761 = logic_pb2.DateTimeValue(year=int(formatted_int935), month=int(formatted_int_3936), day=int(formatted_int_4937), hour=int(formatted_int_5938), minute=int(formatted_int_6939), second=int(formatted_int_7940), microsecond=int((formatted_int_8941 if formatted_int_8941 is not None else 0))) - result943 = _t1761 - self.record_span(span_start942, "DateTimeValue") - return result943 + _t1759 = logic_pb2.DateTimeValue(year=int(formatted_int934), month=int(formatted_int_3935), day=int(formatted_int_4936), hour=int(formatted_int_5937), minute=int(formatted_int_6938), second=int(formatted_int_7939), microsecond=int((formatted_int_8940 if formatted_int_8940 is not None else 0))) + result942 = _t1759 + self.record_span(span_start941, "DateTimeValue") + return result942 def parse_conjunction(self) -> logic_pb2.Conjunction: - span_start948 = self.span_start() + span_start947 = self.span_start() self.consume_literal("(") self.consume_literal("and") - xs944 = [] - cond945 = self.match_lookahead_literal("(", 0) - while cond945: - _t1762 = self.parse_formula() - item946 = _t1762 - xs944.append(item946) - cond945 = self.match_lookahead_literal("(", 0) - formulas947 = xs944 + xs943 = [] + cond944 = self.match_lookahead_literal("(", 0) + while cond944: + _t1760 = self.parse_formula() + item945 = _t1760 + xs943.append(item945) + cond944 = self.match_lookahead_literal("(", 0) + formulas946 = xs943 self.consume_literal(")") - _t1763 = logic_pb2.Conjunction(args=formulas947) - result949 = _t1763 - self.record_span(span_start948, "Conjunction") - return result949 + _t1761 = logic_pb2.Conjunction(args=formulas946) + result948 = _t1761 + self.record_span(span_start947, "Conjunction") + return result948 def parse_disjunction(self) -> logic_pb2.Disjunction: - span_start954 = self.span_start() + span_start953 = self.span_start() self.consume_literal("(") self.consume_literal("or") - xs950 = [] - cond951 = self.match_lookahead_literal("(", 0) - while cond951: - _t1764 = self.parse_formula() - item952 = _t1764 - xs950.append(item952) - cond951 = self.match_lookahead_literal("(", 0) - formulas953 = xs950 + xs949 = [] + cond950 = self.match_lookahead_literal("(", 0) + while cond950: + _t1762 = self.parse_formula() + item951 = _t1762 + xs949.append(item951) + cond950 = self.match_lookahead_literal("(", 0) + formulas952 = xs949 self.consume_literal(")") - _t1765 = logic_pb2.Disjunction(args=formulas953) - result955 = _t1765 - self.record_span(span_start954, "Disjunction") - return result955 + _t1763 = logic_pb2.Disjunction(args=formulas952) + result954 = _t1763 + self.record_span(span_start953, "Disjunction") + return result954 def parse_not(self) -> logic_pb2.Not: - span_start957 = self.span_start() + span_start956 = self.span_start() self.consume_literal("(") self.consume_literal("not") - _t1766 = self.parse_formula() - formula956 = _t1766 + _t1764 = self.parse_formula() + formula955 = _t1764 self.consume_literal(")") - _t1767 = logic_pb2.Not(arg=formula956) - result958 = _t1767 - self.record_span(span_start957, "Not") - return result958 + _t1765 = logic_pb2.Not(arg=formula955) + result957 = _t1765 + self.record_span(span_start956, "Not") + return result957 def parse_ffi(self) -> logic_pb2.FFI: - span_start962 = self.span_start() + span_start961 = self.span_start() self.consume_literal("(") self.consume_literal("ffi") - _t1768 = self.parse_name() - name959 = _t1768 - _t1769 = self.parse_ffi_args() - ffi_args960 = _t1769 - _t1770 = self.parse_terms() - terms961 = _t1770 + _t1766 = self.parse_name() + name958 = _t1766 + _t1767 = self.parse_ffi_args() + ffi_args959 = _t1767 + _t1768 = self.parse_terms() + terms960 = _t1768 self.consume_literal(")") - _t1771 = logic_pb2.FFI(name=name959, args=ffi_args960, terms=terms961) - result963 = _t1771 - self.record_span(span_start962, "FFI") - return result963 + _t1769 = logic_pb2.FFI(name=name958, args=ffi_args959, terms=terms960) + result962 = _t1769 + self.record_span(span_start961, "FFI") + return result962 def parse_name(self) -> str: self.consume_literal(":") - symbol964 = self.consume_terminal("SYMBOL") - return symbol964 + symbol963 = self.consume_terminal("SYMBOL") + return symbol963 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs965 = [] - cond966 = self.match_lookahead_literal("(", 0) - while cond966: - _t1772 = self.parse_abstraction() - item967 = _t1772 - xs965.append(item967) - cond966 = self.match_lookahead_literal("(", 0) - abstractions968 = xs965 + xs964 = [] + cond965 = self.match_lookahead_literal("(", 0) + while cond965: + _t1770 = self.parse_abstraction() + item966 = _t1770 + xs964.append(item966) + cond965 = self.match_lookahead_literal("(", 0) + abstractions967 = xs964 self.consume_literal(")") - return abstractions968 + return abstractions967 def parse_atom(self) -> logic_pb2.Atom: - span_start974 = self.span_start() + span_start973 = self.span_start() self.consume_literal("(") self.consume_literal("atom") - _t1773 = self.parse_relation_id() - relation_id969 = _t1773 - xs970 = [] - cond971 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond971: - _t1774 = self.parse_term() - item972 = _t1774 - xs970.append(item972) - cond971 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - terms973 = xs970 + _t1771 = self.parse_relation_id() + relation_id968 = _t1771 + xs969 = [] + cond970 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond970: + _t1772 = self.parse_term() + item971 = _t1772 + xs969.append(item971) + cond970 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + terms972 = xs969 self.consume_literal(")") - _t1775 = logic_pb2.Atom(name=relation_id969, terms=terms973) - result975 = _t1775 - self.record_span(span_start974, "Atom") - return result975 + _t1773 = logic_pb2.Atom(name=relation_id968, terms=terms972) + result974 = _t1773 + self.record_span(span_start973, "Atom") + return result974 def parse_pragma(self) -> logic_pb2.Pragma: - span_start981 = self.span_start() + span_start980 = self.span_start() self.consume_literal("(") self.consume_literal("pragma") - _t1776 = self.parse_name() - name976 = _t1776 - xs977 = [] - cond978 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond978: - _t1777 = self.parse_term() - item979 = _t1777 - xs977.append(item979) - cond978 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - terms980 = xs977 + _t1774 = self.parse_name() + name975 = _t1774 + xs976 = [] + cond977 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond977: + _t1775 = self.parse_term() + item978 = _t1775 + xs976.append(item978) + cond977 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + terms979 = xs976 self.consume_literal(")") - _t1778 = logic_pb2.Pragma(name=name976, terms=terms980) - result982 = _t1778 - self.record_span(span_start981, "Pragma") - return result982 + _t1776 = logic_pb2.Pragma(name=name975, terms=terms979) + result981 = _t1776 + self.record_span(span_start980, "Pragma") + return result981 def parse_primitive(self) -> logic_pb2.Primitive: - span_start998 = self.span_start() + span_start997 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1780 = 9 + _t1778 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1781 = 4 + _t1779 = 4 else: if self.match_lookahead_literal(">", 1): - _t1782 = 3 + _t1780 = 3 else: if self.match_lookahead_literal("=", 1): - _t1783 = 0 + _t1781 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1784 = 2 + _t1782 = 2 else: if self.match_lookahead_literal("<", 1): - _t1785 = 1 + _t1783 = 1 else: if self.match_lookahead_literal("/", 1): - _t1786 = 8 + _t1784 = 8 else: if self.match_lookahead_literal("-", 1): - _t1787 = 6 + _t1785 = 6 else: if self.match_lookahead_literal("+", 1): - _t1788 = 5 + _t1786 = 5 else: if self.match_lookahead_literal("*", 1): - _t1789 = 7 + _t1787 = 7 else: - _t1789 = -1 - _t1788 = _t1789 - _t1787 = _t1788 - _t1786 = _t1787 - _t1785 = _t1786 - _t1784 = _t1785 - _t1783 = _t1784 - _t1782 = _t1783 - _t1781 = _t1782 - _t1780 = _t1781 - _t1779 = _t1780 + _t1787 = -1 + _t1786 = _t1787 + _t1785 = _t1786 + _t1784 = _t1785 + _t1783 = _t1784 + _t1782 = _t1783 + _t1781 = _t1782 + _t1780 = _t1781 + _t1779 = _t1780 + _t1778 = _t1779 + _t1777 = _t1778 else: - _t1779 = -1 - prediction983 = _t1779 - if prediction983 == 9: + _t1777 = -1 + prediction982 = _t1777 + if prediction982 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1791 = self.parse_name() - name993 = _t1791 - xs994 = [] - cond995 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond995: - _t1792 = self.parse_rel_term() - item996 = _t1792 - xs994.append(item996) - cond995 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - rel_terms997 = xs994 + _t1789 = self.parse_name() + name992 = _t1789 + xs993 = [] + cond994 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond994: + _t1790 = self.parse_rel_term() + item995 = _t1790 + xs993.append(item995) + cond994 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + rel_terms996 = xs993 self.consume_literal(")") - _t1793 = logic_pb2.Primitive(name=name993, terms=rel_terms997) - _t1790 = _t1793 + _t1791 = logic_pb2.Primitive(name=name992, terms=rel_terms996) + _t1788 = _t1791 else: - if prediction983 == 8: - _t1795 = self.parse_divide() - divide992 = _t1795 - _t1794 = divide992 + if prediction982 == 8: + _t1793 = self.parse_divide() + divide991 = _t1793 + _t1792 = divide991 else: - if prediction983 == 7: - _t1797 = self.parse_multiply() - multiply991 = _t1797 - _t1796 = multiply991 + if prediction982 == 7: + _t1795 = self.parse_multiply() + multiply990 = _t1795 + _t1794 = multiply990 else: - if prediction983 == 6: - _t1799 = self.parse_minus() - minus990 = _t1799 - _t1798 = minus990 + if prediction982 == 6: + _t1797 = self.parse_minus() + minus989 = _t1797 + _t1796 = minus989 else: - if prediction983 == 5: - _t1801 = self.parse_add() - add989 = _t1801 - _t1800 = add989 + if prediction982 == 5: + _t1799 = self.parse_add() + add988 = _t1799 + _t1798 = add988 else: - if prediction983 == 4: - _t1803 = self.parse_gt_eq() - gt_eq988 = _t1803 - _t1802 = gt_eq988 + if prediction982 == 4: + _t1801 = self.parse_gt_eq() + gt_eq987 = _t1801 + _t1800 = gt_eq987 else: - if prediction983 == 3: - _t1805 = self.parse_gt() - gt987 = _t1805 - _t1804 = gt987 + if prediction982 == 3: + _t1803 = self.parse_gt() + gt986 = _t1803 + _t1802 = gt986 else: - if prediction983 == 2: - _t1807 = self.parse_lt_eq() - lt_eq986 = _t1807 - _t1806 = lt_eq986 + if prediction982 == 2: + _t1805 = self.parse_lt_eq() + lt_eq985 = _t1805 + _t1804 = lt_eq985 else: - if prediction983 == 1: - _t1809 = self.parse_lt() - lt985 = _t1809 - _t1808 = lt985 + if prediction982 == 1: + _t1807 = self.parse_lt() + lt984 = _t1807 + _t1806 = lt984 else: - if prediction983 == 0: - _t1811 = self.parse_eq() - eq984 = _t1811 - _t1810 = eq984 + if prediction982 == 0: + _t1809 = self.parse_eq() + eq983 = _t1809 + _t1808 = eq983 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1808 = _t1810 - _t1806 = _t1808 - _t1804 = _t1806 - _t1802 = _t1804 - _t1800 = _t1802 - _t1798 = _t1800 - _t1796 = _t1798 - _t1794 = _t1796 - _t1790 = _t1794 - result999 = _t1790 - self.record_span(span_start998, "Primitive") - return result999 + _t1806 = _t1808 + _t1804 = _t1806 + _t1802 = _t1804 + _t1800 = _t1802 + _t1798 = _t1800 + _t1796 = _t1798 + _t1794 = _t1796 + _t1792 = _t1794 + _t1788 = _t1792 + result998 = _t1788 + self.record_span(span_start997, "Primitive") + return result998 def parse_eq(self) -> logic_pb2.Primitive: - span_start1002 = self.span_start() + span_start1001 = self.span_start() self.consume_literal("(") self.consume_literal("=") - _t1812 = self.parse_term() - term1000 = _t1812 - _t1813 = self.parse_term() - term_31001 = _t1813 + _t1810 = self.parse_term() + term999 = _t1810 + _t1811 = self.parse_term() + term_31000 = _t1811 self.consume_literal(")") - _t1814 = logic_pb2.RelTerm(term=term1000) - _t1815 = logic_pb2.RelTerm(term=term_31001) - _t1816 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1814, _t1815]) - result1003 = _t1816 - self.record_span(span_start1002, "Primitive") - return result1003 + _t1812 = logic_pb2.RelTerm(term=term999) + _t1813 = logic_pb2.RelTerm(term=term_31000) + _t1814 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1812, _t1813]) + result1002 = _t1814 + self.record_span(span_start1001, "Primitive") + return result1002 def parse_lt(self) -> logic_pb2.Primitive: - span_start1006 = self.span_start() + span_start1005 = self.span_start() self.consume_literal("(") self.consume_literal("<") - _t1817 = self.parse_term() - term1004 = _t1817 - _t1818 = self.parse_term() - term_31005 = _t1818 + _t1815 = self.parse_term() + term1003 = _t1815 + _t1816 = self.parse_term() + term_31004 = _t1816 self.consume_literal(")") - _t1819 = logic_pb2.RelTerm(term=term1004) - _t1820 = logic_pb2.RelTerm(term=term_31005) - _t1821 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1819, _t1820]) - result1007 = _t1821 - self.record_span(span_start1006, "Primitive") - return result1007 + _t1817 = logic_pb2.RelTerm(term=term1003) + _t1818 = logic_pb2.RelTerm(term=term_31004) + _t1819 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1817, _t1818]) + result1006 = _t1819 + self.record_span(span_start1005, "Primitive") + return result1006 def parse_lt_eq(self) -> logic_pb2.Primitive: - span_start1010 = self.span_start() + span_start1009 = self.span_start() self.consume_literal("(") self.consume_literal("<=") - _t1822 = self.parse_term() - term1008 = _t1822 - _t1823 = self.parse_term() - term_31009 = _t1823 + _t1820 = self.parse_term() + term1007 = _t1820 + _t1821 = self.parse_term() + term_31008 = _t1821 self.consume_literal(")") - _t1824 = logic_pb2.RelTerm(term=term1008) - _t1825 = logic_pb2.RelTerm(term=term_31009) - _t1826 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1824, _t1825]) - result1011 = _t1826 - self.record_span(span_start1010, "Primitive") - return result1011 + _t1822 = logic_pb2.RelTerm(term=term1007) + _t1823 = logic_pb2.RelTerm(term=term_31008) + _t1824 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1822, _t1823]) + result1010 = _t1824 + self.record_span(span_start1009, "Primitive") + return result1010 def parse_gt(self) -> logic_pb2.Primitive: - span_start1014 = self.span_start() + span_start1013 = self.span_start() self.consume_literal("(") self.consume_literal(">") - _t1827 = self.parse_term() - term1012 = _t1827 - _t1828 = self.parse_term() - term_31013 = _t1828 + _t1825 = self.parse_term() + term1011 = _t1825 + _t1826 = self.parse_term() + term_31012 = _t1826 self.consume_literal(")") - _t1829 = logic_pb2.RelTerm(term=term1012) - _t1830 = logic_pb2.RelTerm(term=term_31013) - _t1831 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1829, _t1830]) - result1015 = _t1831 - self.record_span(span_start1014, "Primitive") - return result1015 + _t1827 = logic_pb2.RelTerm(term=term1011) + _t1828 = logic_pb2.RelTerm(term=term_31012) + _t1829 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1827, _t1828]) + result1014 = _t1829 + self.record_span(span_start1013, "Primitive") + return result1014 def parse_gt_eq(self) -> logic_pb2.Primitive: - span_start1018 = self.span_start() + span_start1017 = self.span_start() self.consume_literal("(") self.consume_literal(">=") - _t1832 = self.parse_term() - term1016 = _t1832 - _t1833 = self.parse_term() - term_31017 = _t1833 + _t1830 = self.parse_term() + term1015 = _t1830 + _t1831 = self.parse_term() + term_31016 = _t1831 self.consume_literal(")") - _t1834 = logic_pb2.RelTerm(term=term1016) - _t1835 = logic_pb2.RelTerm(term=term_31017) - _t1836 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1834, _t1835]) - result1019 = _t1836 - self.record_span(span_start1018, "Primitive") - return result1019 + _t1832 = logic_pb2.RelTerm(term=term1015) + _t1833 = logic_pb2.RelTerm(term=term_31016) + _t1834 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1832, _t1833]) + result1018 = _t1834 + self.record_span(span_start1017, "Primitive") + return result1018 def parse_add(self) -> logic_pb2.Primitive: - span_start1023 = self.span_start() + span_start1022 = self.span_start() self.consume_literal("(") self.consume_literal("+") + _t1835 = self.parse_term() + term1019 = _t1835 + _t1836 = self.parse_term() + term_31020 = _t1836 _t1837 = self.parse_term() - term1020 = _t1837 - _t1838 = self.parse_term() - term_31021 = _t1838 - _t1839 = self.parse_term() - term_41022 = _t1839 + term_41021 = _t1837 self.consume_literal(")") - _t1840 = logic_pb2.RelTerm(term=term1020) - _t1841 = logic_pb2.RelTerm(term=term_31021) - _t1842 = logic_pb2.RelTerm(term=term_41022) - _t1843 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1840, _t1841, _t1842]) - result1024 = _t1843 - self.record_span(span_start1023, "Primitive") - return result1024 + _t1838 = logic_pb2.RelTerm(term=term1019) + _t1839 = logic_pb2.RelTerm(term=term_31020) + _t1840 = logic_pb2.RelTerm(term=term_41021) + _t1841 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1838, _t1839, _t1840]) + result1023 = _t1841 + self.record_span(span_start1022, "Primitive") + return result1023 def parse_minus(self) -> logic_pb2.Primitive: - span_start1028 = self.span_start() + span_start1027 = self.span_start() self.consume_literal("(") self.consume_literal("-") + _t1842 = self.parse_term() + term1024 = _t1842 + _t1843 = self.parse_term() + term_31025 = _t1843 _t1844 = self.parse_term() - term1025 = _t1844 - _t1845 = self.parse_term() - term_31026 = _t1845 - _t1846 = self.parse_term() - term_41027 = _t1846 + term_41026 = _t1844 self.consume_literal(")") - _t1847 = logic_pb2.RelTerm(term=term1025) - _t1848 = logic_pb2.RelTerm(term=term_31026) - _t1849 = logic_pb2.RelTerm(term=term_41027) - _t1850 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1847, _t1848, _t1849]) - result1029 = _t1850 - self.record_span(span_start1028, "Primitive") - return result1029 + _t1845 = logic_pb2.RelTerm(term=term1024) + _t1846 = logic_pb2.RelTerm(term=term_31025) + _t1847 = logic_pb2.RelTerm(term=term_41026) + _t1848 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1845, _t1846, _t1847]) + result1028 = _t1848 + self.record_span(span_start1027, "Primitive") + return result1028 def parse_multiply(self) -> logic_pb2.Primitive: - span_start1033 = self.span_start() + span_start1032 = self.span_start() self.consume_literal("(") self.consume_literal("*") + _t1849 = self.parse_term() + term1029 = _t1849 + _t1850 = self.parse_term() + term_31030 = _t1850 _t1851 = self.parse_term() - term1030 = _t1851 - _t1852 = self.parse_term() - term_31031 = _t1852 - _t1853 = self.parse_term() - term_41032 = _t1853 + term_41031 = _t1851 self.consume_literal(")") - _t1854 = logic_pb2.RelTerm(term=term1030) - _t1855 = logic_pb2.RelTerm(term=term_31031) - _t1856 = logic_pb2.RelTerm(term=term_41032) - _t1857 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1854, _t1855, _t1856]) - result1034 = _t1857 - self.record_span(span_start1033, "Primitive") - return result1034 + _t1852 = logic_pb2.RelTerm(term=term1029) + _t1853 = logic_pb2.RelTerm(term=term_31030) + _t1854 = logic_pb2.RelTerm(term=term_41031) + _t1855 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1852, _t1853, _t1854]) + result1033 = _t1855 + self.record_span(span_start1032, "Primitive") + return result1033 def parse_divide(self) -> logic_pb2.Primitive: - span_start1038 = self.span_start() + span_start1037 = self.span_start() self.consume_literal("(") self.consume_literal("/") + _t1856 = self.parse_term() + term1034 = _t1856 + _t1857 = self.parse_term() + term_31035 = _t1857 _t1858 = self.parse_term() - term1035 = _t1858 - _t1859 = self.parse_term() - term_31036 = _t1859 - _t1860 = self.parse_term() - term_41037 = _t1860 + term_41036 = _t1858 self.consume_literal(")") - _t1861 = logic_pb2.RelTerm(term=term1035) - _t1862 = logic_pb2.RelTerm(term=term_31036) - _t1863 = logic_pb2.RelTerm(term=term_41037) - _t1864 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1861, _t1862, _t1863]) - result1039 = _t1864 - self.record_span(span_start1038, "Primitive") - return result1039 + _t1859 = logic_pb2.RelTerm(term=term1034) + _t1860 = logic_pb2.RelTerm(term=term_31035) + _t1861 = logic_pb2.RelTerm(term=term_41036) + _t1862 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1859, _t1860, _t1861]) + result1038 = _t1862 + self.record_span(span_start1037, "Primitive") + return result1038 def parse_rel_term(self) -> logic_pb2.RelTerm: - span_start1043 = self.span_start() + span_start1042 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1865 = 1 + _t1863 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1866 = 1 + _t1864 = 1 else: if self.match_lookahead_literal("false", 0): - _t1867 = 1 + _t1865 = 1 else: if self.match_lookahead_literal("(", 0): - _t1868 = 1 + _t1866 = 1 else: if self.match_lookahead_literal("#", 0): - _t1869 = 0 + _t1867 = 0 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1870 = 1 + _t1868 = 1 else: if self.match_lookahead_terminal("UINT32", 0): - _t1871 = 1 + _t1869 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1872 = 1 + _t1870 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1873 = 1 + _t1871 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1874 = 1 + _t1872 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1875 = 1 + _t1873 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1876 = 1 + _t1874 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1877 = 1 + _t1875 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1878 = 1 + _t1876 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1879 = 1 + _t1877 = 1 else: - _t1879 = -1 - _t1878 = _t1879 - _t1877 = _t1878 - _t1876 = _t1877 - _t1875 = _t1876 - _t1874 = _t1875 - _t1873 = _t1874 - _t1872 = _t1873 - _t1871 = _t1872 - _t1870 = _t1871 - _t1869 = _t1870 - _t1868 = _t1869 - _t1867 = _t1868 - _t1866 = _t1867 - _t1865 = _t1866 - prediction1040 = _t1865 - if prediction1040 == 1: - _t1881 = self.parse_term() - term1042 = _t1881 - _t1882 = logic_pb2.RelTerm(term=term1042) - _t1880 = _t1882 + _t1877 = -1 + _t1876 = _t1877 + _t1875 = _t1876 + _t1874 = _t1875 + _t1873 = _t1874 + _t1872 = _t1873 + _t1871 = _t1872 + _t1870 = _t1871 + _t1869 = _t1870 + _t1868 = _t1869 + _t1867 = _t1868 + _t1866 = _t1867 + _t1865 = _t1866 + _t1864 = _t1865 + _t1863 = _t1864 + prediction1039 = _t1863 + if prediction1039 == 1: + _t1879 = self.parse_term() + term1041 = _t1879 + _t1880 = logic_pb2.RelTerm(term=term1041) + _t1878 = _t1880 else: - if prediction1040 == 0: - _t1884 = self.parse_specialized_value() - specialized_value1041 = _t1884 - _t1885 = logic_pb2.RelTerm(specialized_value=specialized_value1041) - _t1883 = _t1885 + if prediction1039 == 0: + _t1882 = self.parse_specialized_value() + specialized_value1040 = _t1882 + _t1883 = logic_pb2.RelTerm(specialized_value=specialized_value1040) + _t1881 = _t1883 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1880 = _t1883 - result1044 = _t1880 - self.record_span(span_start1043, "RelTerm") - return result1044 + _t1878 = _t1881 + result1043 = _t1878 + self.record_span(span_start1042, "RelTerm") + return result1043 def parse_specialized_value(self) -> logic_pb2.Value: - span_start1046 = self.span_start() + span_start1045 = self.span_start() self.consume_literal("#") - _t1886 = self.parse_raw_value() - raw_value1045 = _t1886 - result1047 = raw_value1045 - self.record_span(span_start1046, "Value") - return result1047 + _t1884 = self.parse_raw_value() + raw_value1044 = _t1884 + result1046 = raw_value1044 + self.record_span(span_start1045, "Value") + return result1046 def parse_rel_atom(self) -> logic_pb2.RelAtom: - span_start1053 = self.span_start() + span_start1052 = self.span_start() self.consume_literal("(") self.consume_literal("relatom") - _t1887 = self.parse_name() - name1048 = _t1887 - xs1049 = [] - cond1050 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - while cond1050: - _t1888 = self.parse_rel_term() - item1051 = _t1888 - xs1049.append(item1051) - cond1050 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) - rel_terms1052 = xs1049 + _t1885 = self.parse_name() + name1047 = _t1885 + xs1048 = [] + cond1049 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + while cond1049: + _t1886 = self.parse_rel_term() + item1050 = _t1886 + xs1048.append(item1050) + cond1049 = ((((((((((((((self.match_lookahead_literal("#", 0) or self.match_lookahead_literal("(", 0)) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) or self.match_lookahead_terminal("SYMBOL", 0)) + rel_terms1051 = xs1048 self.consume_literal(")") - _t1889 = logic_pb2.RelAtom(name=name1048, terms=rel_terms1052) - result1054 = _t1889 - self.record_span(span_start1053, "RelAtom") - return result1054 + _t1887 = logic_pb2.RelAtom(name=name1047, terms=rel_terms1051) + result1053 = _t1887 + self.record_span(span_start1052, "RelAtom") + return result1053 def parse_cast(self) -> logic_pb2.Cast: - span_start1057 = self.span_start() + span_start1056 = self.span_start() self.consume_literal("(") self.consume_literal("cast") - _t1890 = self.parse_term() - term1055 = _t1890 - _t1891 = self.parse_term() - term_31056 = _t1891 + _t1888 = self.parse_term() + term1054 = _t1888 + _t1889 = self.parse_term() + term_31055 = _t1889 self.consume_literal(")") - _t1892 = logic_pb2.Cast(input=term1055, result=term_31056) - result1058 = _t1892 - self.record_span(span_start1057, "Cast") - return result1058 + _t1890 = logic_pb2.Cast(input=term1054, result=term_31055) + result1057 = _t1890 + self.record_span(span_start1056, "Cast") + return result1057 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs1059 = [] - cond1060 = self.match_lookahead_literal("(", 0) - while cond1060: - _t1893 = self.parse_attribute() - item1061 = _t1893 - xs1059.append(item1061) - cond1060 = self.match_lookahead_literal("(", 0) - attributes1062 = xs1059 + xs1058 = [] + cond1059 = self.match_lookahead_literal("(", 0) + while cond1059: + _t1891 = self.parse_attribute() + item1060 = _t1891 + xs1058.append(item1060) + cond1059 = self.match_lookahead_literal("(", 0) + attributes1061 = xs1058 self.consume_literal(")") - return attributes1062 + return attributes1061 def parse_attribute(self) -> logic_pb2.Attribute: - span_start1068 = self.span_start() + span_start1067 = self.span_start() self.consume_literal("(") self.consume_literal("attribute") - _t1894 = self.parse_name() - name1063 = _t1894 - xs1064 = [] - cond1065 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) - while cond1065: - _t1895 = self.parse_raw_value() - item1066 = _t1895 - xs1064.append(item1066) - cond1065 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) - raw_values1067 = xs1064 + _t1892 = self.parse_name() + name1062 = _t1892 + xs1063 = [] + cond1064 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) + while cond1064: + _t1893 = self.parse_raw_value() + item1065 = _t1893 + xs1063.append(item1065) + cond1064 = ((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("false", 0)) or self.match_lookahead_literal("missing", 0)) or self.match_lookahead_literal("true", 0)) or self.match_lookahead_terminal("DECIMAL", 0)) or self.match_lookahead_terminal("FLOAT", 0)) or self.match_lookahead_terminal("FLOAT32", 0)) or self.match_lookahead_terminal("INT", 0)) or self.match_lookahead_terminal("INT128", 0)) or self.match_lookahead_terminal("INT32", 0)) or self.match_lookahead_terminal("STRING", 0)) or self.match_lookahead_terminal("UINT128", 0)) or self.match_lookahead_terminal("UINT32", 0)) + raw_values1066 = xs1063 self.consume_literal(")") - _t1896 = logic_pb2.Attribute(name=name1063, args=raw_values1067) - result1069 = _t1896 - self.record_span(span_start1068, "Attribute") - return result1069 + _t1894 = logic_pb2.Attribute(name=name1062, args=raw_values1066) + result1068 = _t1894 + self.record_span(span_start1067, "Attribute") + return result1068 def parse_algorithm(self) -> logic_pb2.Algorithm: - span_start1076 = self.span_start() + span_start1075 = self.span_start() self.consume_literal("(") self.consume_literal("algorithm") - xs1070 = [] - cond1071 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1071: - _t1897 = self.parse_relation_id() - item1072 = _t1897 - xs1070.append(item1072) - cond1071 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1073 = xs1070 - _t1898 = self.parse_script() - script1074 = _t1898 + xs1069 = [] + cond1070 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1070: + _t1895 = self.parse_relation_id() + item1071 = _t1895 + xs1069.append(item1071) + cond1070 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1072 = xs1069 + _t1896 = self.parse_script() + script1073 = _t1896 if self.match_lookahead_literal("(", 0): - _t1900 = self.parse_attrs() - _t1899 = _t1900 + _t1898 = self.parse_attrs() + _t1897 = _t1898 else: - _t1899 = None - attrs1075 = _t1899 + _t1897 = None + attrs1074 = _t1897 self.consume_literal(")") - _t1901 = logic_pb2.Algorithm(body=script1074, attrs=(attrs1075 if attrs1075 is not None else [])) - getattr(_t1901, 'global').extend(relation_ids1073) - result1077 = _t1901 - self.record_span(span_start1076, "Algorithm") - return result1077 + _t1899 = logic_pb2.Algorithm(body=script1073, attrs=(attrs1074 if attrs1074 is not None else [])) + getattr(_t1899, 'global').extend(relation_ids1072) + result1076 = _t1899 + self.record_span(span_start1075, "Algorithm") + return result1076 def parse_script(self) -> logic_pb2.Script: - span_start1082 = self.span_start() + span_start1081 = self.span_start() self.consume_literal("(") self.consume_literal("script") - xs1078 = [] - cond1079 = self.match_lookahead_literal("(", 0) - while cond1079: - _t1902 = self.parse_construct() - item1080 = _t1902 - xs1078.append(item1080) - cond1079 = self.match_lookahead_literal("(", 0) - constructs1081 = xs1078 + xs1077 = [] + cond1078 = self.match_lookahead_literal("(", 0) + while cond1078: + _t1900 = self.parse_construct() + item1079 = _t1900 + xs1077.append(item1079) + cond1078 = self.match_lookahead_literal("(", 0) + constructs1080 = xs1077 self.consume_literal(")") - _t1903 = logic_pb2.Script(constructs=constructs1081) - result1083 = _t1903 - self.record_span(span_start1082, "Script") - return result1083 + _t1901 = logic_pb2.Script(constructs=constructs1080) + result1082 = _t1901 + self.record_span(span_start1081, "Script") + return result1082 def parse_construct(self) -> logic_pb2.Construct: - span_start1087 = self.span_start() + span_start1086 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1905 = 1 + _t1903 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1906 = 1 + _t1904 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1907 = 1 + _t1905 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1908 = 0 + _t1906 = 0 else: if self.match_lookahead_literal("break", 1): - _t1909 = 1 + _t1907 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1910 = 1 + _t1908 = 1 else: - _t1910 = -1 - _t1909 = _t1910 - _t1908 = _t1909 - _t1907 = _t1908 - _t1906 = _t1907 - _t1905 = _t1906 - _t1904 = _t1905 + _t1908 = -1 + _t1907 = _t1908 + _t1906 = _t1907 + _t1905 = _t1906 + _t1904 = _t1905 + _t1903 = _t1904 + _t1902 = _t1903 else: - _t1904 = -1 - prediction1084 = _t1904 - if prediction1084 == 1: - _t1912 = self.parse_instruction() - instruction1086 = _t1912 - _t1913 = logic_pb2.Construct(instruction=instruction1086) - _t1911 = _t1913 + _t1902 = -1 + prediction1083 = _t1902 + if prediction1083 == 1: + _t1910 = self.parse_instruction() + instruction1085 = _t1910 + _t1911 = logic_pb2.Construct(instruction=instruction1085) + _t1909 = _t1911 else: - if prediction1084 == 0: - _t1915 = self.parse_loop() - loop1085 = _t1915 - _t1916 = logic_pb2.Construct(loop=loop1085) - _t1914 = _t1916 + if prediction1083 == 0: + _t1913 = self.parse_loop() + loop1084 = _t1913 + _t1914 = logic_pb2.Construct(loop=loop1084) + _t1912 = _t1914 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1911 = _t1914 - result1088 = _t1911 - self.record_span(span_start1087, "Construct") - return result1088 + _t1909 = _t1912 + result1087 = _t1909 + self.record_span(span_start1086, "Construct") + return result1087 def parse_loop(self) -> logic_pb2.Loop: - span_start1092 = self.span_start() + span_start1091 = self.span_start() self.consume_literal("(") self.consume_literal("loop") - _t1917 = self.parse_init() - init1089 = _t1917 - _t1918 = self.parse_script() - script1090 = _t1918 + _t1915 = self.parse_init() + init1088 = _t1915 + _t1916 = self.parse_script() + script1089 = _t1916 if self.match_lookahead_literal("(", 0): - _t1920 = self.parse_attrs() - _t1919 = _t1920 + _t1918 = self.parse_attrs() + _t1917 = _t1918 else: - _t1919 = None - attrs1091 = _t1919 + _t1917 = None + attrs1090 = _t1917 self.consume_literal(")") - _t1921 = logic_pb2.Loop(init=init1089, body=script1090, attrs=(attrs1091 if attrs1091 is not None else [])) - result1093 = _t1921 - self.record_span(span_start1092, "Loop") - return result1093 + _t1919 = logic_pb2.Loop(init=init1088, body=script1089, attrs=(attrs1090 if attrs1090 is not None else [])) + result1092 = _t1919 + self.record_span(span_start1091, "Loop") + return result1092 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs1094 = [] - cond1095 = self.match_lookahead_literal("(", 0) - while cond1095: - _t1922 = self.parse_instruction() - item1096 = _t1922 - xs1094.append(item1096) - cond1095 = self.match_lookahead_literal("(", 0) - instructions1097 = xs1094 + xs1093 = [] + cond1094 = self.match_lookahead_literal("(", 0) + while cond1094: + _t1920 = self.parse_instruction() + item1095 = _t1920 + xs1093.append(item1095) + cond1094 = self.match_lookahead_literal("(", 0) + instructions1096 = xs1093 self.consume_literal(")") - return instructions1097 + return instructions1096 def parse_instruction(self) -> logic_pb2.Instruction: - span_start1104 = self.span_start() + span_start1103 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1924 = 1 + _t1922 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1925 = 4 + _t1923 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1926 = 3 + _t1924 = 3 else: if self.match_lookahead_literal("break", 1): - _t1927 = 2 + _t1925 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1928 = 0 + _t1926 = 0 else: - _t1928 = -1 - _t1927 = _t1928 - _t1926 = _t1927 - _t1925 = _t1926 - _t1924 = _t1925 - _t1923 = _t1924 + _t1926 = -1 + _t1925 = _t1926 + _t1924 = _t1925 + _t1923 = _t1924 + _t1922 = _t1923 + _t1921 = _t1922 else: - _t1923 = -1 - prediction1098 = _t1923 - if prediction1098 == 4: - _t1930 = self.parse_monus_def() - monus_def1103 = _t1930 - _t1931 = logic_pb2.Instruction(monus_def=monus_def1103) - _t1929 = _t1931 + _t1921 = -1 + prediction1097 = _t1921 + if prediction1097 == 4: + _t1928 = self.parse_monus_def() + monus_def1102 = _t1928 + _t1929 = logic_pb2.Instruction(monus_def=monus_def1102) + _t1927 = _t1929 else: - if prediction1098 == 3: - _t1933 = self.parse_monoid_def() - monoid_def1102 = _t1933 - _t1934 = logic_pb2.Instruction(monoid_def=monoid_def1102) - _t1932 = _t1934 + if prediction1097 == 3: + _t1931 = self.parse_monoid_def() + monoid_def1101 = _t1931 + _t1932 = logic_pb2.Instruction(monoid_def=monoid_def1101) + _t1930 = _t1932 else: - if prediction1098 == 2: - _t1936 = self.parse_break() - break1101 = _t1936 - _t1937 = logic_pb2.Instruction() - getattr(_t1937, 'break').CopyFrom(break1101) - _t1935 = _t1937 + if prediction1097 == 2: + _t1934 = self.parse_break() + break1100 = _t1934 + _t1935 = logic_pb2.Instruction() + getattr(_t1935, 'break').CopyFrom(break1100) + _t1933 = _t1935 else: - if prediction1098 == 1: - _t1939 = self.parse_upsert() - upsert1100 = _t1939 - _t1940 = logic_pb2.Instruction(upsert=upsert1100) - _t1938 = _t1940 + if prediction1097 == 1: + _t1937 = self.parse_upsert() + upsert1099 = _t1937 + _t1938 = logic_pb2.Instruction(upsert=upsert1099) + _t1936 = _t1938 else: - if prediction1098 == 0: - _t1942 = self.parse_assign() - assign1099 = _t1942 - _t1943 = logic_pb2.Instruction(assign=assign1099) - _t1941 = _t1943 + if prediction1097 == 0: + _t1940 = self.parse_assign() + assign1098 = _t1940 + _t1941 = logic_pb2.Instruction(assign=assign1098) + _t1939 = _t1941 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1938 = _t1941 - _t1935 = _t1938 - _t1932 = _t1935 - _t1929 = _t1932 - result1105 = _t1929 - self.record_span(span_start1104, "Instruction") - return result1105 + _t1936 = _t1939 + _t1933 = _t1936 + _t1930 = _t1933 + _t1927 = _t1930 + result1104 = _t1927 + self.record_span(span_start1103, "Instruction") + return result1104 def parse_assign(self) -> logic_pb2.Assign: - span_start1109 = self.span_start() + span_start1108 = self.span_start() self.consume_literal("(") self.consume_literal("assign") - _t1944 = self.parse_relation_id() - relation_id1106 = _t1944 - _t1945 = self.parse_abstraction() - abstraction1107 = _t1945 + _t1942 = self.parse_relation_id() + relation_id1105 = _t1942 + _t1943 = self.parse_abstraction() + abstraction1106 = _t1943 if self.match_lookahead_literal("(", 0): - _t1947 = self.parse_attrs() - _t1946 = _t1947 + _t1945 = self.parse_attrs() + _t1944 = _t1945 else: - _t1946 = None - attrs1108 = _t1946 + _t1944 = None + attrs1107 = _t1944 self.consume_literal(")") - _t1948 = logic_pb2.Assign(name=relation_id1106, body=abstraction1107, attrs=(attrs1108 if attrs1108 is not None else [])) - result1110 = _t1948 - self.record_span(span_start1109, "Assign") - return result1110 + _t1946 = logic_pb2.Assign(name=relation_id1105, body=abstraction1106, attrs=(attrs1107 if attrs1107 is not None else [])) + result1109 = _t1946 + self.record_span(span_start1108, "Assign") + return result1109 def parse_upsert(self) -> logic_pb2.Upsert: - span_start1114 = self.span_start() + span_start1113 = self.span_start() self.consume_literal("(") self.consume_literal("upsert") - _t1949 = self.parse_relation_id() - relation_id1111 = _t1949 - _t1950 = self.parse_abstraction_with_arity() - abstraction_with_arity1112 = _t1950 + _t1947 = self.parse_relation_id() + relation_id1110 = _t1947 + _t1948 = self.parse_abstraction_with_arity() + abstraction_with_arity1111 = _t1948 if self.match_lookahead_literal("(", 0): - _t1952 = self.parse_attrs() - _t1951 = _t1952 + _t1950 = self.parse_attrs() + _t1949 = _t1950 else: - _t1951 = None - attrs1113 = _t1951 + _t1949 = None + attrs1112 = _t1949 self.consume_literal(")") - _t1953 = logic_pb2.Upsert(name=relation_id1111, body=abstraction_with_arity1112[0], attrs=(attrs1113 if attrs1113 is not None else []), value_arity=abstraction_with_arity1112[1]) - result1115 = _t1953 - self.record_span(span_start1114, "Upsert") - return result1115 + _t1951 = logic_pb2.Upsert(name=relation_id1110, body=abstraction_with_arity1111[0], attrs=(attrs1112 if attrs1112 is not None else []), value_arity=abstraction_with_arity1111[1]) + result1114 = _t1951 + self.record_span(span_start1113, "Upsert") + return result1114 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1954 = self.parse_bindings() - bindings1116 = _t1954 - _t1955 = self.parse_formula() - formula1117 = _t1955 + _t1952 = self.parse_bindings() + bindings1115 = _t1952 + _t1953 = self.parse_formula() + formula1116 = _t1953 self.consume_literal(")") - _t1956 = logic_pb2.Abstraction(vars=(list(bindings1116[0]) + list(bindings1116[1] if bindings1116[1] is not None else [])), value=formula1117) - return (_t1956, len(bindings1116[1]),) + _t1954 = logic_pb2.Abstraction(vars=(list(bindings1115[0]) + list(bindings1115[1] if bindings1115[1] is not None else [])), value=formula1116) + return (_t1954, len(bindings1115[1]),) def parse_break(self) -> logic_pb2.Break: - span_start1121 = self.span_start() + span_start1120 = self.span_start() self.consume_literal("(") self.consume_literal("break") - _t1957 = self.parse_relation_id() - relation_id1118 = _t1957 - _t1958 = self.parse_abstraction() - abstraction1119 = _t1958 + _t1955 = self.parse_relation_id() + relation_id1117 = _t1955 + _t1956 = self.parse_abstraction() + abstraction1118 = _t1956 if self.match_lookahead_literal("(", 0): - _t1960 = self.parse_attrs() - _t1959 = _t1960 + _t1958 = self.parse_attrs() + _t1957 = _t1958 else: - _t1959 = None - attrs1120 = _t1959 + _t1957 = None + attrs1119 = _t1957 self.consume_literal(")") - _t1961 = logic_pb2.Break(name=relation_id1118, body=abstraction1119, attrs=(attrs1120 if attrs1120 is not None else [])) - result1122 = _t1961 - self.record_span(span_start1121, "Break") - return result1122 + _t1959 = logic_pb2.Break(name=relation_id1117, body=abstraction1118, attrs=(attrs1119 if attrs1119 is not None else [])) + result1121 = _t1959 + self.record_span(span_start1120, "Break") + return result1121 def parse_monoid_def(self) -> logic_pb2.MonoidDef: - span_start1127 = self.span_start() + span_start1126 = self.span_start() self.consume_literal("(") self.consume_literal("monoid") - _t1962 = self.parse_monoid() - monoid1123 = _t1962 - _t1963 = self.parse_relation_id() - relation_id1124 = _t1963 - _t1964 = self.parse_abstraction_with_arity() - abstraction_with_arity1125 = _t1964 + _t1960 = self.parse_monoid() + monoid1122 = _t1960 + _t1961 = self.parse_relation_id() + relation_id1123 = _t1961 + _t1962 = self.parse_abstraction_with_arity() + abstraction_with_arity1124 = _t1962 if self.match_lookahead_literal("(", 0): - _t1966 = self.parse_attrs() - _t1965 = _t1966 + _t1964 = self.parse_attrs() + _t1963 = _t1964 else: - _t1965 = None - attrs1126 = _t1965 + _t1963 = None + attrs1125 = _t1963 self.consume_literal(")") - _t1967 = logic_pb2.MonoidDef(monoid=monoid1123, name=relation_id1124, body=abstraction_with_arity1125[0], attrs=(attrs1126 if attrs1126 is not None else []), value_arity=abstraction_with_arity1125[1]) - result1128 = _t1967 - self.record_span(span_start1127, "MonoidDef") - return result1128 + _t1965 = logic_pb2.MonoidDef(monoid=monoid1122, name=relation_id1123, body=abstraction_with_arity1124[0], attrs=(attrs1125 if attrs1125 is not None else []), value_arity=abstraction_with_arity1124[1]) + result1127 = _t1965 + self.record_span(span_start1126, "MonoidDef") + return result1127 def parse_monoid(self) -> logic_pb2.Monoid: - span_start1134 = self.span_start() + span_start1133 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1969 = 3 + _t1967 = 3 else: if self.match_lookahead_literal("or", 1): - _t1970 = 0 + _t1968 = 0 else: if self.match_lookahead_literal("min", 1): - _t1971 = 1 + _t1969 = 1 else: if self.match_lookahead_literal("max", 1): - _t1972 = 2 + _t1970 = 2 else: - _t1972 = -1 - _t1971 = _t1972 - _t1970 = _t1971 - _t1969 = _t1970 - _t1968 = _t1969 + _t1970 = -1 + _t1969 = _t1970 + _t1968 = _t1969 + _t1967 = _t1968 + _t1966 = _t1967 else: - _t1968 = -1 - prediction1129 = _t1968 - if prediction1129 == 3: - _t1974 = self.parse_sum_monoid() - sum_monoid1133 = _t1974 - _t1975 = logic_pb2.Monoid(sum_monoid=sum_monoid1133) - _t1973 = _t1975 + _t1966 = -1 + prediction1128 = _t1966 + if prediction1128 == 3: + _t1972 = self.parse_sum_monoid() + sum_monoid1132 = _t1972 + _t1973 = logic_pb2.Monoid(sum_monoid=sum_monoid1132) + _t1971 = _t1973 else: - if prediction1129 == 2: - _t1977 = self.parse_max_monoid() - max_monoid1132 = _t1977 - _t1978 = logic_pb2.Monoid(max_monoid=max_monoid1132) - _t1976 = _t1978 + if prediction1128 == 2: + _t1975 = self.parse_max_monoid() + max_monoid1131 = _t1975 + _t1976 = logic_pb2.Monoid(max_monoid=max_monoid1131) + _t1974 = _t1976 else: - if prediction1129 == 1: - _t1980 = self.parse_min_monoid() - min_monoid1131 = _t1980 - _t1981 = logic_pb2.Monoid(min_monoid=min_monoid1131) - _t1979 = _t1981 + if prediction1128 == 1: + _t1978 = self.parse_min_monoid() + min_monoid1130 = _t1978 + _t1979 = logic_pb2.Monoid(min_monoid=min_monoid1130) + _t1977 = _t1979 else: - if prediction1129 == 0: - _t1983 = self.parse_or_monoid() - or_monoid1130 = _t1983 - _t1984 = logic_pb2.Monoid(or_monoid=or_monoid1130) - _t1982 = _t1984 + if prediction1128 == 0: + _t1981 = self.parse_or_monoid() + or_monoid1129 = _t1981 + _t1982 = logic_pb2.Monoid(or_monoid=or_monoid1129) + _t1980 = _t1982 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1979 = _t1982 - _t1976 = _t1979 - _t1973 = _t1976 - result1135 = _t1973 - self.record_span(span_start1134, "Monoid") - return result1135 + _t1977 = _t1980 + _t1974 = _t1977 + _t1971 = _t1974 + result1134 = _t1971 + self.record_span(span_start1133, "Monoid") + return result1134 def parse_or_monoid(self) -> logic_pb2.OrMonoid: - span_start1136 = self.span_start() + span_start1135 = self.span_start() self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1985 = logic_pb2.OrMonoid() - result1137 = _t1985 - self.record_span(span_start1136, "OrMonoid") - return result1137 + _t1983 = logic_pb2.OrMonoid() + result1136 = _t1983 + self.record_span(span_start1135, "OrMonoid") + return result1136 def parse_min_monoid(self) -> logic_pb2.MinMonoid: - span_start1139 = self.span_start() + span_start1138 = self.span_start() self.consume_literal("(") self.consume_literal("min") - _t1986 = self.parse_type() - type1138 = _t1986 + _t1984 = self.parse_type() + type1137 = _t1984 self.consume_literal(")") - _t1987 = logic_pb2.MinMonoid(type=type1138) - result1140 = _t1987 - self.record_span(span_start1139, "MinMonoid") - return result1140 + _t1985 = logic_pb2.MinMonoid(type=type1137) + result1139 = _t1985 + self.record_span(span_start1138, "MinMonoid") + return result1139 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: - span_start1142 = self.span_start() + span_start1141 = self.span_start() self.consume_literal("(") self.consume_literal("max") - _t1988 = self.parse_type() - type1141 = _t1988 + _t1986 = self.parse_type() + type1140 = _t1986 self.consume_literal(")") - _t1989 = logic_pb2.MaxMonoid(type=type1141) - result1143 = _t1989 - self.record_span(span_start1142, "MaxMonoid") - return result1143 + _t1987 = logic_pb2.MaxMonoid(type=type1140) + result1142 = _t1987 + self.record_span(span_start1141, "MaxMonoid") + return result1142 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: - span_start1145 = self.span_start() + span_start1144 = self.span_start() self.consume_literal("(") self.consume_literal("sum") - _t1990 = self.parse_type() - type1144 = _t1990 + _t1988 = self.parse_type() + type1143 = _t1988 self.consume_literal(")") - _t1991 = logic_pb2.SumMonoid(type=type1144) - result1146 = _t1991 - self.record_span(span_start1145, "SumMonoid") - return result1146 + _t1989 = logic_pb2.SumMonoid(type=type1143) + result1145 = _t1989 + self.record_span(span_start1144, "SumMonoid") + return result1145 def parse_monus_def(self) -> logic_pb2.MonusDef: - span_start1151 = self.span_start() + span_start1150 = self.span_start() self.consume_literal("(") self.consume_literal("monus") - _t1992 = self.parse_monoid() - monoid1147 = _t1992 - _t1993 = self.parse_relation_id() - relation_id1148 = _t1993 - _t1994 = self.parse_abstraction_with_arity() - abstraction_with_arity1149 = _t1994 + _t1990 = self.parse_monoid() + monoid1146 = _t1990 + _t1991 = self.parse_relation_id() + relation_id1147 = _t1991 + _t1992 = self.parse_abstraction_with_arity() + abstraction_with_arity1148 = _t1992 if self.match_lookahead_literal("(", 0): - _t1996 = self.parse_attrs() - _t1995 = _t1996 + _t1994 = self.parse_attrs() + _t1993 = _t1994 else: - _t1995 = None - attrs1150 = _t1995 + _t1993 = None + attrs1149 = _t1993 self.consume_literal(")") - _t1997 = logic_pb2.MonusDef(monoid=monoid1147, name=relation_id1148, body=abstraction_with_arity1149[0], attrs=(attrs1150 if attrs1150 is not None else []), value_arity=abstraction_with_arity1149[1]) - result1152 = _t1997 - self.record_span(span_start1151, "MonusDef") - return result1152 + _t1995 = logic_pb2.MonusDef(monoid=monoid1146, name=relation_id1147, body=abstraction_with_arity1148[0], attrs=(attrs1149 if attrs1149 is not None else []), value_arity=abstraction_with_arity1148[1]) + result1151 = _t1995 + self.record_span(span_start1150, "MonusDef") + return result1151 def parse_constraint(self) -> logic_pb2.Constraint: - span_start1157 = self.span_start() + span_start1156 = self.span_start() self.consume_literal("(") self.consume_literal("functional_dependency") - _t1998 = self.parse_relation_id() - relation_id1153 = _t1998 - _t1999 = self.parse_abstraction() - abstraction1154 = _t1999 - _t2000 = self.parse_functional_dependency_keys() - functional_dependency_keys1155 = _t2000 - _t2001 = self.parse_functional_dependency_values() - functional_dependency_values1156 = _t2001 + _t1996 = self.parse_relation_id() + relation_id1152 = _t1996 + _t1997 = self.parse_abstraction() + abstraction1153 = _t1997 + _t1998 = self.parse_functional_dependency_keys() + functional_dependency_keys1154 = _t1998 + _t1999 = self.parse_functional_dependency_values() + functional_dependency_values1155 = _t1999 self.consume_literal(")") - _t2002 = logic_pb2.FunctionalDependency(guard=abstraction1154, keys=functional_dependency_keys1155, values=functional_dependency_values1156) - _t2003 = logic_pb2.Constraint(name=relation_id1153, functional_dependency=_t2002) - result1158 = _t2003 - self.record_span(span_start1157, "Constraint") - return result1158 + _t2000 = logic_pb2.FunctionalDependency(guard=abstraction1153, keys=functional_dependency_keys1154, values=functional_dependency_values1155) + _t2001 = logic_pb2.Constraint(name=relation_id1152, functional_dependency=_t2000) + result1157 = _t2001 + self.record_span(span_start1156, "Constraint") + return result1157 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs1159 = [] - cond1160 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1160: - _t2004 = self.parse_var() - item1161 = _t2004 - xs1159.append(item1161) - cond1160 = self.match_lookahead_terminal("SYMBOL", 0) - vars1162 = xs1159 + xs1158 = [] + cond1159 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1159: + _t2002 = self.parse_var() + item1160 = _t2002 + xs1158.append(item1160) + cond1159 = self.match_lookahead_terminal("SYMBOL", 0) + vars1161 = xs1158 self.consume_literal(")") - return vars1162 + return vars1161 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - xs1163 = [] - cond1164 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1164: - _t2005 = self.parse_var() - item1165 = _t2005 - xs1163.append(item1165) - cond1164 = self.match_lookahead_terminal("SYMBOL", 0) - vars1166 = xs1163 + xs1162 = [] + cond1163 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1163: + _t2003 = self.parse_var() + item1164 = _t2003 + xs1162.append(item1164) + cond1163 = self.match_lookahead_terminal("SYMBOL", 0) + vars1165 = xs1162 self.consume_literal(")") - return vars1166 + return vars1165 def parse_data(self) -> logic_pb2.Data: - span_start1172 = self.span_start() + span_start1171 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t2007 = 3 + _t2005 = 3 else: if self.match_lookahead_literal("edb", 1): - _t2008 = 0 + _t2006 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t2009 = 2 + _t2007 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t2010 = 1 + _t2008 = 1 else: - _t2010 = -1 - _t2009 = _t2010 - _t2008 = _t2009 - _t2007 = _t2008 - _t2006 = _t2007 + _t2008 = -1 + _t2007 = _t2008 + _t2006 = _t2007 + _t2005 = _t2006 + _t2004 = _t2005 else: - _t2006 = -1 - prediction1167 = _t2006 - if prediction1167 == 3: - _t2012 = self.parse_iceberg_data() - iceberg_data1171 = _t2012 - _t2013 = logic_pb2.Data(iceberg_data=iceberg_data1171) - _t2011 = _t2013 + _t2004 = -1 + prediction1166 = _t2004 + if prediction1166 == 3: + _t2010 = self.parse_iceberg_data() + iceberg_data1170 = _t2010 + _t2011 = logic_pb2.Data(iceberg_data=iceberg_data1170) + _t2009 = _t2011 else: - if prediction1167 == 2: - _t2015 = self.parse_csv_data() - csv_data1170 = _t2015 - _t2016 = logic_pb2.Data(csv_data=csv_data1170) - _t2014 = _t2016 + if prediction1166 == 2: + _t2013 = self.parse_csv_data() + csv_data1169 = _t2013 + _t2014 = logic_pb2.Data(csv_data=csv_data1169) + _t2012 = _t2014 else: - if prediction1167 == 1: - _t2018 = self.parse_betree_relation() - betree_relation1169 = _t2018 - _t2019 = logic_pb2.Data(betree_relation=betree_relation1169) - _t2017 = _t2019 + if prediction1166 == 1: + _t2016 = self.parse_betree_relation() + betree_relation1168 = _t2016 + _t2017 = logic_pb2.Data(betree_relation=betree_relation1168) + _t2015 = _t2017 else: - if prediction1167 == 0: - _t2021 = self.parse_edb() - edb1168 = _t2021 - _t2022 = logic_pb2.Data(edb=edb1168) - _t2020 = _t2022 + if prediction1166 == 0: + _t2019 = self.parse_edb() + edb1167 = _t2019 + _t2020 = logic_pb2.Data(edb=edb1167) + _t2018 = _t2020 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2017 = _t2020 - _t2014 = _t2017 - _t2011 = _t2014 - result1173 = _t2011 - self.record_span(span_start1172, "Data") - return result1173 + _t2015 = _t2018 + _t2012 = _t2015 + _t2009 = _t2012 + result1172 = _t2009 + self.record_span(span_start1171, "Data") + return result1172 def parse_edb(self) -> logic_pb2.EDB: - span_start1177 = self.span_start() + span_start1176 = self.span_start() self.consume_literal("(") self.consume_literal("edb") - _t2023 = self.parse_relation_id() - relation_id1174 = _t2023 - _t2024 = self.parse_edb_path() - edb_path1175 = _t2024 - _t2025 = self.parse_edb_types() - edb_types1176 = _t2025 + _t2021 = self.parse_relation_id() + relation_id1173 = _t2021 + _t2022 = self.parse_edb_path() + edb_path1174 = _t2022 + _t2023 = self.parse_edb_types() + edb_types1175 = _t2023 self.consume_literal(")") - _t2026 = logic_pb2.EDB(target_id=relation_id1174, path=edb_path1175, types=edb_types1176) - result1178 = _t2026 - self.record_span(span_start1177, "EDB") - return result1178 + _t2024 = logic_pb2.EDB(target_id=relation_id1173, path=edb_path1174, types=edb_types1175) + result1177 = _t2024 + self.record_span(span_start1176, "EDB") + return result1177 def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs1179 = [] - cond1180 = self.match_lookahead_terminal("STRING", 0) - while cond1180: - item1181 = self.consume_terminal("STRING") - xs1179.append(item1181) - cond1180 = self.match_lookahead_terminal("STRING", 0) - strings1182 = xs1179 + xs1178 = [] + cond1179 = self.match_lookahead_terminal("STRING", 0) + while cond1179: + item1180 = self.consume_terminal("STRING") + xs1178.append(item1180) + cond1179 = self.match_lookahead_terminal("STRING", 0) + strings1181 = xs1178 self.consume_literal("]") - return strings1182 + return strings1181 def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs1183 = [] - cond1184 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1184: - _t2027 = self.parse_type() - item1185 = _t2027 - xs1183.append(item1185) - cond1184 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1186 = xs1183 + xs1182 = [] + cond1183 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1183: + _t2025 = self.parse_type() + item1184 = _t2025 + xs1182.append(item1184) + cond1183 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1185 = xs1182 self.consume_literal("]") - return types1186 + return types1185 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: - span_start1189 = self.span_start() + span_start1188 = self.span_start() self.consume_literal("(") self.consume_literal("betree_relation") - _t2028 = self.parse_relation_id() - relation_id1187 = _t2028 - _t2029 = self.parse_betree_info() - betree_info1188 = _t2029 + _t2026 = self.parse_relation_id() + relation_id1186 = _t2026 + _t2027 = self.parse_betree_info() + betree_info1187 = _t2027 self.consume_literal(")") - _t2030 = logic_pb2.BeTreeRelation(name=relation_id1187, relation_info=betree_info1188) - result1190 = _t2030 - self.record_span(span_start1189, "BeTreeRelation") - return result1190 + _t2028 = logic_pb2.BeTreeRelation(name=relation_id1186, relation_info=betree_info1187) + result1189 = _t2028 + self.record_span(span_start1188, "BeTreeRelation") + return result1189 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1194 = self.span_start() + span_start1193 = self.span_start() self.consume_literal("(") self.consume_literal("betree_info") - _t2031 = self.parse_betree_info_key_types() - betree_info_key_types1191 = _t2031 - _t2032 = self.parse_betree_info_value_types() - betree_info_value_types1192 = _t2032 - _t2033 = self.parse_config_dict() - config_dict1193 = _t2033 + _t2029 = self.parse_betree_info_key_types() + betree_info_key_types1190 = _t2029 + _t2030 = self.parse_betree_info_value_types() + betree_info_value_types1191 = _t2030 + _t2031 = self.parse_config_dict() + config_dict1192 = _t2031 self.consume_literal(")") - _t2034 = self.construct_betree_info(betree_info_key_types1191, betree_info_value_types1192, config_dict1193) - result1195 = _t2034 - self.record_span(span_start1194, "BeTreeInfo") - return result1195 + _t2032 = self.construct_betree_info(betree_info_key_types1190, betree_info_value_types1191, config_dict1192) + result1194 = _t2032 + self.record_span(span_start1193, "BeTreeInfo") + return result1194 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs1196 = [] - cond1197 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1197: - _t2035 = self.parse_type() - item1198 = _t2035 - xs1196.append(item1198) - cond1197 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1199 = xs1196 + xs1195 = [] + cond1196 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1196: + _t2033 = self.parse_type() + item1197 = _t2033 + xs1195.append(item1197) + cond1196 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1198 = xs1195 self.consume_literal(")") - return types1199 + return types1198 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - xs1200 = [] - cond1201 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1201: - _t2036 = self.parse_type() - item1202 = _t2036 - xs1200.append(item1202) - cond1201 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1203 = xs1200 + xs1199 = [] + cond1200 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1200: + _t2034 = self.parse_type() + item1201 = _t2034 + xs1199.append(item1201) + cond1200 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1202 = xs1199 self.consume_literal(")") - return types1203 + return types1202 def parse_csv_data(self) -> logic_pb2.CSVData: - span_start1209 = self.span_start() + span_start1208 = self.span_start() self.consume_literal("(") self.consume_literal("csv_data") - _t2037 = self.parse_csvlocator() - csvlocator1204 = _t2037 - _t2038 = self.parse_csv_config() - csv_config1205 = _t2038 + _t2035 = self.parse_csvlocator() + csvlocator1203 = _t2035 + _t2036 = self.parse_csv_config() + csv_config1204 = _t2036 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("columns", 1)): - _t2040 = self.parse_gnf_columns() - _t2039 = _t2040 + _t2038 = self.parse_gnf_columns() + _t2037 = _t2038 else: - _t2039 = None - gnf_columns1206 = _t2039 + _t2037 = None + gnf_columns1205 = _t2037 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("relations", 1)): - _t2042 = self.parse_target_relations() - _t2041 = _t2042 + _t2040 = self.parse_target_relations() + _t2039 = _t2040 else: - _t2041 = None - target_relations1207 = _t2041 - _t2043 = self.parse_csv_asof() - csv_asof1208 = _t2043 + _t2039 = None + target_relations1206 = _t2039 + _t2041 = self.parse_csv_asof() + csv_asof1207 = _t2041 self.consume_literal(")") - _t2044 = self.construct_csv_data(csvlocator1204, csv_config1205, gnf_columns1206, target_relations1207, csv_asof1208) - result1210 = _t2044 - self.record_span(span_start1209, "CSVData") - return result1210 + _t2042 = self.construct_csv_data(csvlocator1203, csv_config1204, gnf_columns1205, target_relations1206, csv_asof1207) + result1209 = _t2042 + self.record_span(span_start1208, "CSVData") + return result1209 def parse_csvlocator(self) -> logic_pb2.CSVLocator: - span_start1213 = self.span_start() + span_start1212 = self.span_start() self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t2046 = self.parse_csv_locator_paths() - _t2045 = _t2046 + _t2044 = self.parse_csv_locator_paths() + _t2043 = _t2044 else: - _t2045 = None - csv_locator_paths1211 = _t2045 + _t2043 = None + csv_locator_paths1210 = _t2043 if self.match_lookahead_literal("(", 0): - _t2048 = self.parse_csv_locator_inline_data() - _t2047 = _t2048 + _t2046 = self.parse_csv_locator_inline_data() + _t2045 = _t2046 else: - _t2047 = None - csv_locator_inline_data1212 = _t2047 + _t2045 = None + csv_locator_inline_data1211 = _t2045 self.consume_literal(")") - _t2049 = logic_pb2.CSVLocator(paths=(csv_locator_paths1211 if csv_locator_paths1211 is not None else []), inline_data=(csv_locator_inline_data1212 if csv_locator_inline_data1212 is not None else "").encode()) - result1214 = _t2049 - self.record_span(span_start1213, "CSVLocator") - return result1214 + _t2047 = logic_pb2.CSVLocator(paths=(csv_locator_paths1210 if csv_locator_paths1210 is not None else []), inline_data=(csv_locator_inline_data1211 if csv_locator_inline_data1211 is not None else "").encode()) + result1213 = _t2047 + self.record_span(span_start1212, "CSVLocator") + return result1213 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs1215 = [] - cond1216 = self.match_lookahead_terminal("STRING", 0) - while cond1216: - item1217 = self.consume_terminal("STRING") - xs1215.append(item1217) - cond1216 = self.match_lookahead_terminal("STRING", 0) - strings1218 = xs1215 + xs1214 = [] + cond1215 = self.match_lookahead_terminal("STRING", 0) + while cond1215: + item1216 = self.consume_terminal("STRING") + xs1214.append(item1216) + cond1215 = self.match_lookahead_terminal("STRING", 0) + strings1217 = xs1214 self.consume_literal(")") - return strings1218 + return strings1217 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - formatted_string1219 = self.consume_terminal("STRING") + formatted_string1218 = self.consume_terminal("STRING") self.consume_literal(")") - return formatted_string1219 + return formatted_string1218 def parse_csv_config(self) -> logic_pb2.CSVConfig: - span_start1222 = self.span_start() + span_start1221 = self.span_start() self.consume_literal("(") self.consume_literal("csv_config") - _t2050 = self.parse_config_dict() - config_dict1220 = _t2050 + _t2048 = self.parse_config_dict() + config_dict1219 = _t2048 if self.match_lookahead_literal("(", 0): - _t2052 = self.parse__storage_integration() - _t2051 = _t2052 + _t2050 = self.parse__storage_integration() + _t2049 = _t2050 else: - _t2051 = None - _storage_integration1221 = _t2051 + _t2049 = None + _storage_integration1220 = _t2049 self.consume_literal(")") - _t2053 = self.construct_csv_config(config_dict1220, _storage_integration1221) - result1223 = _t2053 - self.record_span(span_start1222, "CSVConfig") - return result1223 + _t2051 = self.construct_csv_config(config_dict1219, _storage_integration1220) + result1222 = _t2051 + self.record_span(span_start1221, "CSVConfig") + return result1222 def parse__storage_integration(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("(") self.consume_literal("storage_integration") - _t2054 = self.parse_config_dict() - config_dict1224 = _t2054 + _t2052 = self.parse_config_dict() + config_dict1223 = _t2052 self.consume_literal(")") - return config_dict1224 + return config_dict1223 def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1225 = [] - cond1226 = self.match_lookahead_literal("(", 0) - while cond1226: - _t2055 = self.parse_gnf_column() - item1227 = _t2055 - xs1225.append(item1227) - cond1226 = self.match_lookahead_literal("(", 0) - gnf_columns1228 = xs1225 + xs1224 = [] + cond1225 = self.match_lookahead_literal("(", 0) + while cond1225: + _t2053 = self.parse_gnf_column() + item1226 = _t2053 + xs1224.append(item1226) + cond1225 = self.match_lookahead_literal("(", 0) + gnf_columns1227 = xs1224 self.consume_literal(")") - return gnf_columns1228 + return gnf_columns1227 def parse_gnf_column(self) -> logic_pb2.GNFColumn: - span_start1235 = self.span_start() + span_start1234 = self.span_start() self.consume_literal("(") self.consume_literal("column") - _t2056 = self.parse_gnf_column_path() - gnf_column_path1229 = _t2056 + _t2054 = self.parse_gnf_column_path() + gnf_column_path1228 = _t2054 if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t2058 = self.parse_relation_id() - _t2057 = _t2058 + _t2056 = self.parse_relation_id() + _t2055 = _t2056 else: - _t2057 = None - relation_id1230 = _t2057 + _t2055 = None + relation_id1229 = _t2055 self.consume_literal("[") - xs1231 = [] - cond1232 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - while cond1232: - _t2059 = self.parse_type() - item1233 = _t2059 - xs1231.append(item1233) - cond1232 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) - types1234 = xs1231 + xs1230 = [] + cond1231 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + while cond1231: + _t2057 = self.parse_type() + item1232 = _t2057 + xs1230.append(item1232) + cond1231 = (((((((((((((self.match_lookahead_literal("(", 0) or self.match_lookahead_literal("BOOLEAN", 0)) or self.match_lookahead_literal("DATE", 0)) or self.match_lookahead_literal("DATETIME", 0)) or self.match_lookahead_literal("FLOAT", 0)) or self.match_lookahead_literal("FLOAT32", 0)) or self.match_lookahead_literal("INT", 0)) or self.match_lookahead_literal("INT128", 0)) or self.match_lookahead_literal("INT32", 0)) or self.match_lookahead_literal("MISSING", 0)) or self.match_lookahead_literal("STRING", 0)) or self.match_lookahead_literal("UINT128", 0)) or self.match_lookahead_literal("UINT32", 0)) or self.match_lookahead_literal("UNKNOWN", 0)) + types1233 = xs1230 self.consume_literal("]") self.consume_literal(")") - _t2060 = logic_pb2.GNFColumn(column_path=gnf_column_path1229, target_id=relation_id1230, types=types1234) - result1236 = _t2060 - self.record_span(span_start1235, "GNFColumn") - return result1236 + _t2058 = logic_pb2.GNFColumn(column_path=gnf_column_path1228, target_id=relation_id1229, types=types1233) + result1235 = _t2058 + self.record_span(span_start1234, "GNFColumn") + return result1235 def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t2061 = 1 + _t2059 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t2062 = 0 + _t2060 = 0 else: - _t2062 = -1 - _t2061 = _t2062 - prediction1237 = _t2061 - if prediction1237 == 1: + _t2060 = -1 + _t2059 = _t2060 + prediction1236 = _t2059 + if prediction1236 == 1: self.consume_literal("[") - xs1239 = [] - cond1240 = self.match_lookahead_terminal("STRING", 0) - while cond1240: - item1241 = self.consume_terminal("STRING") - xs1239.append(item1241) - cond1240 = self.match_lookahead_terminal("STRING", 0) - strings1242 = xs1239 + xs1238 = [] + cond1239 = self.match_lookahead_terminal("STRING", 0) + while cond1239: + item1240 = self.consume_terminal("STRING") + xs1238.append(item1240) + cond1239 = self.match_lookahead_terminal("STRING", 0) + strings1241 = xs1238 self.consume_literal("]") - _t2063 = strings1242 + _t2061 = strings1241 else: - if prediction1237 == 0: - string1238 = self.consume_terminal("STRING") - _t2064 = [string1238] + if prediction1236 == 0: + string1237 = self.consume_terminal("STRING") + _t2062 = [string1237] else: raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2063 = _t2064 - return _t2063 + _t2061 = _t2062 + return _t2061 def parse_target_relations(self) -> logic_pb2.TargetRelations: - span_start1245 = self.span_start() + span_start1244 = self.span_start() self.consume_literal("(") self.consume_literal("relations") - _t2065 = self.parse_relation_keys() - relation_keys1243 = _t2065 - _t2066 = self.parse_relation_body() - relation_body1244 = _t2066 + _t2063 = self.parse_relation_keys() + relation_keys1242 = _t2063 + _t2064 = self.parse_relation_body() + relation_body1243 = _t2064 self.consume_literal(")") - _t2067 = self.construct_relations(relation_keys1243, relation_body1244) - result1246 = _t2067 - self.record_span(span_start1245, "TargetRelations") - return result1246 + _t2065 = self.construct_relations(relation_keys1242, relation_body1243) + result1245 = _t2065 + self.record_span(span_start1244, "TargetRelations") + return result1245 def parse_relation_keys(self) -> tuple[Sequence[logic_pb2.NamedColumn], bool]: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("keys", 1): - if self.match_lookahead_literal(":", 2): - _t2070 = 1 + if self.match_lookahead_literal("synthetic", 2): + _t2068 = 1 else: if self.match_lookahead_literal(")", 2): - _t2071 = 0 + _t2069 = 0 else: if self.match_lookahead_literal("(", 2): - _t2072 = 0 + _t2070 = 0 else: - _t2072 = -1 - _t2071 = _t2072 - _t2070 = _t2071 - _t2069 = _t2070 + _t2070 = -1 + _t2069 = _t2070 + _t2068 = _t2069 + _t2067 = _t2068 else: - _t2069 = -1 - _t2068 = _t2069 + _t2067 = -1 + _t2066 = _t2067 else: - _t2068 = -1 - prediction1247 = _t2068 - if prediction1247 == 1: + _t2066 = -1 + prediction1246 = _t2066 + if prediction1246 == 1: self.consume_literal("(") self.consume_literal("keys") - self.consume_literal(":") - symbol1252 = self.consume_terminal("SYMBOL") + self.consume_literal("synthetic") self.consume_literal(")") - _t2074 = self.construct_synthetic_keys(symbol1252) - _t2073 = _t2074 + _t2071 = ([], True,) else: - if prediction1247 == 0: + if prediction1246 == 0: self.consume_literal("(") self.consume_literal("keys") - xs1248 = [] - cond1249 = self.match_lookahead_literal("(", 0) - while cond1249: - _t2076 = self.parse_named_column() - item1250 = _t2076 - xs1248.append(item1250) - cond1249 = self.match_lookahead_literal("(", 0) - named_columns1251 = xs1248 + xs1247 = [] + cond1248 = self.match_lookahead_literal("(", 0) + while cond1248: + _t2073 = self.parse_named_column() + item1249 = _t2073 + xs1247.append(item1249) + cond1248 = self.match_lookahead_literal("(", 0) + named_columns1250 = xs1247 self.consume_literal(")") - _t2075 = (named_columns1251, False,) + _t2072 = (named_columns1250, False,) else: raise ParseError("Unexpected token in relation_keys" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2073 = _t2075 - return _t2073 + _t2071 = _t2072 + return _t2071 def parse_named_column(self) -> logic_pb2.NamedColumn: - span_start1255 = self.span_start() + span_start1253 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1253 = self.consume_terminal("STRING") - _t2077 = self.parse_type() - type1254 = _t2077 + string1251 = self.consume_terminal("STRING") + _t2074 = self.parse_type() + type1252 = _t2074 self.consume_literal(")") - _t2078 = logic_pb2.NamedColumn(name=string1253, type=type1254) - result1256 = _t2078 - self.record_span(span_start1255, "NamedColumn") - return result1256 + _t2075 = logic_pb2.NamedColumn(name=string1251, type=type1252) + result1254 = _t2075 + self.record_span(span_start1253, "NamedColumn") + return result1254 def parse_relation_body(self) -> logic_pb2.TargetRelations: - span_start1261 = self.span_start() + span_start1259 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("relation", 1): - _t2080 = 0 + _t2077 = 0 else: if self.match_lookahead_literal("inserts", 1): - _t2081 = 1 + _t2078 = 1 else: - _t2081 = 0 - _t2080 = _t2081 - _t2079 = _t2080 + _t2078 = 0 + _t2077 = _t2078 + _t2076 = _t2077 else: - _t2079 = 0 - prediction1257 = _t2079 - if prediction1257 == 1: - _t2083 = self.parse_cdc_inserts() - cdc_inserts1259 = _t2083 - _t2084 = self.parse_cdc_deletes() - cdc_deletes1260 = _t2084 - _t2085 = self.construct_cdc_relations(cdc_inserts1259, cdc_deletes1260) - _t2082 = _t2085 + _t2076 = 0 + prediction1255 = _t2076 + if prediction1255 == 1: + _t2080 = self.parse_cdc_inserts() + cdc_inserts1257 = _t2080 + _t2081 = self.parse_cdc_deletes() + cdc_deletes1258 = _t2081 + _t2082 = self.construct_cdc_relations(cdc_inserts1257, cdc_deletes1258) + _t2079 = _t2082 else: - if prediction1257 == 0: - _t2087 = self.parse_non_cdc_relations() - non_cdc_relations1258 = _t2087 - _t2088 = self.construct_non_cdc_relations(non_cdc_relations1258) - _t2086 = _t2088 + if prediction1255 == 0: + _t2084 = self.parse_non_cdc_relations() + non_cdc_relations1256 = _t2084 + _t2085 = self.construct_non_cdc_relations(non_cdc_relations1256) + _t2083 = _t2085 else: raise ParseError("Unexpected token in relation_body" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2082 = _t2086 - result1262 = _t2082 - self.record_span(span_start1261, "TargetRelations") - return result1262 + _t2079 = _t2083 + result1260 = _t2079 + self.record_span(span_start1259, "TargetRelations") + return result1260 def parse_non_cdc_relations(self) -> Sequence[logic_pb2.TargetRelation]: - xs1263 = [] - cond1264 = self.match_lookahead_literal("(", 0) - while cond1264: - _t2089 = self.parse_target_relation() - item1265 = _t2089 - xs1263.append(item1265) - cond1264 = self.match_lookahead_literal("(", 0) - return xs1263 + xs1261 = [] + cond1262 = self.match_lookahead_literal("(", 0) + while cond1262: + _t2086 = self.parse_target_relation() + item1263 = _t2086 + xs1261.append(item1263) + cond1262 = self.match_lookahead_literal("(", 0) + return xs1261 def parse_target_relation(self) -> logic_pb2.TargetRelation: - span_start1271 = self.span_start() + span_start1269 = self.span_start() self.consume_literal("(") self.consume_literal("relation") - _t2090 = self.parse_relation_id() - relation_id1266 = _t2090 - xs1267 = [] - cond1268 = self.match_lookahead_literal("(", 0) - while cond1268: - _t2091 = self.parse_named_column() - item1269 = _t2091 - xs1267.append(item1269) - cond1268 = self.match_lookahead_literal("(", 0) - named_columns1270 = xs1267 + _t2087 = self.parse_relation_id() + relation_id1264 = _t2087 + xs1265 = [] + cond1266 = self.match_lookahead_literal("(", 0) + while cond1266: + _t2088 = self.parse_named_column() + item1267 = _t2088 + xs1265.append(item1267) + cond1266 = self.match_lookahead_literal("(", 0) + named_columns1268 = xs1265 self.consume_literal(")") - _t2092 = logic_pb2.TargetRelation(target_id=relation_id1266, values=named_columns1270) - result1272 = _t2092 - self.record_span(span_start1271, "TargetRelation") - return result1272 + _t2089 = logic_pb2.TargetRelation(target_id=relation_id1264, values=named_columns1268) + result1270 = _t2089 + self.record_span(span_start1269, "TargetRelation") + return result1270 def parse_cdc_inserts(self) -> Sequence[logic_pb2.TargetRelation]: self.consume_literal("(") self.consume_literal("inserts") - xs1273 = [] - cond1274 = self.match_lookahead_literal("(", 0) - while cond1274: - _t2093 = self.parse_target_relation() - item1275 = _t2093 - xs1273.append(item1275) - cond1274 = self.match_lookahead_literal("(", 0) - target_relations1276 = xs1273 + xs1271 = [] + cond1272 = self.match_lookahead_literal("(", 0) + while cond1272: + _t2090 = self.parse_target_relation() + item1273 = _t2090 + xs1271.append(item1273) + cond1272 = self.match_lookahead_literal("(", 0) + target_relations1274 = xs1271 self.consume_literal(")") - return target_relations1276 + return target_relations1274 def parse_cdc_deletes(self) -> Sequence[logic_pb2.TargetRelation]: self.consume_literal("(") self.consume_literal("deletes") - xs1277 = [] - cond1278 = self.match_lookahead_literal("(", 0) - while cond1278: - _t2094 = self.parse_target_relation() - item1279 = _t2094 - xs1277.append(item1279) - cond1278 = self.match_lookahead_literal("(", 0) - target_relations1280 = xs1277 + xs1275 = [] + cond1276 = self.match_lookahead_literal("(", 0) + while cond1276: + _t2091 = self.parse_target_relation() + item1277 = _t2091 + xs1275.append(item1277) + cond1276 = self.match_lookahead_literal("(", 0) + target_relations1278 = xs1275 self.consume_literal(")") - return target_relations1280 + return target_relations1278 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string1281 = self.consume_terminal("STRING") + string1279 = self.consume_terminal("STRING") self.consume_literal(")") - return string1281 + return string1279 def parse_iceberg_data(self) -> logic_pb2.IcebergData: - span_start1288 = self.span_start() + span_start1286 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_data") - _t2095 = self.parse_iceberg_locator() - iceberg_locator1282 = _t2095 - _t2096 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1283 = _t2096 - _t2097 = self.parse_gnf_columns() - gnf_columns1284 = _t2097 + _t2092 = self.parse_iceberg_locator() + iceberg_locator1280 = _t2092 + _t2093 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1281 = _t2093 + _t2094 = self.parse_gnf_columns() + gnf_columns1282 = _t2094 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("from_snapshot", 1)): - _t2099 = self.parse_iceberg_from_snapshot() - _t2098 = _t2099 + _t2096 = self.parse_iceberg_from_snapshot() + _t2095 = _t2096 else: - _t2098 = None - iceberg_from_snapshot1285 = _t2098 + _t2095 = None + iceberg_from_snapshot1283 = _t2095 if self.match_lookahead_literal("(", 0): - _t2101 = self.parse_iceberg_to_snapshot() - _t2100 = _t2101 + _t2098 = self.parse_iceberg_to_snapshot() + _t2097 = _t2098 else: - _t2100 = None - iceberg_to_snapshot1286 = _t2100 - _t2102 = self.parse_boolean_value() - boolean_value1287 = _t2102 + _t2097 = None + iceberg_to_snapshot1284 = _t2097 + _t2099 = self.parse_boolean_value() + boolean_value1285 = _t2099 self.consume_literal(")") - _t2103 = self.construct_iceberg_data(iceberg_locator1282, iceberg_catalog_config1283, gnf_columns1284, iceberg_from_snapshot1285, iceberg_to_snapshot1286, boolean_value1287) - result1289 = _t2103 - self.record_span(span_start1288, "IcebergData") - return result1289 + _t2100 = self.construct_iceberg_data(iceberg_locator1280, iceberg_catalog_config1281, gnf_columns1282, iceberg_from_snapshot1283, iceberg_to_snapshot1284, boolean_value1285) + result1287 = _t2100 + self.record_span(span_start1286, "IcebergData") + return result1287 def parse_iceberg_locator(self) -> logic_pb2.IcebergLocator: - span_start1293 = self.span_start() + span_start1291 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_locator") - _t2104 = self.parse_iceberg_locator_table_name() - iceberg_locator_table_name1290 = _t2104 - _t2105 = self.parse_iceberg_locator_namespace() - iceberg_locator_namespace1291 = _t2105 - _t2106 = self.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1292 = _t2106 + _t2101 = self.parse_iceberg_locator_table_name() + iceberg_locator_table_name1288 = _t2101 + _t2102 = self.parse_iceberg_locator_namespace() + iceberg_locator_namespace1289 = _t2102 + _t2103 = self.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1290 = _t2103 self.consume_literal(")") - _t2107 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1290, namespace=iceberg_locator_namespace1291, warehouse=iceberg_locator_warehouse1292) - result1294 = _t2107 - self.record_span(span_start1293, "IcebergLocator") - return result1294 + _t2104 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1288, namespace=iceberg_locator_namespace1289, warehouse=iceberg_locator_warehouse1290) + result1292 = _t2104 + self.record_span(span_start1291, "IcebergLocator") + return result1292 def parse_iceberg_locator_table_name(self) -> str: self.consume_literal("(") self.consume_literal("table_name") - string1295 = self.consume_terminal("STRING") + string1293 = self.consume_terminal("STRING") self.consume_literal(")") - return string1295 + return string1293 def parse_iceberg_locator_namespace(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("namespace") - xs1296 = [] - cond1297 = self.match_lookahead_terminal("STRING", 0) - while cond1297: - item1298 = self.consume_terminal("STRING") - xs1296.append(item1298) - cond1297 = self.match_lookahead_terminal("STRING", 0) - strings1299 = xs1296 + xs1294 = [] + cond1295 = self.match_lookahead_terminal("STRING", 0) + while cond1295: + item1296 = self.consume_terminal("STRING") + xs1294.append(item1296) + cond1295 = self.match_lookahead_terminal("STRING", 0) + strings1297 = xs1294 self.consume_literal(")") - return strings1299 + return strings1297 def parse_iceberg_locator_warehouse(self) -> str: self.consume_literal("(") self.consume_literal("warehouse") - string1300 = self.consume_terminal("STRING") + string1298 = self.consume_terminal("STRING") self.consume_literal(")") - return string1300 + return string1298 def parse_iceberg_catalog_config(self) -> logic_pb2.IcebergCatalogConfig: - span_start1305 = self.span_start() + span_start1303 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_catalog_config") - _t2108 = self.parse_iceberg_catalog_uri() - iceberg_catalog_uri1301 = _t2108 + _t2105 = self.parse_iceberg_catalog_uri() + iceberg_catalog_uri1299 = _t2105 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("scope", 1)): - _t2110 = self.parse_iceberg_catalog_config_scope() - _t2109 = _t2110 + _t2107 = self.parse_iceberg_catalog_config_scope() + _t2106 = _t2107 else: - _t2109 = None - iceberg_catalog_config_scope1302 = _t2109 - _t2111 = self.parse_iceberg_properties() - iceberg_properties1303 = _t2111 - _t2112 = self.parse_iceberg_auth_properties() - iceberg_auth_properties1304 = _t2112 + _t2106 = None + iceberg_catalog_config_scope1300 = _t2106 + _t2108 = self.parse_iceberg_properties() + iceberg_properties1301 = _t2108 + _t2109 = self.parse_iceberg_auth_properties() + iceberg_auth_properties1302 = _t2109 self.consume_literal(")") - _t2113 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1301, iceberg_catalog_config_scope1302, iceberg_properties1303, iceberg_auth_properties1304) - result1306 = _t2113 - self.record_span(span_start1305, "IcebergCatalogConfig") - return result1306 + _t2110 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1299, iceberg_catalog_config_scope1300, iceberg_properties1301, iceberg_auth_properties1302) + result1304 = _t2110 + self.record_span(span_start1303, "IcebergCatalogConfig") + return result1304 def parse_iceberg_catalog_uri(self) -> str: self.consume_literal("(") self.consume_literal("catalog_uri") - string1307 = self.consume_terminal("STRING") + string1305 = self.consume_terminal("STRING") self.consume_literal(")") - return string1307 + return string1305 def parse_iceberg_catalog_config_scope(self) -> str: self.consume_literal("(") self.consume_literal("scope") - string1308 = self.consume_terminal("STRING") + string1306 = self.consume_terminal("STRING") self.consume_literal(")") - return string1308 + return string1306 def parse_iceberg_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("properties") - xs1309 = [] - cond1310 = self.match_lookahead_literal("(", 0) - while cond1310: - _t2114 = self.parse_iceberg_property_entry() - item1311 = _t2114 - xs1309.append(item1311) - cond1310 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1312 = xs1309 + xs1307 = [] + cond1308 = self.match_lookahead_literal("(", 0) + while cond1308: + _t2111 = self.parse_iceberg_property_entry() + item1309 = _t2111 + xs1307.append(item1309) + cond1308 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1310 = xs1307 self.consume_literal(")") - return iceberg_property_entrys1312 + return iceberg_property_entrys1310 def parse_iceberg_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1313 = self.consume_terminal("STRING") - string_31314 = self.consume_terminal("STRING") + string1311 = self.consume_terminal("STRING") + string_31312 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1313, string_31314,) + return (string1311, string_31312,) def parse_iceberg_auth_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("auth_properties") - xs1315 = [] - cond1316 = self.match_lookahead_literal("(", 0) - while cond1316: - _t2115 = self.parse_iceberg_masked_property_entry() - item1317 = _t2115 - xs1315.append(item1317) - cond1316 = self.match_lookahead_literal("(", 0) - iceberg_masked_property_entrys1318 = xs1315 + xs1313 = [] + cond1314 = self.match_lookahead_literal("(", 0) + while cond1314: + _t2112 = self.parse_iceberg_masked_property_entry() + item1315 = _t2112 + xs1313.append(item1315) + cond1314 = self.match_lookahead_literal("(", 0) + iceberg_masked_property_entrys1316 = xs1313 self.consume_literal(")") - return iceberg_masked_property_entrys1318 + return iceberg_masked_property_entrys1316 def parse_iceberg_masked_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1319 = self.consume_terminal("STRING") - string_31320 = self.consume_terminal("STRING") + string1317 = self.consume_terminal("STRING") + string_31318 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1319, string_31320,) + return (string1317, string_31318,) def parse_iceberg_from_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("from_snapshot") - string1321 = self.consume_terminal("STRING") + string1319 = self.consume_terminal("STRING") self.consume_literal(")") - return string1321 + return string1319 def parse_iceberg_to_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("to_snapshot") - string1322 = self.consume_terminal("STRING") + string1320 = self.consume_terminal("STRING") self.consume_literal(")") - return string1322 + return string1320 def parse_undefine(self) -> transactions_pb2.Undefine: - span_start1324 = self.span_start() + span_start1322 = self.span_start() self.consume_literal("(") self.consume_literal("undefine") - _t2116 = self.parse_fragment_id() - fragment_id1323 = _t2116 + _t2113 = self.parse_fragment_id() + fragment_id1321 = _t2113 self.consume_literal(")") - _t2117 = transactions_pb2.Undefine(fragment_id=fragment_id1323) - result1325 = _t2117 - self.record_span(span_start1324, "Undefine") - return result1325 + _t2114 = transactions_pb2.Undefine(fragment_id=fragment_id1321) + result1323 = _t2114 + self.record_span(span_start1322, "Undefine") + return result1323 def parse_context(self) -> transactions_pb2.Context: - span_start1330 = self.span_start() + span_start1328 = self.span_start() self.consume_literal("(") self.consume_literal("context") - xs1326 = [] - cond1327 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1327: - _t2118 = self.parse_relation_id() - item1328 = _t2118 - xs1326.append(item1328) - cond1327 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1329 = xs1326 + xs1324 = [] + cond1325 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1325: + _t2115 = self.parse_relation_id() + item1326 = _t2115 + xs1324.append(item1326) + cond1325 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1327 = xs1324 self.consume_literal(")") - _t2119 = transactions_pb2.Context(relations=relation_ids1329) - result1331 = _t2119 - self.record_span(span_start1330, "Context") - return result1331 + _t2116 = transactions_pb2.Context(relations=relation_ids1327) + result1329 = _t2116 + self.record_span(span_start1328, "Context") + return result1329 def parse_snapshot(self) -> transactions_pb2.Snapshot: - span_start1337 = self.span_start() + span_start1335 = self.span_start() self.consume_literal("(") self.consume_literal("snapshot") - _t2120 = self.parse_edb_path() - edb_path1332 = _t2120 - xs1333 = [] - cond1334 = self.match_lookahead_literal("[", 0) - while cond1334: - _t2121 = self.parse_snapshot_mapping() - item1335 = _t2121 - xs1333.append(item1335) - cond1334 = self.match_lookahead_literal("[", 0) - snapshot_mappings1336 = xs1333 + _t2117 = self.parse_edb_path() + edb_path1330 = _t2117 + xs1331 = [] + cond1332 = self.match_lookahead_literal("[", 0) + while cond1332: + _t2118 = self.parse_snapshot_mapping() + item1333 = _t2118 + xs1331.append(item1333) + cond1332 = self.match_lookahead_literal("[", 0) + snapshot_mappings1334 = xs1331 self.consume_literal(")") - _t2122 = transactions_pb2.Snapshot(prefix=edb_path1332, mappings=snapshot_mappings1336) - result1338 = _t2122 - self.record_span(span_start1337, "Snapshot") - return result1338 + _t2119 = transactions_pb2.Snapshot(prefix=edb_path1330, mappings=snapshot_mappings1334) + result1336 = _t2119 + self.record_span(span_start1335, "Snapshot") + return result1336 def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: - span_start1341 = self.span_start() - _t2123 = self.parse_edb_path() - edb_path1339 = _t2123 - _t2124 = self.parse_relation_id() - relation_id1340 = _t2124 - _t2125 = transactions_pb2.SnapshotMapping(destination_path=edb_path1339, source_relation=relation_id1340) - result1342 = _t2125 - self.record_span(span_start1341, "SnapshotMapping") - return result1342 + span_start1339 = self.span_start() + _t2120 = self.parse_edb_path() + edb_path1337 = _t2120 + _t2121 = self.parse_relation_id() + relation_id1338 = _t2121 + _t2122 = transactions_pb2.SnapshotMapping(destination_path=edb_path1337, source_relation=relation_id1338) + result1340 = _t2122 + self.record_span(span_start1339, "SnapshotMapping") + return result1340 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs1343 = [] - cond1344 = self.match_lookahead_literal("(", 0) - while cond1344: - _t2126 = self.parse_read() - item1345 = _t2126 - xs1343.append(item1345) - cond1344 = self.match_lookahead_literal("(", 0) - reads1346 = xs1343 + xs1341 = [] + cond1342 = self.match_lookahead_literal("(", 0) + while cond1342: + _t2123 = self.parse_read() + item1343 = _t2123 + xs1341.append(item1343) + cond1342 = self.match_lookahead_literal("(", 0) + reads1344 = xs1341 self.consume_literal(")") - return reads1346 + return reads1344 def parse_read(self) -> transactions_pb2.Read: - span_start1353 = self.span_start() + span_start1351 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t2128 = 2 + _t2125 = 2 else: if self.match_lookahead_literal("output", 1): - _t2129 = 1 + _t2126 = 1 else: if self.match_lookahead_literal("export_iceberg", 1): - _t2130 = 4 + _t2127 = 4 else: if self.match_lookahead_literal("export", 1): - _t2131 = 4 + _t2128 = 4 else: if self.match_lookahead_literal("demand", 1): - _t2132 = 0 + _t2129 = 0 else: if self.match_lookahead_literal("abort", 1): - _t2133 = 3 + _t2130 = 3 else: - _t2133 = -1 - _t2132 = _t2133 - _t2131 = _t2132 - _t2130 = _t2131 - _t2129 = _t2130 - _t2128 = _t2129 - _t2127 = _t2128 + _t2130 = -1 + _t2129 = _t2130 + _t2128 = _t2129 + _t2127 = _t2128 + _t2126 = _t2127 + _t2125 = _t2126 + _t2124 = _t2125 else: - _t2127 = -1 - prediction1347 = _t2127 - if prediction1347 == 4: - _t2135 = self.parse_export() - export1352 = _t2135 - _t2136 = transactions_pb2.Read(export=export1352) - _t2134 = _t2136 + _t2124 = -1 + prediction1345 = _t2124 + if prediction1345 == 4: + _t2132 = self.parse_export() + export1350 = _t2132 + _t2133 = transactions_pb2.Read(export=export1350) + _t2131 = _t2133 else: - if prediction1347 == 3: - _t2138 = self.parse_abort() - abort1351 = _t2138 - _t2139 = transactions_pb2.Read(abort=abort1351) - _t2137 = _t2139 + if prediction1345 == 3: + _t2135 = self.parse_abort() + abort1349 = _t2135 + _t2136 = transactions_pb2.Read(abort=abort1349) + _t2134 = _t2136 else: - if prediction1347 == 2: - _t2141 = self.parse_what_if() - what_if1350 = _t2141 - _t2142 = transactions_pb2.Read(what_if=what_if1350) - _t2140 = _t2142 + if prediction1345 == 2: + _t2138 = self.parse_what_if() + what_if1348 = _t2138 + _t2139 = transactions_pb2.Read(what_if=what_if1348) + _t2137 = _t2139 else: - if prediction1347 == 1: - _t2144 = self.parse_output() - output1349 = _t2144 - _t2145 = transactions_pb2.Read(output=output1349) - _t2143 = _t2145 + if prediction1345 == 1: + _t2141 = self.parse_output() + output1347 = _t2141 + _t2142 = transactions_pb2.Read(output=output1347) + _t2140 = _t2142 else: - if prediction1347 == 0: - _t2147 = self.parse_demand() - demand1348 = _t2147 - _t2148 = transactions_pb2.Read(demand=demand1348) - _t2146 = _t2148 + if prediction1345 == 0: + _t2144 = self.parse_demand() + demand1346 = _t2144 + _t2145 = transactions_pb2.Read(demand=demand1346) + _t2143 = _t2145 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2143 = _t2146 - _t2140 = _t2143 - _t2137 = _t2140 - _t2134 = _t2137 - result1354 = _t2134 - self.record_span(span_start1353, "Read") - return result1354 + _t2140 = _t2143 + _t2137 = _t2140 + _t2134 = _t2137 + _t2131 = _t2134 + result1352 = _t2131 + self.record_span(span_start1351, "Read") + return result1352 def parse_demand(self) -> transactions_pb2.Demand: - span_start1356 = self.span_start() + span_start1354 = self.span_start() self.consume_literal("(") self.consume_literal("demand") - _t2149 = self.parse_relation_id() - relation_id1355 = _t2149 + _t2146 = self.parse_relation_id() + relation_id1353 = _t2146 self.consume_literal(")") - _t2150 = transactions_pb2.Demand(relation_id=relation_id1355) - result1357 = _t2150 - self.record_span(span_start1356, "Demand") - return result1357 + _t2147 = transactions_pb2.Demand(relation_id=relation_id1353) + result1355 = _t2147 + self.record_span(span_start1354, "Demand") + return result1355 def parse_output(self) -> transactions_pb2.Output: - span_start1360 = self.span_start() + span_start1358 = self.span_start() self.consume_literal("(") self.consume_literal("output") - _t2151 = self.parse_name() - name1358 = _t2151 - _t2152 = self.parse_relation_id() - relation_id1359 = _t2152 + _t2148 = self.parse_name() + name1356 = _t2148 + _t2149 = self.parse_relation_id() + relation_id1357 = _t2149 self.consume_literal(")") - _t2153 = transactions_pb2.Output(name=name1358, relation_id=relation_id1359) - result1361 = _t2153 - self.record_span(span_start1360, "Output") - return result1361 + _t2150 = transactions_pb2.Output(name=name1356, relation_id=relation_id1357) + result1359 = _t2150 + self.record_span(span_start1358, "Output") + return result1359 def parse_what_if(self) -> transactions_pb2.WhatIf: - span_start1364 = self.span_start() + span_start1362 = self.span_start() self.consume_literal("(") self.consume_literal("what_if") - _t2154 = self.parse_name() - name1362 = _t2154 - _t2155 = self.parse_epoch() - epoch1363 = _t2155 + _t2151 = self.parse_name() + name1360 = _t2151 + _t2152 = self.parse_epoch() + epoch1361 = _t2152 self.consume_literal(")") - _t2156 = transactions_pb2.WhatIf(branch=name1362, epoch=epoch1363) - result1365 = _t2156 - self.record_span(span_start1364, "WhatIf") - return result1365 + _t2153 = transactions_pb2.WhatIf(branch=name1360, epoch=epoch1361) + result1363 = _t2153 + self.record_span(span_start1362, "WhatIf") + return result1363 def parse_abort(self) -> transactions_pb2.Abort: - span_start1368 = self.span_start() + span_start1366 = self.span_start() self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t2158 = self.parse_name() - _t2157 = _t2158 + _t2155 = self.parse_name() + _t2154 = _t2155 else: - _t2157 = None - name1366 = _t2157 - _t2159 = self.parse_relation_id() - relation_id1367 = _t2159 + _t2154 = None + name1364 = _t2154 + _t2156 = self.parse_relation_id() + relation_id1365 = _t2156 self.consume_literal(")") - _t2160 = transactions_pb2.Abort(name=(name1366 if name1366 is not None else "abort"), relation_id=relation_id1367) - result1369 = _t2160 - self.record_span(span_start1368, "Abort") - return result1369 + _t2157 = transactions_pb2.Abort(name=(name1364 if name1364 is not None else "abort"), relation_id=relation_id1365) + result1367 = _t2157 + self.record_span(span_start1366, "Abort") + return result1367 def parse_export(self) -> transactions_pb2.Export: - span_start1373 = self.span_start() + span_start1371 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_iceberg", 1): - _t2162 = 1 + _t2159 = 1 else: if self.match_lookahead_literal("export", 1): - _t2163 = 0 + _t2160 = 0 else: - _t2163 = -1 - _t2162 = _t2163 - _t2161 = _t2162 + _t2160 = -1 + _t2159 = _t2160 + _t2158 = _t2159 else: - _t2161 = -1 - prediction1370 = _t2161 - if prediction1370 == 1: + _t2158 = -1 + prediction1368 = _t2158 + if prediction1368 == 1: self.consume_literal("(") self.consume_literal("export_iceberg") - _t2165 = self.parse_export_iceberg_config() - export_iceberg_config1372 = _t2165 + _t2162 = self.parse_export_iceberg_config() + export_iceberg_config1370 = _t2162 self.consume_literal(")") - _t2166 = transactions_pb2.Export(iceberg_config=export_iceberg_config1372) - _t2164 = _t2166 + _t2163 = transactions_pb2.Export(iceberg_config=export_iceberg_config1370) + _t2161 = _t2163 else: - if prediction1370 == 0: + if prediction1368 == 0: self.consume_literal("(") self.consume_literal("export") - _t2168 = self.parse_export_csv_config() - export_csv_config1371 = _t2168 + _t2165 = self.parse_export_csv_config() + export_csv_config1369 = _t2165 self.consume_literal(")") - _t2169 = transactions_pb2.Export(csv_config=export_csv_config1371) - _t2167 = _t2169 + _t2166 = transactions_pb2.Export(csv_config=export_csv_config1369) + _t2164 = _t2166 else: raise ParseError("Unexpected token in export" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2164 = _t2167 - result1374 = _t2164 - self.record_span(span_start1373, "Export") - return result1374 + _t2161 = _t2164 + result1372 = _t2161 + self.record_span(span_start1371, "Export") + return result1372 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1382 = self.span_start() + span_start1380 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2171 = 0 + _t2168 = 0 else: if self.match_lookahead_literal("export_csv_config", 1): - _t2172 = 1 + _t2169 = 1 else: - _t2172 = -1 - _t2171 = _t2172 - _t2170 = _t2171 + _t2169 = -1 + _t2168 = _t2169 + _t2167 = _t2168 else: - _t2170 = -1 - prediction1375 = _t2170 - if prediction1375 == 1: + _t2167 = -1 + prediction1373 = _t2167 + if prediction1373 == 1: self.consume_literal("(") self.consume_literal("export_csv_config") - _t2174 = self.parse_export_csv_path() - export_csv_path1379 = _t2174 - _t2175 = self.parse_export_csv_columns_list() - export_csv_columns_list1380 = _t2175 - _t2176 = self.parse_config_dict() - config_dict1381 = _t2176 + _t2171 = self.parse_export_csv_path() + export_csv_path1377 = _t2171 + _t2172 = self.parse_export_csv_columns_list() + export_csv_columns_list1378 = _t2172 + _t2173 = self.parse_config_dict() + config_dict1379 = _t2173 self.consume_literal(")") - _t2177 = self.construct_export_csv_config(export_csv_path1379, export_csv_columns_list1380, config_dict1381) - _t2173 = _t2177 + _t2174 = self.construct_export_csv_config(export_csv_path1377, export_csv_columns_list1378, config_dict1379) + _t2170 = _t2174 else: - if prediction1375 == 0: + if prediction1373 == 0: self.consume_literal("(") self.consume_literal("export_csv_config_v2") - _t2179 = self.parse_export_csv_output_location() - export_csv_output_location1376 = _t2179 - _t2180 = self.parse_export_csv_source() - export_csv_source1377 = _t2180 - _t2181 = self.parse_csv_config() - csv_config1378 = _t2181 + _t2176 = self.parse_export_csv_output_location() + export_csv_output_location1374 = _t2176 + _t2177 = self.parse_export_csv_source() + export_csv_source1375 = _t2177 + _t2178 = self.parse_csv_config() + csv_config1376 = _t2178 self.consume_literal(")") - _t2182 = self.construct_export_csv_config_with_location(export_csv_output_location1376, export_csv_source1377, csv_config1378) - _t2178 = _t2182 + _t2179 = self.construct_export_csv_config_with_location(export_csv_output_location1374, export_csv_source1375, csv_config1376) + _t2175 = _t2179 else: raise ParseError("Unexpected token in export_csv_config" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2173 = _t2178 - result1383 = _t2173 - self.record_span(span_start1382, "ExportCSVConfig") - return result1383 + _t2170 = _t2175 + result1381 = _t2170 + self.record_span(span_start1380, "ExportCSVConfig") + return result1381 def parse_export_csv_output_location(self) -> tuple[str, str]: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("transaction_output_name", 1): - _t2184 = 1 + _t2181 = 1 else: if self.match_lookahead_literal("path", 1): - _t2185 = 0 + _t2182 = 0 else: - _t2185 = -1 - _t2184 = _t2185 - _t2183 = _t2184 + _t2182 = -1 + _t2181 = _t2182 + _t2180 = _t2181 else: - _t2183 = -1 - prediction1384 = _t2183 - if prediction1384 == 1: + _t2180 = -1 + prediction1382 = _t2180 + if prediction1382 == 1: self.consume_literal("(") self.consume_literal("transaction_output_name") - _t2187 = self.parse_name() - name1386 = _t2187 + _t2184 = self.parse_name() + name1384 = _t2184 self.consume_literal(")") - _t2186 = ("", name1386,) + _t2183 = ("", name1384,) else: - if prediction1384 == 0: + if prediction1382 == 0: self.consume_literal("(") self.consume_literal("path") - string1385 = self.consume_terminal("STRING") + string1383 = self.consume_terminal("STRING") self.consume_literal(")") - _t2188 = (string1385, "",) + _t2185 = (string1383, "",) else: raise ParseError("Unexpected token in export_csv_output_location" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2186 = _t2188 - return _t2186 + _t2183 = _t2185 + return _t2183 def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1393 = self.span_start() + span_start1391 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("table_def", 1): - _t2190 = 1 + _t2187 = 1 else: if self.match_lookahead_literal("gnf_columns", 1): - _t2191 = 0 + _t2188 = 0 else: - _t2191 = -1 - _t2190 = _t2191 - _t2189 = _t2190 + _t2188 = -1 + _t2187 = _t2188 + _t2186 = _t2187 else: - _t2189 = -1 - prediction1387 = _t2189 - if prediction1387 == 1: + _t2186 = -1 + prediction1385 = _t2186 + if prediction1385 == 1: self.consume_literal("(") self.consume_literal("table_def") - _t2193 = self.parse_relation_id() - relation_id1392 = _t2193 + _t2190 = self.parse_relation_id() + relation_id1390 = _t2190 self.consume_literal(")") - _t2194 = transactions_pb2.ExportCSVSource(table_def=relation_id1392) - _t2192 = _t2194 + _t2191 = transactions_pb2.ExportCSVSource(table_def=relation_id1390) + _t2189 = _t2191 else: - if prediction1387 == 0: + if prediction1385 == 0: self.consume_literal("(") self.consume_literal("gnf_columns") - xs1388 = [] - cond1389 = self.match_lookahead_literal("(", 0) - while cond1389: - _t2196 = self.parse_export_csv_column() - item1390 = _t2196 - xs1388.append(item1390) - cond1389 = self.match_lookahead_literal("(", 0) - export_csv_columns1391 = xs1388 + xs1386 = [] + cond1387 = self.match_lookahead_literal("(", 0) + while cond1387: + _t2193 = self.parse_export_csv_column() + item1388 = _t2193 + xs1386.append(item1388) + cond1387 = self.match_lookahead_literal("(", 0) + export_csv_columns1389 = xs1386 self.consume_literal(")") - _t2197 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1391) - _t2198 = transactions_pb2.ExportCSVSource(gnf_columns=_t2197) - _t2195 = _t2198 + _t2194 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1389) + _t2195 = transactions_pb2.ExportCSVSource(gnf_columns=_t2194) + _t2192 = _t2195 else: raise ParseError("Unexpected token in export_csv_source" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2192 = _t2195 - result1394 = _t2192 - self.record_span(span_start1393, "ExportCSVSource") - return result1394 + _t2189 = _t2192 + result1392 = _t2189 + self.record_span(span_start1391, "ExportCSVSource") + return result1392 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1397 = self.span_start() + span_start1395 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1395 = self.consume_terminal("STRING") - _t2199 = self.parse_relation_id() - relation_id1396 = _t2199 + string1393 = self.consume_terminal("STRING") + _t2196 = self.parse_relation_id() + relation_id1394 = _t2196 self.consume_literal(")") - _t2200 = transactions_pb2.ExportCSVColumn(column_name=string1395, column_data=relation_id1396) - result1398 = _t2200 - self.record_span(span_start1397, "ExportCSVColumn") - return result1398 + _t2197 = transactions_pb2.ExportCSVColumn(column_name=string1393, column_data=relation_id1394) + result1396 = _t2197 + self.record_span(span_start1395, "ExportCSVColumn") + return result1396 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") - string1399 = self.consume_terminal("STRING") + string1397 = self.consume_terminal("STRING") self.consume_literal(")") - return string1399 + return string1397 def parse_export_csv_columns_list(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1400 = [] - cond1401 = self.match_lookahead_literal("(", 0) - while cond1401: - _t2201 = self.parse_export_csv_column() - item1402 = _t2201 - xs1400.append(item1402) - cond1401 = self.match_lookahead_literal("(", 0) - export_csv_columns1403 = xs1400 + xs1398 = [] + cond1399 = self.match_lookahead_literal("(", 0) + while cond1399: + _t2198 = self.parse_export_csv_column() + item1400 = _t2198 + xs1398.append(item1400) + cond1399 = self.match_lookahead_literal("(", 0) + export_csv_columns1401 = xs1398 self.consume_literal(")") - return export_csv_columns1403 + return export_csv_columns1401 def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1409 = self.span_start() + span_start1407 = self.span_start() self.consume_literal("(") self.consume_literal("export_iceberg_config") - _t2202 = self.parse_iceberg_locator() - iceberg_locator1404 = _t2202 - _t2203 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1405 = _t2203 - _t2204 = self.parse_export_iceberg_table_def() - export_iceberg_table_def1406 = _t2204 - _t2205 = self.parse_iceberg_table_properties() - iceberg_table_properties1407 = _t2205 + _t2199 = self.parse_iceberg_locator() + iceberg_locator1402 = _t2199 + _t2200 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1403 = _t2200 + _t2201 = self.parse_export_iceberg_table_def() + export_iceberg_table_def1404 = _t2201 + _t2202 = self.parse_iceberg_table_properties() + iceberg_table_properties1405 = _t2202 if self.match_lookahead_literal("{", 0): - _t2207 = self.parse_config_dict() - _t2206 = _t2207 + _t2204 = self.parse_config_dict() + _t2203 = _t2204 else: - _t2206 = None - config_dict1408 = _t2206 + _t2203 = None + config_dict1406 = _t2203 self.consume_literal(")") - _t2208 = self.construct_export_iceberg_config_full(iceberg_locator1404, iceberg_catalog_config1405, export_iceberg_table_def1406, iceberg_table_properties1407, config_dict1408) - result1410 = _t2208 - self.record_span(span_start1409, "ExportIcebergConfig") - return result1410 + _t2205 = self.construct_export_iceberg_config_full(iceberg_locator1402, iceberg_catalog_config1403, export_iceberg_table_def1404, iceberg_table_properties1405, config_dict1406) + result1408 = _t2205 + self.record_span(span_start1407, "ExportIcebergConfig") + return result1408 def parse_export_iceberg_table_def(self) -> logic_pb2.RelationId: - span_start1412 = self.span_start() + span_start1410 = self.span_start() self.consume_literal("(") self.consume_literal("table_def") - _t2209 = self.parse_relation_id() - relation_id1411 = _t2209 + _t2206 = self.parse_relation_id() + relation_id1409 = _t2206 self.consume_literal(")") - result1413 = relation_id1411 - self.record_span(span_start1412, "RelationId") - return result1413 + result1411 = relation_id1409 + self.record_span(span_start1410, "RelationId") + return result1411 def parse_iceberg_table_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("table_properties") - xs1414 = [] - cond1415 = self.match_lookahead_literal("(", 0) - while cond1415: - _t2210 = self.parse_iceberg_property_entry() - item1416 = _t2210 - xs1414.append(item1416) - cond1415 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1417 = xs1414 + xs1412 = [] + cond1413 = self.match_lookahead_literal("(", 0) + while cond1413: + _t2207 = self.parse_iceberg_property_entry() + item1414 = _t2207 + xs1412.append(item1414) + cond1413 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1415 = xs1412 self.consume_literal(")") - return iceberg_property_entrys1417 + return iceberg_property_entrys1415 def parse_transaction(input_str: str) -> tuple[Any, dict[int, Span]]: diff --git a/sdks/python/src/lqp/gen/pretty.py b/sdks/python/src/lqp/gen/pretty.py index 975345bc..ecb36722 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -3635,7 +3635,7 @@ def pretty_relation_keys(self, msg: tuple[Sequence[logic_pb2.NamedColumn], bool] else: _dollar_dollar = msg if _dollar_dollar[1]: - _t1830 = "synthetic_key" + _t1830 = () else: _t1830 = None deconstruct_result1493 = _t1830 @@ -3643,12 +3643,8 @@ def pretty_relation_keys(self, msg: tuple[Sequence[logic_pb2.NamedColumn], bool] assert deconstruct_result1493 is not None unwrapped1494 = deconstruct_result1493 self.write("(keys") - self.indent_sexp() self.newline() - self.write(":") - self.write(unwrapped1494) - self.dedent() - self.write(")") + self.write("synthetic)") else: raise ParseError("No matching rule for relation_keys") diff --git a/sdks/python/tests/test_parser.py b/sdks/python/tests/test_parser.py index 312a48c0..3352dfd9 100644 --- a/sdks/python/tests/test_parser.py +++ b/sdks/python/tests/test_parser.py @@ -116,8 +116,8 @@ def _relations_of(fragment: str): def test_synthetic_key_marker(): - # `(keys :synthetic_key)` sets the synthetic_key flag and leaves keys empty. - relations = _relations_of(_relations_fragment("(keys :synthetic_key)")) + # `(keys synthetic)` sets the synthetic_key flag and leaves keys empty. + relations = _relations_of(_relations_fragment("(keys synthetic)")) assert relations.synthetic_key is True assert list(relations.keys) == [] @@ -128,9 +128,9 @@ def test_synthetic_key_marker(): def test_synthetic_key_rejects_unknown_marker(): - # Only the `:synthetic_key` marker is accepted; anything else is a hard error. + # Only the `synthetic` marker is accepted; anything else is a hard error. with pytest.raises(ParseError): - parse_fragment(_relations_fragment("(keys :bogus)")) + parse_fragment(_relations_fragment("(keys bogus)")) class TestSymbolLexing: diff --git a/tests/lqp/relations_synthetic_key.lqp b/tests/lqp/relations_synthetic_key.lqp index 9ab2e1a4..bc3995e0 100644 --- a/tests/lqp/relations_synthetic_key.lqp +++ b/tests/lqp/relations_synthetic_key.lqp @@ -11,7 +11,7 @@ (paths "s3://bucket/nodes.csv")) (csv_config {}) (relations - (keys :synthetic_key) + (keys synthetic) (relation :weights (column "weight" FLOAT)) (relation :labels diff --git a/tests/lqp/relations_synthetic_key_cdc.lqp b/tests/lqp/relations_synthetic_key_cdc.lqp index 4da2da93..75842141 100644 --- a/tests/lqp/relations_synthetic_key_cdc.lqp +++ b/tests/lqp/relations_synthetic_key_cdc.lqp @@ -11,7 +11,7 @@ (paths "s3://bucket/edges.csv")) (csv_config {}) (relations - (keys :synthetic_key) + (keys synthetic) (inserts (relation :weight_ins (column "weight" FLOAT))) diff --git a/tests/pretty/relations_synthetic_key.lqp b/tests/pretty/relations_synthetic_key.lqp index 9cdc8cac..fd4b8dc7 100644 --- a/tests/pretty/relations_synthetic_key.lqp +++ b/tests/pretty/relations_synthetic_key.lqp @@ -18,7 +18,7 @@ :csv_quotechar "\"" :csv_skip 0}) (relations - (keys :synthetic_key) + (keys synthetic) (relation :weights (column "weight" FLOAT)) (relation :labels (column "label" STRING))) (asof "2025-06-01T00:00:00Z"))))) diff --git a/tests/pretty/relations_synthetic_key_cdc.lqp b/tests/pretty/relations_synthetic_key_cdc.lqp index a97c44cd..dce94dc4 100644 --- a/tests/pretty/relations_synthetic_key_cdc.lqp +++ b/tests/pretty/relations_synthetic_key_cdc.lqp @@ -18,7 +18,7 @@ :csv_quotechar "\"" :csv_skip 0}) (relations - (keys :synthetic_key) + (keys synthetic) (inserts (relation :weight_ins (column "weight" FLOAT))) (deletes (relation :weight_del (column "weight" FLOAT)))) (asof "2025-06-01T00:00:00Z"))))) diff --git a/tests/pretty_debug/relations_synthetic_key.lqp b/tests/pretty_debug/relations_synthetic_key.lqp index 23d9bafc..592aa495 100644 --- a/tests/pretty_debug/relations_synthetic_key.lqp +++ b/tests/pretty_debug/relations_synthetic_key.lqp @@ -18,7 +18,7 @@ :csv_quotechar "\"" :csv_skip 0}) (relations - (keys :synthetic_key) + (keys synthetic) (relation 0x813449061ab87848cf1a13eafdf33b2c (column "weight" FLOAT)) (relation 0x93d866d8479f84a4c0ca36918a3fa75f (column "label" STRING))) (asof "2025-06-01T00:00:00Z"))))) diff --git a/tests/pretty_debug/relations_synthetic_key_cdc.lqp b/tests/pretty_debug/relations_synthetic_key_cdc.lqp index 4e495b48..18409590 100644 --- a/tests/pretty_debug/relations_synthetic_key_cdc.lqp +++ b/tests/pretty_debug/relations_synthetic_key_cdc.lqp @@ -18,7 +18,7 @@ :csv_quotechar "\"" :csv_skip 0}) (relations - (keys :synthetic_key) + (keys synthetic) (inserts (relation 0x678037975b01b6389c78bc1cc79abde (column "weight" FLOAT))) (deletes (relation 0xb214f85adaa2e403bed30d3721f4363 (column "weight" FLOAT)))) (asof "2025-06-01T00:00:00Z"))))) From d05f8c29784aa5d47e64c3bfcd1aeeb7e2986c32 Mon Sep 17 00:00:00 2001 From: Henrik Barthels <25176271+hbarthels@users.noreply.github.com> Date: Sat, 25 Jul 2026 17:53:57 +0200 Subject: [PATCH 3/3] Test synthetic key with a single unary keyless relation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cover the case where a synthetic key feeds a single relation that has no value columns — i.e. the relation holds just the (synthetic) key. Adds the `relations_synthetic_key_unary` round-trip fixture and a matching parser unit test asserting synthetic_key is set, keys is empty, and the sole target has no value columns. Co-Authored-By: Claude Opus 4.8 --- sdks/python/tests/test_parser.py | 15 +++++++++++ tests/bin/relations_synthetic_key_unary.bin | 13 +++++++++ tests/lqp/relations_synthetic_key_unary.lqp | 18 +++++++++++++ .../pretty/relations_synthetic_key_unary.lqp | 22 +++++++++++++++ .../relations_synthetic_key_unary.lqp | 27 +++++++++++++++++++ 5 files changed, 95 insertions(+) create mode 100644 tests/bin/relations_synthetic_key_unary.bin create mode 100644 tests/lqp/relations_synthetic_key_unary.lqp create mode 100644 tests/pretty/relations_synthetic_key_unary.lqp create mode 100644 tests/pretty_debug/relations_synthetic_key_unary.lqp diff --git a/sdks/python/tests/test_parser.py b/sdks/python/tests/test_parser.py index 3352dfd9..633f90ad 100644 --- a/sdks/python/tests/test_parser.py +++ b/sdks/python/tests/test_parser.py @@ -127,6 +127,21 @@ def test_synthetic_key_marker(): assert [c.name for c in relations.keys] == ["id"] +def test_synthetic_key_with_unary_keyless_relation(): + # A synthetic key with a single relation that has no value columns: the + # relation holds just the (synthetic) key. + fragment = ( + '(fragment :f (csv_data (csv_locator (paths "x.csv")) (csv_config {}) ' + "(relations (keys synthetic) (relation :keys)) " + '(asof "2025-01-01T00:00:00Z")))' + ) + relations = _relations_of(fragment) + assert relations.synthetic_key is True + assert list(relations.keys) == [] + assert len(relations.plain.targets) == 1 + assert list(relations.plain.targets[0].values) == [] + + def test_synthetic_key_rejects_unknown_marker(): # Only the `synthetic` marker is accepted; anything else is a hard error. with pytest.raises(ParseError): diff --git a/tests/bin/relations_synthetic_key_unary.bin b/tests/bin/relations_synthetic_key_unary.bin new file mode 100644 index 00000000..fb2603ea --- /dev/null +++ b/tests/bin/relations_synthetic_key_unary.bin @@ -0,0 +1,13 @@ + + + + + + +f1e"ca + +s3://bucket/keys.csv",*"2"J.Rutf-8"2025-06-01T00:00:00Z* + + #ySӶDC<'۳  + #ySӶDC<'۳keys +keys #ySӶDC<'۳ \ No newline at end of file diff --git a/tests/lqp/relations_synthetic_key_unary.lqp b/tests/lqp/relations_synthetic_key_unary.lqp new file mode 100644 index 00000000..f7dd38bd --- /dev/null +++ b/tests/lqp/relations_synthetic_key_unary.lqp @@ -0,0 +1,18 @@ +(transaction + (epoch + (writes + (define + (fragment :f1 + ;; Generalized CSV loading with a synthetic (loader-generated) key and a single + ;; unary relation that carries no value columns — the relation holds just the key. + (csv_data + (csv_locator + (paths "s3://bucket/keys.csv")) + (csv_config {}) + (relations + (keys synthetic) + (relation :keys)) + (asof "2025-06-01T00:00:00Z"))))) + + (reads + (output :keys :keys)))) diff --git a/tests/pretty/relations_synthetic_key_unary.lqp b/tests/pretty/relations_synthetic_key_unary.lqp new file mode 100644 index 00000000..fd623546 --- /dev/null +++ b/tests/pretty/relations_synthetic_key_unary.lqp @@ -0,0 +1,22 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes + (define + (fragment + :f1 + (csv_data + (csv_locator (paths "s3://bucket/keys.csv")) + (csv_config + { + :csv_compression "" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\"" + :csv_header_row 1i32 + :csv_quotechar "\"" + :csv_skip 0}) + (relations (keys synthetic) (relation :keys)) + (asof "2025-06-01T00:00:00Z"))))) + (reads (output :keys :keys)))) diff --git a/tests/pretty_debug/relations_synthetic_key_unary.lqp b/tests/pretty_debug/relations_synthetic_key_unary.lqp new file mode 100644 index 00000000..0c562213 --- /dev/null +++ b/tests/pretty_debug/relations_synthetic_key_unary.lqp @@ -0,0 +1,27 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes + (define + (fragment + :f1 + (csv_data + (csv_locator (paths "s3://bucket/keys.csv")) + (csv_config + { + :csv_compression "" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\"" + :csv_header_row 1i32 + :csv_quotechar "\"" + :csv_skip 0}) + (relations (keys synthetic) (relation 0xd382b3db273cff4344b6d39d5379c923)) + (asof "2025-06-01T00:00:00Z"))))) + (reads (output :keys 0xd382b3db273cff4344b6d39d5379c923)))) + +;; Debug information +;; ----------------------- +;; Original names +;; ID `0xd382b3db273cff4344b6d39d5379c923` -> `keys`