From b8064ee0fffcc78c3c1e8a0479d01347bfb1a493 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Tue, 23 Jun 2026 11:36:43 +1000 Subject: [PATCH 1/6] Add transaction output name to the ExportCSVConfig action --- proto/relationalai/lqp/v1/transactions.proto | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/proto/relationalai/lqp/v1/transactions.proto b/proto/relationalai/lqp/v1/transactions.proto index 8c9ce432..81b14a4f 100644 --- a/proto/relationalai/lqp/v1/transactions.proto +++ b/proto/relationalai/lqp/v1/transactions.proto @@ -85,7 +85,13 @@ message Snapshot { // message ExportCSVConfig { + // The following two fields should be in a `oneof`, but compatibility makes that tricky. + // The `path` option should be used if the client needs to output a CSV file to a + // specific location. + // The `transaction_output_name` should be used if the client wants the CSV file to be + // returned as part of the transaction results. string path = 1; + string transaction_output_name = 12; ExportCSVSource csv_source = 10; CSVConfig csv_config = 11; From dfed824de550ff3bf26459f783d74d700765e88f Mon Sep 17 00:00:00 2001 From: David Zhao Date: Tue, 23 Jun 2026 12:13:58 +1000 Subject: [PATCH 2/6] Add transaction_output_name alternative to export_csv_config_v2 Co-Authored-By: Claude Sonnet 4.6 --- meta/src/meta/grammar.y | 27 +++++++++++++++++++------ tests/lqp/export_transaction_output.lqp | 23 +++++++++++++++++++++ 2 files changed, 44 insertions(+), 6 deletions(-) create mode 100644 tests/lqp/export_transaction_output.lqp diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index 7df7da9b..3988a6e1 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -115,6 +115,7 @@ %nonterm export_csv_column transactions.ExportCSVColumn %nonterm export_csv_columns_list Sequence[transactions.ExportCSVColumn] %nonterm export_csv_config transactions.ExportCSVConfig +%nonterm export_csv_output_location Tuple[String, String] %nonterm export_csv_path String %nonterm export_csv_source transactions.ExportCSVSource %nonterm export_iceberg_config transactions.ExportIcebergConfig @@ -1331,10 +1332,10 @@ export $3: transactions.ExportIcebergConfig = $$.iceberg_config export_csv_config - : "(" "export_csv_config_v2" export_csv_path export_csv_source csv_config ")" - construct: $$ = construct_export_csv_config_with_source($3, $4, $5) + : "(" "export_csv_config_v2" export_csv_output_location export_csv_source csv_config ")" + construct: $$ = construct_export_csv_config_with_location($3, $4, $5) deconstruct if builtin.length($$.data_columns) == 0: - $3: String = $$.path + $3: Tuple[String, String] = deconstruct_export_csv_output_location($$) $4: transactions.ExportCSVSource = $$.csv_source $5: logic.CSVConfig = $$.csv_config | "(" "export_csv_config" export_csv_path export_csv_columns_list config_dict ")" @@ -1344,6 +1345,16 @@ export_csv_config $4: Sequence[transactions.ExportCSVColumn] = $$.data_columns $5: Sequence[Tuple[String, logic.Value]] = deconstruct_export_csv_config($$) +export_csv_output_location + : "(" "path" STRING ")" + construct: $$ = builtin.tuple($3, "") + deconstruct if $$[0] != "": + $3: String = $$[0] + | "(" "transaction_output_name" name ")" + construct: $$ = builtin.tuple("", $3) + deconstruct if $$[1] != "": + $3: String = $$[1] + export_csv_path : "(" "path" STRING ")" @@ -1610,13 +1621,17 @@ def construct_export_csv_config( syntax_escapechar=builtin.some(syntax_escapechar), ) -def construct_export_csv_config_with_source( - path: String, +def deconstruct_export_csv_output_location(msg: transactions.ExportCSVConfig) -> Tuple[String, String]: + return (msg.path, msg.transaction_output_name) + +def construct_export_csv_config_with_location( + location: Tuple[String, String], csv_source: transactions.ExportCSVSource, csv_config: logic.CSVConfig, ) -> transactions.ExportCSVConfig: return transactions.ExportCSVConfig( - path=path, + path=location[0], + transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config, ) diff --git a/tests/lqp/export_transaction_output.lqp b/tests/lqp/export_transaction_output.lqp new file mode 100644 index 00000000..ae1d5737 --- /dev/null +++ b/tests/lqp/export_transaction_output.lqp @@ -0,0 +1,23 @@ +(transaction + (epoch + (writes + (define + (fragment :f1 + (def :my_table + ([col1::INT col2::STRING] + (or + (and (= col1 1) (= col2 "hello")) + (and (= col1 2) (= col2 "world")))) + (attrs + (attribute :csv_export)))))) + + (reads + (export + (export_csv_config_v2 + (transaction_output_name :csv_result) + (table_def :my_table) + (csv_config + { :csv_partition_size_mb 10 + :csv_compression "" + :csv_quotechar "\"" + :csv_escapechar "\\" })))))) From 958b356a0d4ece66dc5cbb57467e628258356869 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Tue, 23 Jun 2026 12:14:08 +1000 Subject: [PATCH 3/6] Fix Call.target_type() for variadic builtin.tuple builtin.tuple is registered as variadic (arity -1), so make_builtin gives it an empty param list and the generic type-variable matching can't resolve the return type T. Add a special case that infers TupleType directly from the argument types, matching what _infer_type already does in the parser. Without this, IfElse nodes wrapping tuple constructs were typed as interface{} in Go, causing a compile error when the function's declared return type is []interface{}. Co-Authored-By: Claude Sonnet 4.6 --- meta/src/meta/target.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/meta/src/meta/target.py b/meta/src/meta/target.py index fc0db432..2a4dab69 100644 --- a/meta/src/meta/target.py +++ b/meta/src/meta/target.py @@ -345,6 +345,9 @@ def __post_init__(self): def target_type(self) -> "TargetType": if isinstance(self.func, (ParseNonterminal, PrintNonterminal)): return self.func.target_type() + # builtin.tuple is variadic; infer TupleType from the argument types directly. + if isinstance(self.func, Builtin) and self.func.name == "tuple": + return TupleType(tuple(a.target_type() for a in self.args)) func_type = self.func.target_type() if isinstance(func_type, FunctionType): # Match parameter types against argument types to build type variable mapping From ee4158f992c7fe204d6944c5e7f0092223a9ebc3 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Tue, 23 Jun 2026 12:14:14 +1000 Subject: [PATCH 4/6] Regenerate parsers, printers, and test snapshots Co-Authored-By: Claude Sonnet 4.6 --- sdks/go/src/lqp/v1/transactions.pb.go | 345 +- sdks/go/src/parser.go | 5592 +++++++++-------- sdks/go/src/pretty.go | 3922 ++++++------ .../relationalai/lqp/v1/transactions_pb.jl | 14 +- .../LogicalQueryProtocol.jl/src/parser.jl | 4707 +++++++------- .../LogicalQueryProtocol.jl/src/pretty.jl | 3950 ++++++------ sdks/python/src/lqp/gen/parser.py | 4759 +++++++------- sdks/python/src/lqp/gen/pretty.py | 4461 ++++++------- .../src/lqp/proto/v1/transactions_pb2.py | 52 +- .../src/lqp/proto/v1/transactions_pb2.pyi | 6 +- sdks/python/uv.lock | 2 +- tests/bin/export_transaction_output.bin | Bin 0 -> 384 bytes tests/pretty/export_transaction_output.lqp | 28 + .../export_transaction_output.lqp | 33 + 14 files changed, 14109 insertions(+), 13762 deletions(-) create mode 100644 tests/bin/export_transaction_output.bin create mode 100644 tests/pretty/export_transaction_output.lqp create mode 100644 tests/pretty_debug/export_transaction_output.lqp diff --git a/sdks/go/src/lqp/v1/transactions.pb.go b/sdks/go/src/lqp/v1/transactions.pb.go index b1a0ca1f..04d576e3 100644 --- a/sdks/go/src/lqp/v1/transactions.pb.go +++ b/sdks/go/src/lqp/v1/transactions.pb.go @@ -682,10 +682,16 @@ func (x *Snapshot) GetPrefix() []string { } type ExportCSVConfig struct { - state protoimpl.MessageState `protogen:"open.v1"` - Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` - CsvSource *ExportCSVSource `protobuf:"bytes,10,opt,name=csv_source,json=csvSource,proto3" json:"csv_source,omitempty"` - CsvConfig *CSVConfig `protobuf:"bytes,11,opt,name=csv_config,json=csvConfig,proto3" json:"csv_config,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + // The following two fields should be in a `oneof`, but compatibility makes that tricky. + // The `path` option should be used if the client needs to output a CSV file to a + // specific location. + // The `transaction_output_name` should be used if the client wants the CSV file to be + // returned as part of the transaction results. + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + TransactionOutputName string `protobuf:"bytes,12,opt,name=transaction_output_name,json=transactionOutputName,proto3" json:"transaction_output_name,omitempty"` + CsvSource *ExportCSVSource `protobuf:"bytes,10,opt,name=csv_source,json=csvSource,proto3" json:"csv_source,omitempty"` + CsvConfig *CSVConfig `protobuf:"bytes,11,opt,name=csv_config,json=csvConfig,proto3" json:"csv_config,omitempty"` // Below are all deprecated in favour of the `csv_config` above. DataColumns []*ExportCSVColumn `protobuf:"bytes,2,rep,name=data_columns,json=dataColumns,proto3" json:"data_columns,omitempty"` PartitionSize *int64 `protobuf:"varint,3,opt,name=partition_size,json=partitionSize,proto3,oneof" json:"partition_size,omitempty"` @@ -736,6 +742,13 @@ func (x *ExportCSVConfig) GetPath() string { return "" } +func (x *ExportCSVConfig) GetTransactionOutputName() string { + if x != nil { + return x.TransactionOutputName + } + return "" +} + func (x *ExportCSVConfig) GetCsvSource() *ExportCSVSource { if x != nil { return x.CsvSource @@ -1580,174 +1593,178 @@ var file_relationalai_lqp_v1_transactions_proto_rawDesc = string([]byte{ 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x52, 0x08, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x22, - 0xc8, 0x05, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, + 0x80, 0x06, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x43, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x65, + 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x36, 0x0a, 0x17, 0x74, 0x72, 0x61, 0x6e, 0x73, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x43, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x0a, 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, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, + 0x43, 0x53, 0x56, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x09, 0x63, 0x73, 0x76, 0x53, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x18, 0x0b, 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, 0x09, 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x12, 0x47, 0x0a, 0x0c, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75, + 0x6d, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 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, + 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, + 0x0b, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x2a, 0x0a, 0x0e, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x88, 0x01, 0x01, 0x12, 0x25, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, + 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, + 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x12, + 0x2f, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x48, 0x02, 0x52, 0x0f, 0x73, 0x79, + 0x6e, 0x74, 0x61, 0x78, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x88, 0x01, 0x01, + 0x12, 0x37, 0x0a, 0x15, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, + 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, + 0x03, 0x52, 0x13, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x88, 0x01, 0x01, 0x12, 0x26, 0x0a, 0x0c, 0x73, 0x79, 0x6e, + 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, + 0x04, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x88, 0x01, + 0x01, 0x12, 0x2e, 0x0a, 0x10, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, + 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x48, 0x05, 0x52, 0x0f, 0x73, + 0x79, 0x6e, 0x74, 0x61, 0x78, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, + 0x01, 0x12, 0x30, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, + 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x48, 0x06, 0x52, 0x10, + 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x45, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, + 0x88, 0x01, 0x01, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x72, + 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, + 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x42, 0x18, 0x0a, 0x16, + 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, + 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, + 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x42, 0x13, 0x0a, 0x11, 0x5f, 0x73, 0x79, 0x6e, 0x74, + 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x42, 0x14, 0x0a, 0x12, + 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, + 0x61, 0x72, 0x22, 0x74, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, + 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, + 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, + 0x5f, 0x64, 0x61, 0x74, 0x61, 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, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x53, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x52, 0x09, 0x63, 0x73, 0x76, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x3d, 0x0a, 0x0a, - 0x63, 0x73, 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x0b, 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, 0x09, 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x47, 0x0a, 0x0c, 0x64, - 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 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, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, - 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, - 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x2a, 0x0a, 0x0e, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0d, - 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x88, 0x01, 0x01, - 0x12, 0x25, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, - 0x73, 0x69, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x12, 0x2f, 0x0a, 0x11, 0x73, 0x79, 0x6e, 0x74, 0x61, - 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x08, 0x48, 0x02, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x48, 0x65, 0x61, 0x64, - 0x65, 0x72, 0x52, 0x6f, 0x77, 0x88, 0x01, 0x01, 0x12, 0x37, 0x0a, 0x15, 0x73, 0x79, 0x6e, 0x74, - 0x61, 0x78, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, - 0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x03, 0x52, 0x13, 0x73, 0x79, 0x6e, 0x74, 0x61, - 0x78, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x88, 0x01, - 0x01, 0x12, 0x26, 0x0a, 0x0c, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, - 0x6d, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, 0x04, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x74, 0x61, - 0x78, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x2e, 0x0a, 0x10, 0x73, 0x79, 0x6e, - 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x08, 0x20, - 0x01, 0x28, 0x09, 0x48, 0x05, 0x52, 0x0f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x51, 0x75, 0x6f, - 0x74, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x12, 0x30, 0x0a, 0x11, 0x73, 0x79, 0x6e, - 0x74, 0x61, 0x78, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x18, 0x09, - 0x20, 0x01, 0x28, 0x09, 0x48, 0x06, 0x52, 0x10, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x45, 0x73, - 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x88, 0x01, 0x01, 0x42, 0x11, 0x0a, 0x0f, 0x5f, - 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x0e, - 0x0a, 0x0c, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x14, - 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x5f, 0x72, 0x6f, 0x77, 0x42, 0x18, 0x0a, 0x16, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, - 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x0f, - 0x0a, 0x0d, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x42, - 0x13, 0x0a, 0x11, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, - 0x63, 0x68, 0x61, 0x72, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x5f, - 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x63, 0x68, 0x61, 0x72, 0x22, 0x74, 0x0a, 0x0f, 0x45, 0x78, - 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, - 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x40, - 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61, 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, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61, - 0x22, 0x52, 0x0a, 0x10, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, - 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, - 0x01, 0x20, 0x03, 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, 0x45, 0x78, 0x70, 0x6f, - 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, - 0x75, 0x6d, 0x6e, 0x73, 0x22, 0xa9, 0x01, 0x0a, 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, - 0x53, 0x56, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x48, 0x0a, 0x0b, 0x67, 0x6e, 0x66, 0x5f, - 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, + 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x63, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x22, 0x52, 0x0a, 0x10, 0x45, 0x78, 0x70, 0x6f, + 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x07, + 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 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, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, - 0x75, 0x6d, 0x6e, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x67, 0x6e, 0x66, 0x43, 0x6f, 0x6c, 0x75, 0x6d, - 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x09, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x66, 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, 0x62, 0x6c, 0x65, 0x44, - 0x65, 0x66, 0x42, 0x0c, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x22, 0xa8, 0x04, 0x0a, 0x13, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x49, 0x63, 0x65, 0x62, 0x65, - 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 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, 0x3c, 0x0a, 0x09, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x22, 0xa9, 0x01, 0x0a, + 0x0f, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x12, 0x48, 0x0a, 0x0b, 0x67, 0x6e, 0x66, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, + 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x48, 0x00, 0x52, 0x0a, + 0x67, 0x6e, 0x66, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x3e, 0x0a, 0x09, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x66, 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, 0x52, 0x08, - 0x74, 0x61, 0x62, 0x6c, 0x65, 0x44, 0x65, 0x66, 0x12, 0x1b, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, - 0x69, 0x78, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, - 0x69, 0x78, 0x88, 0x01, 0x01, 0x12, 0x38, 0x0a, 0x16, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, - 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x03, 0x48, 0x01, 0x52, 0x13, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x46, - 0x69, 0x6c, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73, 0x88, 0x01, 0x01, 0x12, - 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x12, 0x68, 0x0a, 0x10, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, - 0x72, 0x74, 0x69, 0x65, 0x73, 0x18, 0x08, 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, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, - 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x1a, 0x42, 0x0a, 0x14, 0x54, - 0x61, 0x62, 0x6c, 0x65, 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, - 0x09, 0x0a, 0x07, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x42, 0x19, 0x0a, 0x17, 0x5f, 0x74, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, - 0x62, 0x79, 0x74, 0x65, 0x73, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x22, 0xa4, 0x02, 0x0a, 0x04, - 0x52, 0x65, 0x61, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, - 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6d, 0x61, 0x6e, - 0x64, 0x48, 0x00, 0x52, 0x06, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x6f, - 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, - 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, - 0x31, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x48, 0x00, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, - 0x75, 0x74, 0x12, 0x36, 0x0a, 0x07, 0x77, 0x68, 0x61, 0x74, 0x5f, 0x69, 0x66, 0x18, 0x03, 0x20, + 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x48, 0x00, + 0x52, 0x08, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x44, 0x65, 0x66, 0x42, 0x0c, 0x0a, 0x0a, 0x63, 0x73, + 0x76, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x22, 0xa8, 0x04, 0x0a, 0x13, 0x45, 0x78, 0x70, + 0x6f, 0x72, 0x74, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 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, 0x3c, 0x0a, 0x09, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x66, 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, 0x52, 0x65, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x08, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x44, 0x65, 0x66, + 0x12, 0x1b, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x48, 0x00, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x88, 0x01, 0x01, 0x12, 0x38, 0x0a, + 0x16, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x69, 0x7a, + 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x48, 0x01, 0x52, + 0x13, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x42, + 0x79, 0x74, 0x65, 0x73, 0x88, 0x01, 0x01, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, + 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, + 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x68, 0x0a, 0x10, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x18, 0x08, 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, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, + 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, + 0x69, 0x65, 0x73, 0x1a, 0x42, 0x0a, 0x14, 0x54, 0x61, 0x62, 0x6c, 0x65, 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, 0x09, 0x0a, 0x07, 0x5f, 0x70, 0x72, 0x65, 0x66, + 0x69, 0x78, 0x42, 0x19, 0x0a, 0x17, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x66, 0x69, + 0x6c, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x4a, 0x04, 0x08, + 0x04, 0x10, 0x05, 0x22, 0xa4, 0x02, 0x0a, 0x04, 0x52, 0x65, 0x61, 0x64, 0x12, 0x35, 0x0a, 0x06, + 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, + 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, + 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x48, 0x00, 0x52, 0x06, 0x64, 0x65, 0x6d, + 0x61, 0x6e, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, - 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, - 0x48, 0x00, 0x52, 0x06, 0x77, 0x68, 0x61, 0x74, 0x49, 0x66, 0x12, 0x32, 0x0a, 0x05, 0x61, 0x62, - 0x6f, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, + 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x48, 0x00, 0x52, 0x06, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x36, 0x0a, 0x07, 0x77, 0x68, + 0x61, 0x74, 0x5f, 0x69, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, + 0x31, 0x2e, 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, 0x48, 0x00, 0x52, 0x06, 0x77, 0x68, 0x61, 0x74, + 0x49, 0x66, 0x12, 0x32, 0x0a, 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, + 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, + 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x12, 0x35, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, + 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x42, 0x0b, 0x0a, + 0x09, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x4a, 0x0a, 0x06, 0x44, 0x65, + 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x69, 0x64, 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, + 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x5e, 0x0a, 0x06, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 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, - 0x41, 0x62, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x05, 0x61, 0x62, 0x6f, 0x72, 0x74, 0x12, 0x35, - 0x0a, 0x06, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, - 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, - 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x06, 0x65, - 0x78, 0x70, 0x6f, 0x72, 0x74, 0x42, 0x0b, 0x0a, 0x09, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x74, 0x79, - 0x70, 0x65, 0x22, 0x4a, 0x0a, 0x06, 0x44, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x40, 0x0a, 0x0b, - 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 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, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x5e, - 0x0a, 0x06, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, - 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0xb3, - 0x01, 0x0a, 0x06, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x45, 0x0a, 0x0a, 0x63, 0x73, 0x76, - 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, + 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0xb3, 0x01, 0x0a, 0x06, 0x45, 0x78, 0x70, 0x6f, 0x72, + 0x74, 0x12, 0x45, 0x0a, 0x0a, 0x63, 0x73, 0x76, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 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, 0x45, 0x78, 0x70, 0x6f, + 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x09, 0x63, + 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x51, 0x0a, 0x0e, 0x69, 0x63, 0x65, 0x62, + 0x65, 0x72, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x28, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, + 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x49, 0x63, 0x65, + 0x62, 0x65, 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x0d, 0x69, 0x63, + 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x65, + 0x78, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x52, 0x0a, 0x06, + 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x30, + 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, - 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x53, 0x56, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x09, 0x63, 0x73, 0x76, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x12, 0x51, 0x0a, 0x0e, 0x69, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x5f, 0x63, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, - 0x78, 0x70, 0x6f, 0x72, 0x74, 0x49, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x48, 0x00, 0x52, 0x0d, 0x69, 0x63, 0x65, 0x62, 0x65, 0x72, 0x67, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x63, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x22, 0x52, 0x0a, 0x06, 0x57, 0x68, 0x61, 0x74, 0x49, 0x66, 0x12, 0x16, - 0x0a, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x30, 0x0a, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x61, 0x6c, 0x61, 0x69, 0x2e, 0x6c, 0x71, 0x70, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x70, 0x6f, 0x63, - 0x68, 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x22, 0x5d, 0x0a, 0x05, 0x41, 0x62, 0x6f, 0x72, - 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 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, 0x52, 0x0a, 0x72, 0x65, 0x6c, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, 0x87, 0x01, 0x0a, 0x10, 0x4d, 0x61, 0x69, 0x6e, - 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x1d, - 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, - 0x4c, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, - 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, - 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x4f, 0x46, 0x46, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x4d, 0x41, - 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, - 0x41, 0x55, 0x54, 0x4f, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, - 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x4c, 0x4c, 0x10, - 0x03, 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, + 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x05, 0x65, 0x70, 0x6f, 0x63, 0x68, + 0x22, 0x5d, 0x0a, 0x05, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x40, 0x0a, + 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 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, 0x52, 0x0a, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, + 0x87, 0x01, 0x0a, 0x10, 0x4d, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x4c, + 0x65, 0x76, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x1d, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, + 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, + 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, + 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x4f, 0x46, 0x46, + 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, + 0x45, 0x5f, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x55, 0x54, 0x4f, 0x10, 0x02, 0x12, 0x19, + 0x0a, 0x15, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4c, 0x45, + 0x56, 0x45, 0x4c, 0x5f, 0x41, 0x4c, 0x4c, 0x10, 0x03, 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 a5962189..74e77ca3 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -655,170 +655,170 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t2101 interface{} + var _t2113 interface{} if (value != nil && hasProtoField(value, "int32_value")) { return value.GetInt32Value() } - _ = _t2101 + _ = _t2113 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t2102 interface{} + var _t2114 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2102 + _ = _t2114 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t2103 interface{} + var _t2115 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2103 + _ = _t2115 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t2104 interface{} + var _t2116 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2104 + _ = _t2116 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t2105 interface{} + var _t2117 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2105 + _ = _t2117 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t2106 interface{} + var _t2118 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2106 + _ = _t2118 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t2107 interface{} + var _t2119 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2107 + _ = _t2119 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t2108 interface{} + var _t2120 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2108 + _ = _t2120 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t2109 interface{} + var _t2121 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2109 + _ = _t2121 return nil } func (p *Parser) construct_csv_config(config_dict [][]interface{}, storage_integration_opt [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) - _t2110 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2110 - _t2111 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2111 - _t2112 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2112 - _t2113 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2113 - _t2114 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2114 - _t2115 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2115 - _t2116 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2116 - _t2117 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2117 - _t2118 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2118 - _t2119 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2119 - _t2120 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") - compression := _t2120 - _t2121 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2121 - _t2122 := p.construct_csv_storage_integration(storage_integration_opt) - storage_integration := _t2122 - _t2123 := &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 _t2123 + _t2122 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t2122 + _t2123 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t2123 + _t2124 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t2124 + _t2125 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t2125 + _t2126 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t2126 + _t2127 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t2127 + _t2128 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t2128 + _t2129 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t2129 + _t2130 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t2130 + _t2131 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t2131 + _t2132 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") + compression := _t2132 + _t2133 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) + partition_size_mb := _t2133 + _t2134 := p.construct_csv_storage_integration(storage_integration_opt) + storage_integration := _t2134 + _t2135 := &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 _t2135 } func (p *Parser) construct_csv_storage_integration(storage_integration_opt [][]interface{}) *pb.StorageIntegration { - var _t2124 interface{} + var _t2136 interface{} if storage_integration_opt == nil { return nil } - _ = _t2124 + _ = _t2136 config := dictFromList(storage_integration_opt) - _t2125 := p._extract_value_string(dictGetValue(config, "provider"), "") - _t2126 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") - _t2127 := p._extract_value_string(dictGetValue(config, "s3_region"), "") - _t2128 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") - _t2129 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") - _t2130 := &pb.StorageIntegration{Provider: _t2125, AzureSasToken: _t2126, S3Region: _t2127, S3AccessKeyId: _t2128, S3SecretAccessKey: _t2129} - return _t2130 + _t2137 := p._extract_value_string(dictGetValue(config, "provider"), "") + _t2138 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") + _t2139 := p._extract_value_string(dictGetValue(config, "s3_region"), "") + _t2140 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") + _t2141 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") + _t2142 := &pb.StorageIntegration{Provider: _t2137, AzureSasToken: _t2138, S3Region: _t2139, S3AccessKeyId: _t2140, S3SecretAccessKey: _t2141} + return _t2142 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) - _t2131 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2131 - _t2132 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2132 - _t2133 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2133 - _t2134 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2134 - _t2135 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2135 - _t2136 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2136 - _t2137 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2137 - _t2138 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2138 - _t2139 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2139 - _t2140 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t2143 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t2143 + _t2144 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t2144 + _t2145 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t2145 + _t2146 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t2146 + _t2147 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t2147 + _t2148 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t2148 + _t2149 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t2149 + _t2150 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t2150 + _t2151 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t2151 + _t2152 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t2140.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t2152.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t2140.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t2152.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t2140 - _t2141 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2141 + relation_locator := _t2152 + _t2153 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t2153 } func (p *Parser) default_configure() *pb.Configure { - _t2142 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2142 - _t2143 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2143 + _t2154 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t2154 + _t2155 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t2155 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -840,4274 +840,4318 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _t2144 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2144 - _t2145 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2145 - _t2146 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t2146 + _t2156 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t2156 + _t2157 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t2157 + _t2158 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t2158 } func (p *Parser) construct_export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) - _t2147 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2147 - _t2148 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2148 - _t2149 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2149 - _t2150 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2150 - _t2151 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2151 - _t2152 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2152 - _t2153 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2153 - _t2154 := &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 _t2154 -} - -func (p *Parser) construct_export_csv_config_with_source(path string, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2155 := &pb.ExportCSVConfig{Path: path, CsvSource: csv_source, CsvConfig: csv_config} - return _t2155 + _t2159 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t2159 + _t2160 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t2160 + _t2161 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t2161 + _t2162 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t2162 + _t2163 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t2163 + _t2164 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t2164 + _t2165 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t2165 + _t2166 := &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 _t2166 +} + +func (p *Parser) construct_export_csv_config_with_location(location []interface{}, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { + _t2167 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} + return _t2167 } 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) - _t2156 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2156 + _t2168 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} + return _t2168 } 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 { - _t2157 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2157 + _t2169 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} + return _t2169 } 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 { - _t2158 := config_dict + _t2170 := config_dict if config_dict == nil { - _t2158 = [][]interface{}{} - } - cfg := dictFromList(_t2158) - _t2159 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2159 - _t2160 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2160 - _t2161 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2161 + _t2170 = [][]interface{}{} + } + cfg := dictFromList(_t2170) + _t2171 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") + prefix := _t2171 + _t2172 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) + target_file_size_bytes := _t2172 + _t2173 := p._extract_value_string(dictGetValue(cfg, "compression"), "") + compression := _t2173 table_props := stringMapFromPairs(table_property_pairs) - _t2162 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2162 + _t2174 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} + return _t2174 } // --- Parse functions --- func (p *Parser) parse_transaction() *pb.Transaction { - span_start673 := int64(p.spanStart()) + span_start676 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t1334 *pb.Configure + var _t1340 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t1335 := p.parse_configure() - _t1334 = _t1335 + _t1341 := p.parse_configure() + _t1340 = _t1341 } - configure667 := _t1334 - var _t1336 *pb.Sync + configure670 := _t1340 + var _t1342 *pb.Sync if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t1337 := p.parse_sync() - _t1336 = _t1337 - } - sync668 := _t1336 - xs669 := []*pb.Epoch{} - cond670 := p.matchLookaheadLiteral("(", 0) - for cond670 { - _t1338 := p.parse_epoch() - item671 := _t1338 - xs669 = append(xs669, item671) - cond670 = p.matchLookaheadLiteral("(", 0) - } - epochs672 := xs669 + _t1343 := p.parse_sync() + _t1342 = _t1343 + } + sync671 := _t1342 + xs672 := []*pb.Epoch{} + cond673 := p.matchLookaheadLiteral("(", 0) + for cond673 { + _t1344 := p.parse_epoch() + item674 := _t1344 + xs672 = append(xs672, item674) + cond673 = p.matchLookaheadLiteral("(", 0) + } + epochs675 := xs672 p.consumeLiteral(")") - _t1339 := p.default_configure() - _t1340 := configure667 - if configure667 == nil { - _t1340 = _t1339 - } - _t1341 := &pb.Transaction{Epochs: epochs672, Configure: _t1340, Sync: sync668} - result674 := _t1341 - p.recordSpan(int(span_start673), "Transaction") - return result674 + _t1345 := p.default_configure() + _t1346 := configure670 + if configure670 == nil { + _t1346 = _t1345 + } + _t1347 := &pb.Transaction{Epochs: epochs675, Configure: _t1346, Sync: sync671} + result677 := _t1347 + p.recordSpan(int(span_start676), "Transaction") + return result677 } func (p *Parser) parse_configure() *pb.Configure { - span_start676 := int64(p.spanStart()) + span_start679 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("configure") - _t1342 := p.parse_config_dict() - config_dict675 := _t1342 + _t1348 := p.parse_config_dict() + config_dict678 := _t1348 p.consumeLiteral(")") - _t1343 := p.construct_configure(config_dict675) - result677 := _t1343 - p.recordSpan(int(span_start676), "Configure") - return result677 + _t1349 := p.construct_configure(config_dict678) + result680 := _t1349 + p.recordSpan(int(span_start679), "Configure") + return result680 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") - xs678 := [][]interface{}{} - cond679 := p.matchLookaheadLiteral(":", 0) - for cond679 { - _t1344 := p.parse_config_key_value() - item680 := _t1344 - xs678 = append(xs678, item680) - cond679 = p.matchLookaheadLiteral(":", 0) - } - config_key_values681 := xs678 + xs681 := [][]interface{}{} + cond682 := p.matchLookaheadLiteral(":", 0) + for cond682 { + _t1350 := p.parse_config_key_value() + item683 := _t1350 + xs681 = append(xs681, item683) + cond682 = p.matchLookaheadLiteral(":", 0) + } + config_key_values684 := xs681 p.consumeLiteral("}") - return config_key_values681 + return config_key_values684 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - symbol682 := p.consumeTerminal("SYMBOL").Value.str - _t1345 := p.parse_raw_value() - raw_value683 := _t1345 - return []interface{}{symbol682, raw_value683} + symbol685 := p.consumeTerminal("SYMBOL").Value.str + _t1351 := p.parse_raw_value() + raw_value686 := _t1351 + return []interface{}{symbol685, raw_value686} } func (p *Parser) parse_raw_value() *pb.Value { - span_start697 := int64(p.spanStart()) - var _t1346 int64 + span_start700 := int64(p.spanStart()) + var _t1352 int64 if p.matchLookaheadLiteral("true", 0) { - _t1346 = 12 + _t1352 = 12 } else { - var _t1347 int64 + var _t1353 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1347 = 11 + _t1353 = 11 } else { - var _t1348 int64 + var _t1354 int64 if p.matchLookaheadLiteral("false", 0) { - _t1348 = 12 + _t1354 = 12 } else { - var _t1349 int64 + var _t1355 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1350 int64 + var _t1356 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1350 = 1 + _t1356 = 1 } else { - var _t1351 int64 + var _t1357 int64 if p.matchLookaheadLiteral("date", 1) { - _t1351 = 0 + _t1357 = 0 } else { - _t1351 = -1 + _t1357 = -1 } - _t1350 = _t1351 + _t1356 = _t1357 } - _t1349 = _t1350 + _t1355 = _t1356 } else { - var _t1352 int64 + var _t1358 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1352 = 7 + _t1358 = 7 } else { - var _t1353 int64 + var _t1359 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1353 = 8 + _t1359 = 8 } else { - var _t1354 int64 + var _t1360 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1354 = 2 + _t1360 = 2 } else { - var _t1355 int64 + var _t1361 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1355 = 3 + _t1361 = 3 } else { - var _t1356 int64 + var _t1362 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1356 = 9 + _t1362 = 9 } else { - var _t1357 int64 + var _t1363 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1357 = 4 + _t1363 = 4 } else { - var _t1358 int64 + var _t1364 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1358 = 5 + _t1364 = 5 } else { - var _t1359 int64 + var _t1365 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1359 = 6 + _t1365 = 6 } else { - var _t1360 int64 + var _t1366 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1360 = 10 + _t1366 = 10 } else { - _t1360 = -1 + _t1366 = -1 } - _t1359 = _t1360 + _t1365 = _t1366 } - _t1358 = _t1359 + _t1364 = _t1365 } - _t1357 = _t1358 + _t1363 = _t1364 } - _t1356 = _t1357 + _t1362 = _t1363 } - _t1355 = _t1356 + _t1361 = _t1362 } - _t1354 = _t1355 + _t1360 = _t1361 } - _t1353 = _t1354 + _t1359 = _t1360 } - _t1352 = _t1353 + _t1358 = _t1359 } - _t1349 = _t1352 + _t1355 = _t1358 } - _t1348 = _t1349 + _t1354 = _t1355 } - _t1347 = _t1348 + _t1353 = _t1354 } - _t1346 = _t1347 - } - prediction684 := _t1346 - var _t1361 *pb.Value - if prediction684 == 12 { - _t1362 := p.parse_boolean_value() - boolean_value696 := _t1362 - _t1363 := &pb.Value{} - _t1363.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value696} - _t1361 = _t1363 + _t1352 = _t1353 + } + prediction687 := _t1352 + var _t1367 *pb.Value + if prediction687 == 12 { + _t1368 := p.parse_boolean_value() + boolean_value699 := _t1368 + _t1369 := &pb.Value{} + _t1369.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value699} + _t1367 = _t1369 } else { - var _t1364 *pb.Value - if prediction684 == 11 { + var _t1370 *pb.Value + if prediction687 == 11 { p.consumeLiteral("missing") - _t1365 := &pb.MissingValue{} - _t1366 := &pb.Value{} - _t1366.Value = &pb.Value_MissingValue{MissingValue: _t1365} - _t1364 = _t1366 + _t1371 := &pb.MissingValue{} + _t1372 := &pb.Value{} + _t1372.Value = &pb.Value_MissingValue{MissingValue: _t1371} + _t1370 = _t1372 } else { - var _t1367 *pb.Value - if prediction684 == 10 { - decimal695 := p.consumeTerminal("DECIMAL").Value.decimal - _t1368 := &pb.Value{} - _t1368.Value = &pb.Value_DecimalValue{DecimalValue: decimal695} - _t1367 = _t1368 + var _t1373 *pb.Value + if prediction687 == 10 { + decimal698 := p.consumeTerminal("DECIMAL").Value.decimal + _t1374 := &pb.Value{} + _t1374.Value = &pb.Value_DecimalValue{DecimalValue: decimal698} + _t1373 = _t1374 } else { - var _t1369 *pb.Value - if prediction684 == 9 { - int128694 := p.consumeTerminal("INT128").Value.int128 - _t1370 := &pb.Value{} - _t1370.Value = &pb.Value_Int128Value{Int128Value: int128694} - _t1369 = _t1370 + var _t1375 *pb.Value + if prediction687 == 9 { + int128697 := p.consumeTerminal("INT128").Value.int128 + _t1376 := &pb.Value{} + _t1376.Value = &pb.Value_Int128Value{Int128Value: int128697} + _t1375 = _t1376 } else { - var _t1371 *pb.Value - if prediction684 == 8 { - uint128693 := p.consumeTerminal("UINT128").Value.uint128 - _t1372 := &pb.Value{} - _t1372.Value = &pb.Value_Uint128Value{Uint128Value: uint128693} - _t1371 = _t1372 + var _t1377 *pb.Value + if prediction687 == 8 { + uint128696 := p.consumeTerminal("UINT128").Value.uint128 + _t1378 := &pb.Value{} + _t1378.Value = &pb.Value_Uint128Value{Uint128Value: uint128696} + _t1377 = _t1378 } else { - var _t1373 *pb.Value - if prediction684 == 7 { - uint32692 := p.consumeTerminal("UINT32").Value.u32 - _t1374 := &pb.Value{} - _t1374.Value = &pb.Value_Uint32Value{Uint32Value: uint32692} - _t1373 = _t1374 + var _t1379 *pb.Value + if prediction687 == 7 { + uint32695 := p.consumeTerminal("UINT32").Value.u32 + _t1380 := &pb.Value{} + _t1380.Value = &pb.Value_Uint32Value{Uint32Value: uint32695} + _t1379 = _t1380 } else { - var _t1375 *pb.Value - if prediction684 == 6 { - float691 := p.consumeTerminal("FLOAT").Value.f64 - _t1376 := &pb.Value{} - _t1376.Value = &pb.Value_FloatValue{FloatValue: float691} - _t1375 = _t1376 + var _t1381 *pb.Value + if prediction687 == 6 { + float694 := p.consumeTerminal("FLOAT").Value.f64 + _t1382 := &pb.Value{} + _t1382.Value = &pb.Value_FloatValue{FloatValue: float694} + _t1381 = _t1382 } else { - var _t1377 *pb.Value - if prediction684 == 5 { - float32690 := p.consumeTerminal("FLOAT32").Value.f32 - _t1378 := &pb.Value{} - _t1378.Value = &pb.Value_Float32Value{Float32Value: float32690} - _t1377 = _t1378 + var _t1383 *pb.Value + if prediction687 == 5 { + float32693 := p.consumeTerminal("FLOAT32").Value.f32 + _t1384 := &pb.Value{} + _t1384.Value = &pb.Value_Float32Value{Float32Value: float32693} + _t1383 = _t1384 } else { - var _t1379 *pb.Value - if prediction684 == 4 { - int689 := p.consumeTerminal("INT").Value.i64 - _t1380 := &pb.Value{} - _t1380.Value = &pb.Value_IntValue{IntValue: int689} - _t1379 = _t1380 + var _t1385 *pb.Value + if prediction687 == 4 { + int692 := p.consumeTerminal("INT").Value.i64 + _t1386 := &pb.Value{} + _t1386.Value = &pb.Value_IntValue{IntValue: int692} + _t1385 = _t1386 } else { - var _t1381 *pb.Value - if prediction684 == 3 { - int32688 := p.consumeTerminal("INT32").Value.i32 - _t1382 := &pb.Value{} - _t1382.Value = &pb.Value_Int32Value{Int32Value: int32688} - _t1381 = _t1382 + var _t1387 *pb.Value + if prediction687 == 3 { + int32691 := p.consumeTerminal("INT32").Value.i32 + _t1388 := &pb.Value{} + _t1388.Value = &pb.Value_Int32Value{Int32Value: int32691} + _t1387 = _t1388 } else { - var _t1383 *pb.Value - if prediction684 == 2 { - string687 := p.consumeTerminal("STRING").Value.str - _t1384 := &pb.Value{} - _t1384.Value = &pb.Value_StringValue{StringValue: string687} - _t1383 = _t1384 + var _t1389 *pb.Value + if prediction687 == 2 { + string690 := p.consumeTerminal("STRING").Value.str + _t1390 := &pb.Value{} + _t1390.Value = &pb.Value_StringValue{StringValue: string690} + _t1389 = _t1390 } else { - var _t1385 *pb.Value - if prediction684 == 1 { - _t1386 := p.parse_raw_datetime() - raw_datetime686 := _t1386 - _t1387 := &pb.Value{} - _t1387.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime686} - _t1385 = _t1387 + var _t1391 *pb.Value + if prediction687 == 1 { + _t1392 := p.parse_raw_datetime() + raw_datetime689 := _t1392 + _t1393 := &pb.Value{} + _t1393.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime689} + _t1391 = _t1393 } else { - var _t1388 *pb.Value - if prediction684 == 0 { - _t1389 := p.parse_raw_date() - raw_date685 := _t1389 - _t1390 := &pb.Value{} - _t1390.Value = &pb.Value_DateValue{DateValue: raw_date685} - _t1388 = _t1390 + var _t1394 *pb.Value + if prediction687 == 0 { + _t1395 := p.parse_raw_date() + raw_date688 := _t1395 + _t1396 := &pb.Value{} + _t1396.Value = &pb.Value_DateValue{DateValue: raw_date688} + _t1394 = _t1396 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in raw_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1385 = _t1388 + _t1391 = _t1394 } - _t1383 = _t1385 + _t1389 = _t1391 } - _t1381 = _t1383 + _t1387 = _t1389 } - _t1379 = _t1381 + _t1385 = _t1387 } - _t1377 = _t1379 + _t1383 = _t1385 } - _t1375 = _t1377 + _t1381 = _t1383 } - _t1373 = _t1375 + _t1379 = _t1381 } - _t1371 = _t1373 + _t1377 = _t1379 } - _t1369 = _t1371 + _t1375 = _t1377 } - _t1367 = _t1369 + _t1373 = _t1375 } - _t1364 = _t1367 + _t1370 = _t1373 } - _t1361 = _t1364 + _t1367 = _t1370 } - result698 := _t1361 - p.recordSpan(int(span_start697), "Value") - return result698 + result701 := _t1367 + p.recordSpan(int(span_start700), "Value") + return result701 } func (p *Parser) parse_raw_date() *pb.DateValue { - span_start702 := int64(p.spanStart()) + span_start705 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - int699 := p.consumeTerminal("INT").Value.i64 - int_3700 := p.consumeTerminal("INT").Value.i64 - int_4701 := p.consumeTerminal("INT").Value.i64 + int702 := p.consumeTerminal("INT").Value.i64 + int_3703 := p.consumeTerminal("INT").Value.i64 + int_4704 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1391 := &pb.DateValue{Year: int32(int699), Month: int32(int_3700), Day: int32(int_4701)} - result703 := _t1391 - p.recordSpan(int(span_start702), "DateValue") - return result703 + _t1397 := &pb.DateValue{Year: int32(int702), Month: int32(int_3703), Day: int32(int_4704)} + result706 := _t1397 + p.recordSpan(int(span_start705), "DateValue") + return result706 } func (p *Parser) parse_raw_datetime() *pb.DateTimeValue { - span_start711 := int64(p.spanStart()) + span_start714 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - int704 := p.consumeTerminal("INT").Value.i64 - int_3705 := p.consumeTerminal("INT").Value.i64 - int_4706 := p.consumeTerminal("INT").Value.i64 - int_5707 := p.consumeTerminal("INT").Value.i64 - int_6708 := p.consumeTerminal("INT").Value.i64 - int_7709 := p.consumeTerminal("INT").Value.i64 - var _t1392 *int64 + int707 := p.consumeTerminal("INT").Value.i64 + int_3708 := p.consumeTerminal("INT").Value.i64 + int_4709 := p.consumeTerminal("INT").Value.i64 + int_5710 := p.consumeTerminal("INT").Value.i64 + int_6711 := p.consumeTerminal("INT").Value.i64 + int_7712 := p.consumeTerminal("INT").Value.i64 + var _t1398 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1392 = ptr(p.consumeTerminal("INT").Value.i64) + _t1398 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8710 := _t1392 + int_8713 := _t1398 p.consumeLiteral(")") - _t1393 := &pb.DateTimeValue{Year: int32(int704), Month: int32(int_3705), Day: int32(int_4706), Hour: int32(int_5707), Minute: int32(int_6708), Second: int32(int_7709), Microsecond: int32(deref(int_8710, 0))} - result712 := _t1393 - p.recordSpan(int(span_start711), "DateTimeValue") - return result712 + _t1399 := &pb.DateTimeValue{Year: int32(int707), Month: int32(int_3708), Day: int32(int_4709), Hour: int32(int_5710), Minute: int32(int_6711), Second: int32(int_7712), Microsecond: int32(deref(int_8713, 0))} + result715 := _t1399 + p.recordSpan(int(span_start714), "DateTimeValue") + return result715 } func (p *Parser) parse_boolean_value() bool { - var _t1394 int64 + var _t1400 int64 if p.matchLookaheadLiteral("true", 0) { - _t1394 = 0 + _t1400 = 0 } else { - var _t1395 int64 + var _t1401 int64 if p.matchLookaheadLiteral("false", 0) { - _t1395 = 1 + _t1401 = 1 } else { - _t1395 = -1 + _t1401 = -1 } - _t1394 = _t1395 + _t1400 = _t1401 } - prediction713 := _t1394 - var _t1396 bool - if prediction713 == 1 { + prediction716 := _t1400 + var _t1402 bool + if prediction716 == 1 { p.consumeLiteral("false") - _t1396 = false + _t1402 = false } else { - var _t1397 bool - if prediction713 == 0 { + var _t1403 bool + if prediction716 == 0 { p.consumeLiteral("true") - _t1397 = true + _t1403 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1396 = _t1397 + _t1402 = _t1403 } - return _t1396 + return _t1402 } func (p *Parser) parse_sync() *pb.Sync { - span_start718 := int64(p.spanStart()) + span_start721 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sync") - xs714 := []*pb.FragmentId{} - cond715 := p.matchLookaheadLiteral(":", 0) - for cond715 { - _t1398 := p.parse_fragment_id() - item716 := _t1398 - xs714 = append(xs714, item716) - cond715 = p.matchLookaheadLiteral(":", 0) - } - fragment_ids717 := xs714 + xs717 := []*pb.FragmentId{} + cond718 := p.matchLookaheadLiteral(":", 0) + for cond718 { + _t1404 := p.parse_fragment_id() + item719 := _t1404 + xs717 = append(xs717, item719) + cond718 = p.matchLookaheadLiteral(":", 0) + } + fragment_ids720 := xs717 p.consumeLiteral(")") - _t1399 := &pb.Sync{Fragments: fragment_ids717} - result719 := _t1399 - p.recordSpan(int(span_start718), "Sync") - return result719 + _t1405 := &pb.Sync{Fragments: fragment_ids720} + result722 := _t1405 + p.recordSpan(int(span_start721), "Sync") + return result722 } func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start721 := int64(p.spanStart()) + span_start724 := int64(p.spanStart()) p.consumeLiteral(":") - symbol720 := p.consumeTerminal("SYMBOL").Value.str - result722 := &pb.FragmentId{Id: []byte(symbol720)} - p.recordSpan(int(span_start721), "FragmentId") - return result722 + symbol723 := p.consumeTerminal("SYMBOL").Value.str + result725 := &pb.FragmentId{Id: []byte(symbol723)} + p.recordSpan(int(span_start724), "FragmentId") + return result725 } func (p *Parser) parse_epoch() *pb.Epoch { - span_start725 := int64(p.spanStart()) + span_start728 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t1400 []*pb.Write + var _t1406 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t1401 := p.parse_epoch_writes() - _t1400 = _t1401 + _t1407 := p.parse_epoch_writes() + _t1406 = _t1407 } - epoch_writes723 := _t1400 - var _t1402 []*pb.Read + epoch_writes726 := _t1406 + var _t1408 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t1403 := p.parse_epoch_reads() - _t1402 = _t1403 + _t1409 := p.parse_epoch_reads() + _t1408 = _t1409 } - epoch_reads724 := _t1402 + epoch_reads727 := _t1408 p.consumeLiteral(")") - _t1404 := epoch_writes723 - if epoch_writes723 == nil { - _t1404 = []*pb.Write{} + _t1410 := epoch_writes726 + if epoch_writes726 == nil { + _t1410 = []*pb.Write{} } - _t1405 := epoch_reads724 - if epoch_reads724 == nil { - _t1405 = []*pb.Read{} + _t1411 := epoch_reads727 + if epoch_reads727 == nil { + _t1411 = []*pb.Read{} } - _t1406 := &pb.Epoch{Writes: _t1404, Reads: _t1405} - result726 := _t1406 - p.recordSpan(int(span_start725), "Epoch") - return result726 + _t1412 := &pb.Epoch{Writes: _t1410, Reads: _t1411} + result729 := _t1412 + p.recordSpan(int(span_start728), "Epoch") + return result729 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") - xs727 := []*pb.Write{} - cond728 := p.matchLookaheadLiteral("(", 0) - for cond728 { - _t1407 := p.parse_write() - item729 := _t1407 - xs727 = append(xs727, item729) - cond728 = p.matchLookaheadLiteral("(", 0) - } - writes730 := xs727 + xs730 := []*pb.Write{} + cond731 := p.matchLookaheadLiteral("(", 0) + for cond731 { + _t1413 := p.parse_write() + item732 := _t1413 + xs730 = append(xs730, item732) + cond731 = p.matchLookaheadLiteral("(", 0) + } + writes733 := xs730 p.consumeLiteral(")") - return writes730 + return writes733 } func (p *Parser) parse_write() *pb.Write { - span_start736 := int64(p.spanStart()) - var _t1408 int64 + span_start739 := int64(p.spanStart()) + var _t1414 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1409 int64 + var _t1415 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t1409 = 1 + _t1415 = 1 } else { - var _t1410 int64 + var _t1416 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t1410 = 3 + _t1416 = 3 } else { - var _t1411 int64 + var _t1417 int64 if p.matchLookaheadLiteral("define", 1) { - _t1411 = 0 + _t1417 = 0 } else { - var _t1412 int64 + var _t1418 int64 if p.matchLookaheadLiteral("context", 1) { - _t1412 = 2 + _t1418 = 2 } else { - _t1412 = -1 + _t1418 = -1 } - _t1411 = _t1412 + _t1417 = _t1418 } - _t1410 = _t1411 + _t1416 = _t1417 } - _t1409 = _t1410 + _t1415 = _t1416 } - _t1408 = _t1409 + _t1414 = _t1415 } else { - _t1408 = -1 - } - prediction731 := _t1408 - var _t1413 *pb.Write - if prediction731 == 3 { - _t1414 := p.parse_snapshot() - snapshot735 := _t1414 - _t1415 := &pb.Write{} - _t1415.WriteType = &pb.Write_Snapshot{Snapshot: snapshot735} - _t1413 = _t1415 + _t1414 = -1 + } + prediction734 := _t1414 + var _t1419 *pb.Write + if prediction734 == 3 { + _t1420 := p.parse_snapshot() + snapshot738 := _t1420 + _t1421 := &pb.Write{} + _t1421.WriteType = &pb.Write_Snapshot{Snapshot: snapshot738} + _t1419 = _t1421 } else { - var _t1416 *pb.Write - if prediction731 == 2 { - _t1417 := p.parse_context() - context734 := _t1417 - _t1418 := &pb.Write{} - _t1418.WriteType = &pb.Write_Context{Context: context734} - _t1416 = _t1418 + var _t1422 *pb.Write + if prediction734 == 2 { + _t1423 := p.parse_context() + context737 := _t1423 + _t1424 := &pb.Write{} + _t1424.WriteType = &pb.Write_Context{Context: context737} + _t1422 = _t1424 } else { - var _t1419 *pb.Write - if prediction731 == 1 { - _t1420 := p.parse_undefine() - undefine733 := _t1420 - _t1421 := &pb.Write{} - _t1421.WriteType = &pb.Write_Undefine{Undefine: undefine733} - _t1419 = _t1421 + var _t1425 *pb.Write + if prediction734 == 1 { + _t1426 := p.parse_undefine() + undefine736 := _t1426 + _t1427 := &pb.Write{} + _t1427.WriteType = &pb.Write_Undefine{Undefine: undefine736} + _t1425 = _t1427 } else { - var _t1422 *pb.Write - if prediction731 == 0 { - _t1423 := p.parse_define() - define732 := _t1423 - _t1424 := &pb.Write{} - _t1424.WriteType = &pb.Write_Define{Define: define732} - _t1422 = _t1424 + var _t1428 *pb.Write + if prediction734 == 0 { + _t1429 := p.parse_define() + define735 := _t1429 + _t1430 := &pb.Write{} + _t1430.WriteType = &pb.Write_Define{Define: define735} + _t1428 = _t1430 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1419 = _t1422 + _t1425 = _t1428 } - _t1416 = _t1419 + _t1422 = _t1425 } - _t1413 = _t1416 + _t1419 = _t1422 } - result737 := _t1413 - p.recordSpan(int(span_start736), "Write") - return result737 + result740 := _t1419 + p.recordSpan(int(span_start739), "Write") + return result740 } func (p *Parser) parse_define() *pb.Define { - span_start739 := int64(p.spanStart()) + span_start742 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("define") - _t1425 := p.parse_fragment() - fragment738 := _t1425 + _t1431 := p.parse_fragment() + fragment741 := _t1431 p.consumeLiteral(")") - _t1426 := &pb.Define{Fragment: fragment738} - result740 := _t1426 - p.recordSpan(int(span_start739), "Define") - return result740 + _t1432 := &pb.Define{Fragment: fragment741} + result743 := _t1432 + p.recordSpan(int(span_start742), "Define") + return result743 } func (p *Parser) parse_fragment() *pb.Fragment { - span_start746 := int64(p.spanStart()) + span_start749 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("fragment") - _t1427 := p.parse_new_fragment_id() - new_fragment_id741 := _t1427 - xs742 := []*pb.Declaration{} - cond743 := p.matchLookaheadLiteral("(", 0) - for cond743 { - _t1428 := p.parse_declaration() - item744 := _t1428 - xs742 = append(xs742, item744) - cond743 = p.matchLookaheadLiteral("(", 0) - } - declarations745 := xs742 + _t1433 := p.parse_new_fragment_id() + new_fragment_id744 := _t1433 + xs745 := []*pb.Declaration{} + cond746 := p.matchLookaheadLiteral("(", 0) + for cond746 { + _t1434 := p.parse_declaration() + item747 := _t1434 + xs745 = append(xs745, item747) + cond746 = p.matchLookaheadLiteral("(", 0) + } + declarations748 := xs745 p.consumeLiteral(")") - result747 := p.constructFragment(new_fragment_id741, declarations745) - p.recordSpan(int(span_start746), "Fragment") - return result747 + result750 := p.constructFragment(new_fragment_id744, declarations748) + p.recordSpan(int(span_start749), "Fragment") + return result750 } func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - span_start749 := int64(p.spanStart()) - _t1429 := p.parse_fragment_id() - fragment_id748 := _t1429 - p.startFragment(fragment_id748) - result750 := fragment_id748 - p.recordSpan(int(span_start749), "FragmentId") - return result750 + span_start752 := int64(p.spanStart()) + _t1435 := p.parse_fragment_id() + fragment_id751 := _t1435 + p.startFragment(fragment_id751) + result753 := fragment_id751 + p.recordSpan(int(span_start752), "FragmentId") + return result753 } func (p *Parser) parse_declaration() *pb.Declaration { - span_start756 := int64(p.spanStart()) - var _t1430 int64 + span_start759 := int64(p.spanStart()) + var _t1436 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1431 int64 + var _t1437 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1431 = 3 + _t1437 = 3 } else { - var _t1432 int64 + var _t1438 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1432 = 2 + _t1438 = 2 } else { - var _t1433 int64 + var _t1439 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1433 = 3 + _t1439 = 3 } else { - var _t1434 int64 + var _t1440 int64 if p.matchLookaheadLiteral("def", 1) { - _t1434 = 0 + _t1440 = 0 } else { - var _t1435 int64 + var _t1441 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1435 = 3 + _t1441 = 3 } else { - var _t1436 int64 + var _t1442 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1436 = 3 + _t1442 = 3 } else { - var _t1437 int64 + var _t1443 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t1437 = 1 + _t1443 = 1 } else { - _t1437 = -1 + _t1443 = -1 } - _t1436 = _t1437 + _t1442 = _t1443 } - _t1435 = _t1436 + _t1441 = _t1442 } - _t1434 = _t1435 + _t1440 = _t1441 } - _t1433 = _t1434 + _t1439 = _t1440 } - _t1432 = _t1433 + _t1438 = _t1439 } - _t1431 = _t1432 + _t1437 = _t1438 } - _t1430 = _t1431 + _t1436 = _t1437 } else { - _t1430 = -1 - } - prediction751 := _t1430 - var _t1438 *pb.Declaration - if prediction751 == 3 { - _t1439 := p.parse_data() - data755 := _t1439 - _t1440 := &pb.Declaration{} - _t1440.DeclarationType = &pb.Declaration_Data{Data: data755} - _t1438 = _t1440 + _t1436 = -1 + } + prediction754 := _t1436 + var _t1444 *pb.Declaration + if prediction754 == 3 { + _t1445 := p.parse_data() + data758 := _t1445 + _t1446 := &pb.Declaration{} + _t1446.DeclarationType = &pb.Declaration_Data{Data: data758} + _t1444 = _t1446 } else { - var _t1441 *pb.Declaration - if prediction751 == 2 { - _t1442 := p.parse_constraint() - constraint754 := _t1442 - _t1443 := &pb.Declaration{} - _t1443.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint754} - _t1441 = _t1443 + var _t1447 *pb.Declaration + if prediction754 == 2 { + _t1448 := p.parse_constraint() + constraint757 := _t1448 + _t1449 := &pb.Declaration{} + _t1449.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint757} + _t1447 = _t1449 } else { - var _t1444 *pb.Declaration - if prediction751 == 1 { - _t1445 := p.parse_algorithm() - algorithm753 := _t1445 - _t1446 := &pb.Declaration{} - _t1446.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm753} - _t1444 = _t1446 + var _t1450 *pb.Declaration + if prediction754 == 1 { + _t1451 := p.parse_algorithm() + algorithm756 := _t1451 + _t1452 := &pb.Declaration{} + _t1452.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm756} + _t1450 = _t1452 } else { - var _t1447 *pb.Declaration - if prediction751 == 0 { - _t1448 := p.parse_def() - def752 := _t1448 - _t1449 := &pb.Declaration{} - _t1449.DeclarationType = &pb.Declaration_Def{Def: def752} - _t1447 = _t1449 + var _t1453 *pb.Declaration + if prediction754 == 0 { + _t1454 := p.parse_def() + def755 := _t1454 + _t1455 := &pb.Declaration{} + _t1455.DeclarationType = &pb.Declaration_Def{Def: def755} + _t1453 = _t1455 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1444 = _t1447 + _t1450 = _t1453 } - _t1441 = _t1444 + _t1447 = _t1450 } - _t1438 = _t1441 + _t1444 = _t1447 } - result757 := _t1438 - p.recordSpan(int(span_start756), "Declaration") - return result757 + result760 := _t1444 + p.recordSpan(int(span_start759), "Declaration") + return result760 } func (p *Parser) parse_def() *pb.Def { - span_start761 := int64(p.spanStart()) + span_start764 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("def") - _t1450 := p.parse_relation_id() - relation_id758 := _t1450 - _t1451 := p.parse_abstraction() - abstraction759 := _t1451 - var _t1452 []*pb.Attribute + _t1456 := p.parse_relation_id() + relation_id761 := _t1456 + _t1457 := p.parse_abstraction() + abstraction762 := _t1457 + var _t1458 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1453 := p.parse_attrs() - _t1452 = _t1453 + _t1459 := p.parse_attrs() + _t1458 = _t1459 } - attrs760 := _t1452 + attrs763 := _t1458 p.consumeLiteral(")") - _t1454 := attrs760 - if attrs760 == nil { - _t1454 = []*pb.Attribute{} + _t1460 := attrs763 + if attrs763 == nil { + _t1460 = []*pb.Attribute{} } - _t1455 := &pb.Def{Name: relation_id758, Body: abstraction759, Attrs: _t1454} - result762 := _t1455 - p.recordSpan(int(span_start761), "Def") - return result762 + _t1461 := &pb.Def{Name: relation_id761, Body: abstraction762, Attrs: _t1460} + result765 := _t1461 + p.recordSpan(int(span_start764), "Def") + return result765 } func (p *Parser) parse_relation_id() *pb.RelationId { - span_start766 := int64(p.spanStart()) - var _t1456 int64 + span_start769 := int64(p.spanStart()) + var _t1462 int64 if p.matchLookaheadLiteral(":", 0) { - _t1456 = 0 + _t1462 = 0 } else { - var _t1457 int64 + var _t1463 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1457 = 1 + _t1463 = 1 } else { - _t1457 = -1 + _t1463 = -1 } - _t1456 = _t1457 - } - prediction763 := _t1456 - var _t1458 *pb.RelationId - if prediction763 == 1 { - uint128765 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128765 - _t1458 = &pb.RelationId{IdLow: uint128765.Low, IdHigh: uint128765.High} + _t1462 = _t1463 + } + prediction766 := _t1462 + var _t1464 *pb.RelationId + if prediction766 == 1 { + uint128768 := p.consumeTerminal("UINT128").Value.uint128 + _ = uint128768 + _t1464 = &pb.RelationId{IdLow: uint128768.Low, IdHigh: uint128768.High} } else { - var _t1459 *pb.RelationId - if prediction763 == 0 { + var _t1465 *pb.RelationId + if prediction766 == 0 { p.consumeLiteral(":") - symbol764 := p.consumeTerminal("SYMBOL").Value.str - _t1459 = p.relationIdFromString(symbol764) + symbol767 := p.consumeTerminal("SYMBOL").Value.str + _t1465 = p.relationIdFromString(symbol767) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1458 = _t1459 + _t1464 = _t1465 } - result767 := _t1458 - p.recordSpan(int(span_start766), "RelationId") - return result767 + result770 := _t1464 + p.recordSpan(int(span_start769), "RelationId") + return result770 } func (p *Parser) parse_abstraction() *pb.Abstraction { - span_start770 := int64(p.spanStart()) + span_start773 := int64(p.spanStart()) p.consumeLiteral("(") - _t1460 := p.parse_bindings() - bindings768 := _t1460 - _t1461 := p.parse_formula() - formula769 := _t1461 + _t1466 := p.parse_bindings() + bindings771 := _t1466 + _t1467 := p.parse_formula() + formula772 := _t1467 p.consumeLiteral(")") - _t1462 := &pb.Abstraction{Vars: listConcat(bindings768[0].([]*pb.Binding), bindings768[1].([]*pb.Binding)), Value: formula769} - result771 := _t1462 - p.recordSpan(int(span_start770), "Abstraction") - return result771 + _t1468 := &pb.Abstraction{Vars: listConcat(bindings771[0].([]*pb.Binding), bindings771[1].([]*pb.Binding)), Value: formula772} + result774 := _t1468 + p.recordSpan(int(span_start773), "Abstraction") + return result774 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") - xs772 := []*pb.Binding{} - cond773 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond773 { - _t1463 := p.parse_binding() - item774 := _t1463 - xs772 = append(xs772, item774) - cond773 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings775 := xs772 - var _t1464 []*pb.Binding + xs775 := []*pb.Binding{} + cond776 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond776 { + _t1469 := p.parse_binding() + item777 := _t1469 + xs775 = append(xs775, item777) + cond776 = p.matchLookaheadTerminal("SYMBOL", 0) + } + bindings778 := xs775 + var _t1470 []*pb.Binding if p.matchLookaheadLiteral("|", 0) { - _t1465 := p.parse_value_bindings() - _t1464 = _t1465 + _t1471 := p.parse_value_bindings() + _t1470 = _t1471 } - value_bindings776 := _t1464 + value_bindings779 := _t1470 p.consumeLiteral("]") - _t1466 := value_bindings776 - if value_bindings776 == nil { - _t1466 = []*pb.Binding{} + _t1472 := value_bindings779 + if value_bindings779 == nil { + _t1472 = []*pb.Binding{} } - return []interface{}{bindings775, _t1466} + return []interface{}{bindings778, _t1472} } func (p *Parser) parse_binding() *pb.Binding { - span_start779 := int64(p.spanStart()) - symbol777 := p.consumeTerminal("SYMBOL").Value.str + span_start782 := int64(p.spanStart()) + symbol780 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t1467 := p.parse_type() - type778 := _t1467 - _t1468 := &pb.Var{Name: symbol777} - _t1469 := &pb.Binding{Var: _t1468, Type: type778} - result780 := _t1469 - p.recordSpan(int(span_start779), "Binding") - return result780 + _t1473 := p.parse_type() + type781 := _t1473 + _t1474 := &pb.Var{Name: symbol780} + _t1475 := &pb.Binding{Var: _t1474, Type: type781} + result783 := _t1475 + p.recordSpan(int(span_start782), "Binding") + return result783 } func (p *Parser) parse_type() *pb.Type { - span_start796 := int64(p.spanStart()) - var _t1470 int64 + span_start799 := int64(p.spanStart()) + var _t1476 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1470 = 0 + _t1476 = 0 } else { - var _t1471 int64 + var _t1477 int64 if p.matchLookaheadLiteral("UINT32", 0) { - _t1471 = 13 + _t1477 = 13 } else { - var _t1472 int64 + var _t1478 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t1472 = 4 + _t1478 = 4 } else { - var _t1473 int64 + var _t1479 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t1473 = 1 + _t1479 = 1 } else { - var _t1474 int64 + var _t1480 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t1474 = 8 + _t1480 = 8 } else { - var _t1475 int64 + var _t1481 int64 if p.matchLookaheadLiteral("INT32", 0) { - _t1475 = 11 + _t1481 = 11 } else { - var _t1476 int64 + var _t1482 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t1476 = 5 + _t1482 = 5 } else { - var _t1477 int64 + var _t1483 int64 if p.matchLookaheadLiteral("INT", 0) { - _t1477 = 2 + _t1483 = 2 } else { - var _t1478 int64 + var _t1484 int64 if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1478 = 12 + _t1484 = 12 } else { - var _t1479 int64 + var _t1485 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t1479 = 3 + _t1485 = 3 } else { - var _t1480 int64 + var _t1486 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t1480 = 7 + _t1486 = 7 } else { - var _t1481 int64 + var _t1487 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t1481 = 6 + _t1487 = 6 } else { - var _t1482 int64 + var _t1488 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1482 = 10 + _t1488 = 10 } else { - var _t1483 int64 + var _t1489 int64 if p.matchLookaheadLiteral("(", 0) { - _t1483 = 9 + _t1489 = 9 } else { - _t1483 = -1 + _t1489 = -1 } - _t1482 = _t1483 + _t1488 = _t1489 } - _t1481 = _t1482 + _t1487 = _t1488 } - _t1480 = _t1481 + _t1486 = _t1487 } - _t1479 = _t1480 + _t1485 = _t1486 } - _t1478 = _t1479 + _t1484 = _t1485 } - _t1477 = _t1478 + _t1483 = _t1484 } - _t1476 = _t1477 + _t1482 = _t1483 } - _t1475 = _t1476 + _t1481 = _t1482 } - _t1474 = _t1475 + _t1480 = _t1481 } - _t1473 = _t1474 + _t1479 = _t1480 } - _t1472 = _t1473 + _t1478 = _t1479 } - _t1471 = _t1472 + _t1477 = _t1478 } - _t1470 = _t1471 - } - prediction781 := _t1470 - var _t1484 *pb.Type - if prediction781 == 13 { - _t1485 := p.parse_uint32_type() - uint32_type795 := _t1485 - _t1486 := &pb.Type{} - _t1486.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type795} - _t1484 = _t1486 + _t1476 = _t1477 + } + prediction784 := _t1476 + var _t1490 *pb.Type + if prediction784 == 13 { + _t1491 := p.parse_uint32_type() + uint32_type798 := _t1491 + _t1492 := &pb.Type{} + _t1492.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type798} + _t1490 = _t1492 } else { - var _t1487 *pb.Type - if prediction781 == 12 { - _t1488 := p.parse_float32_type() - float32_type794 := _t1488 - _t1489 := &pb.Type{} - _t1489.Type = &pb.Type_Float32Type{Float32Type: float32_type794} - _t1487 = _t1489 + var _t1493 *pb.Type + if prediction784 == 12 { + _t1494 := p.parse_float32_type() + float32_type797 := _t1494 + _t1495 := &pb.Type{} + _t1495.Type = &pb.Type_Float32Type{Float32Type: float32_type797} + _t1493 = _t1495 } else { - var _t1490 *pb.Type - if prediction781 == 11 { - _t1491 := p.parse_int32_type() - int32_type793 := _t1491 - _t1492 := &pb.Type{} - _t1492.Type = &pb.Type_Int32Type{Int32Type: int32_type793} - _t1490 = _t1492 + var _t1496 *pb.Type + if prediction784 == 11 { + _t1497 := p.parse_int32_type() + int32_type796 := _t1497 + _t1498 := &pb.Type{} + _t1498.Type = &pb.Type_Int32Type{Int32Type: int32_type796} + _t1496 = _t1498 } else { - var _t1493 *pb.Type - if prediction781 == 10 { - _t1494 := p.parse_boolean_type() - boolean_type792 := _t1494 - _t1495 := &pb.Type{} - _t1495.Type = &pb.Type_BooleanType{BooleanType: boolean_type792} - _t1493 = _t1495 + var _t1499 *pb.Type + if prediction784 == 10 { + _t1500 := p.parse_boolean_type() + boolean_type795 := _t1500 + _t1501 := &pb.Type{} + _t1501.Type = &pb.Type_BooleanType{BooleanType: boolean_type795} + _t1499 = _t1501 } else { - var _t1496 *pb.Type - if prediction781 == 9 { - _t1497 := p.parse_decimal_type() - decimal_type791 := _t1497 - _t1498 := &pb.Type{} - _t1498.Type = &pb.Type_DecimalType{DecimalType: decimal_type791} - _t1496 = _t1498 + var _t1502 *pb.Type + if prediction784 == 9 { + _t1503 := p.parse_decimal_type() + decimal_type794 := _t1503 + _t1504 := &pb.Type{} + _t1504.Type = &pb.Type_DecimalType{DecimalType: decimal_type794} + _t1502 = _t1504 } else { - var _t1499 *pb.Type - if prediction781 == 8 { - _t1500 := p.parse_missing_type() - missing_type790 := _t1500 - _t1501 := &pb.Type{} - _t1501.Type = &pb.Type_MissingType{MissingType: missing_type790} - _t1499 = _t1501 + var _t1505 *pb.Type + if prediction784 == 8 { + _t1506 := p.parse_missing_type() + missing_type793 := _t1506 + _t1507 := &pb.Type{} + _t1507.Type = &pb.Type_MissingType{MissingType: missing_type793} + _t1505 = _t1507 } else { - var _t1502 *pb.Type - if prediction781 == 7 { - _t1503 := p.parse_datetime_type() - datetime_type789 := _t1503 - _t1504 := &pb.Type{} - _t1504.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type789} - _t1502 = _t1504 + var _t1508 *pb.Type + if prediction784 == 7 { + _t1509 := p.parse_datetime_type() + datetime_type792 := _t1509 + _t1510 := &pb.Type{} + _t1510.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type792} + _t1508 = _t1510 } else { - var _t1505 *pb.Type - if prediction781 == 6 { - _t1506 := p.parse_date_type() - date_type788 := _t1506 - _t1507 := &pb.Type{} - _t1507.Type = &pb.Type_DateType{DateType: date_type788} - _t1505 = _t1507 + var _t1511 *pb.Type + if prediction784 == 6 { + _t1512 := p.parse_date_type() + date_type791 := _t1512 + _t1513 := &pb.Type{} + _t1513.Type = &pb.Type_DateType{DateType: date_type791} + _t1511 = _t1513 } else { - var _t1508 *pb.Type - if prediction781 == 5 { - _t1509 := p.parse_int128_type() - int128_type787 := _t1509 - _t1510 := &pb.Type{} - _t1510.Type = &pb.Type_Int128Type{Int128Type: int128_type787} - _t1508 = _t1510 + var _t1514 *pb.Type + if prediction784 == 5 { + _t1515 := p.parse_int128_type() + int128_type790 := _t1515 + _t1516 := &pb.Type{} + _t1516.Type = &pb.Type_Int128Type{Int128Type: int128_type790} + _t1514 = _t1516 } else { - var _t1511 *pb.Type - if prediction781 == 4 { - _t1512 := p.parse_uint128_type() - uint128_type786 := _t1512 - _t1513 := &pb.Type{} - _t1513.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type786} - _t1511 = _t1513 + var _t1517 *pb.Type + if prediction784 == 4 { + _t1518 := p.parse_uint128_type() + uint128_type789 := _t1518 + _t1519 := &pb.Type{} + _t1519.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type789} + _t1517 = _t1519 } else { - var _t1514 *pb.Type - if prediction781 == 3 { - _t1515 := p.parse_float_type() - float_type785 := _t1515 - _t1516 := &pb.Type{} - _t1516.Type = &pb.Type_FloatType{FloatType: float_type785} - _t1514 = _t1516 + var _t1520 *pb.Type + if prediction784 == 3 { + _t1521 := p.parse_float_type() + float_type788 := _t1521 + _t1522 := &pb.Type{} + _t1522.Type = &pb.Type_FloatType{FloatType: float_type788} + _t1520 = _t1522 } else { - var _t1517 *pb.Type - if prediction781 == 2 { - _t1518 := p.parse_int_type() - int_type784 := _t1518 - _t1519 := &pb.Type{} - _t1519.Type = &pb.Type_IntType{IntType: int_type784} - _t1517 = _t1519 + var _t1523 *pb.Type + if prediction784 == 2 { + _t1524 := p.parse_int_type() + int_type787 := _t1524 + _t1525 := &pb.Type{} + _t1525.Type = &pb.Type_IntType{IntType: int_type787} + _t1523 = _t1525 } else { - var _t1520 *pb.Type - if prediction781 == 1 { - _t1521 := p.parse_string_type() - string_type783 := _t1521 - _t1522 := &pb.Type{} - _t1522.Type = &pb.Type_StringType{StringType: string_type783} - _t1520 = _t1522 + var _t1526 *pb.Type + if prediction784 == 1 { + _t1527 := p.parse_string_type() + string_type786 := _t1527 + _t1528 := &pb.Type{} + _t1528.Type = &pb.Type_StringType{StringType: string_type786} + _t1526 = _t1528 } else { - var _t1523 *pb.Type - if prediction781 == 0 { - _t1524 := p.parse_unspecified_type() - unspecified_type782 := _t1524 - _t1525 := &pb.Type{} - _t1525.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type782} - _t1523 = _t1525 + var _t1529 *pb.Type + if prediction784 == 0 { + _t1530 := p.parse_unspecified_type() + unspecified_type785 := _t1530 + _t1531 := &pb.Type{} + _t1531.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type785} + _t1529 = _t1531 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1520 = _t1523 + _t1526 = _t1529 } - _t1517 = _t1520 + _t1523 = _t1526 } - _t1514 = _t1517 + _t1520 = _t1523 } - _t1511 = _t1514 + _t1517 = _t1520 } - _t1508 = _t1511 + _t1514 = _t1517 } - _t1505 = _t1508 + _t1511 = _t1514 } - _t1502 = _t1505 + _t1508 = _t1511 } - _t1499 = _t1502 + _t1505 = _t1508 } - _t1496 = _t1499 + _t1502 = _t1505 } - _t1493 = _t1496 + _t1499 = _t1502 } - _t1490 = _t1493 + _t1496 = _t1499 } - _t1487 = _t1490 + _t1493 = _t1496 } - _t1484 = _t1487 + _t1490 = _t1493 } - result797 := _t1484 - p.recordSpan(int(span_start796), "Type") - return result797 + result800 := _t1490 + p.recordSpan(int(span_start799), "Type") + return result800 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start798 := int64(p.spanStart()) + span_start801 := int64(p.spanStart()) p.consumeLiteral("UNKNOWN") - _t1526 := &pb.UnspecifiedType{} - result799 := _t1526 - p.recordSpan(int(span_start798), "UnspecifiedType") - return result799 + _t1532 := &pb.UnspecifiedType{} + result802 := _t1532 + p.recordSpan(int(span_start801), "UnspecifiedType") + return result802 } func (p *Parser) parse_string_type() *pb.StringType { - span_start800 := int64(p.spanStart()) + span_start803 := int64(p.spanStart()) p.consumeLiteral("STRING") - _t1527 := &pb.StringType{} - result801 := _t1527 - p.recordSpan(int(span_start800), "StringType") - return result801 + _t1533 := &pb.StringType{} + result804 := _t1533 + p.recordSpan(int(span_start803), "StringType") + return result804 } func (p *Parser) parse_int_type() *pb.IntType { - span_start802 := int64(p.spanStart()) + span_start805 := int64(p.spanStart()) p.consumeLiteral("INT") - _t1528 := &pb.IntType{} - result803 := _t1528 - p.recordSpan(int(span_start802), "IntType") - return result803 + _t1534 := &pb.IntType{} + result806 := _t1534 + p.recordSpan(int(span_start805), "IntType") + return result806 } func (p *Parser) parse_float_type() *pb.FloatType { - span_start804 := int64(p.spanStart()) + span_start807 := int64(p.spanStart()) p.consumeLiteral("FLOAT") - _t1529 := &pb.FloatType{} - result805 := _t1529 - p.recordSpan(int(span_start804), "FloatType") - return result805 + _t1535 := &pb.FloatType{} + result808 := _t1535 + p.recordSpan(int(span_start807), "FloatType") + return result808 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start806 := int64(p.spanStart()) + span_start809 := int64(p.spanStart()) p.consumeLiteral("UINT128") - _t1530 := &pb.UInt128Type{} - result807 := _t1530 - p.recordSpan(int(span_start806), "UInt128Type") - return result807 + _t1536 := &pb.UInt128Type{} + result810 := _t1536 + p.recordSpan(int(span_start809), "UInt128Type") + return result810 } func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start808 := int64(p.spanStart()) + span_start811 := int64(p.spanStart()) p.consumeLiteral("INT128") - _t1531 := &pb.Int128Type{} - result809 := _t1531 - p.recordSpan(int(span_start808), "Int128Type") - return result809 + _t1537 := &pb.Int128Type{} + result812 := _t1537 + p.recordSpan(int(span_start811), "Int128Type") + return result812 } func (p *Parser) parse_date_type() *pb.DateType { - span_start810 := int64(p.spanStart()) + span_start813 := int64(p.spanStart()) p.consumeLiteral("DATE") - _t1532 := &pb.DateType{} - result811 := _t1532 - p.recordSpan(int(span_start810), "DateType") - return result811 + _t1538 := &pb.DateType{} + result814 := _t1538 + p.recordSpan(int(span_start813), "DateType") + return result814 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start812 := int64(p.spanStart()) + span_start815 := int64(p.spanStart()) p.consumeLiteral("DATETIME") - _t1533 := &pb.DateTimeType{} - result813 := _t1533 - p.recordSpan(int(span_start812), "DateTimeType") - return result813 + _t1539 := &pb.DateTimeType{} + result816 := _t1539 + p.recordSpan(int(span_start815), "DateTimeType") + return result816 } func (p *Parser) parse_missing_type() *pb.MissingType { - span_start814 := int64(p.spanStart()) + span_start817 := int64(p.spanStart()) p.consumeLiteral("MISSING") - _t1534 := &pb.MissingType{} - result815 := _t1534 - p.recordSpan(int(span_start814), "MissingType") - return result815 + _t1540 := &pb.MissingType{} + result818 := _t1540 + p.recordSpan(int(span_start817), "MissingType") + return result818 } func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start818 := int64(p.spanStart()) + span_start821 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int816 := p.consumeTerminal("INT").Value.i64 - int_3817 := p.consumeTerminal("INT").Value.i64 + int819 := p.consumeTerminal("INT").Value.i64 + int_3820 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1535 := &pb.DecimalType{Precision: int32(int816), Scale: int32(int_3817)} - result819 := _t1535 - p.recordSpan(int(span_start818), "DecimalType") - return result819 + _t1541 := &pb.DecimalType{Precision: int32(int819), Scale: int32(int_3820)} + result822 := _t1541 + p.recordSpan(int(span_start821), "DecimalType") + return result822 } func (p *Parser) parse_boolean_type() *pb.BooleanType { - span_start820 := int64(p.spanStart()) + span_start823 := int64(p.spanStart()) p.consumeLiteral("BOOLEAN") - _t1536 := &pb.BooleanType{} - result821 := _t1536 - p.recordSpan(int(span_start820), "BooleanType") - return result821 + _t1542 := &pb.BooleanType{} + result824 := _t1542 + p.recordSpan(int(span_start823), "BooleanType") + return result824 } func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start822 := int64(p.spanStart()) + span_start825 := int64(p.spanStart()) p.consumeLiteral("INT32") - _t1537 := &pb.Int32Type{} - result823 := _t1537 - p.recordSpan(int(span_start822), "Int32Type") - return result823 + _t1543 := &pb.Int32Type{} + result826 := _t1543 + p.recordSpan(int(span_start825), "Int32Type") + return result826 } func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start824 := int64(p.spanStart()) + span_start827 := int64(p.spanStart()) p.consumeLiteral("FLOAT32") - _t1538 := &pb.Float32Type{} - result825 := _t1538 - p.recordSpan(int(span_start824), "Float32Type") - return result825 + _t1544 := &pb.Float32Type{} + result828 := _t1544 + p.recordSpan(int(span_start827), "Float32Type") + return result828 } func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start826 := int64(p.spanStart()) + span_start829 := int64(p.spanStart()) p.consumeLiteral("UINT32") - _t1539 := &pb.UInt32Type{} - result827 := _t1539 - p.recordSpan(int(span_start826), "UInt32Type") - return result827 + _t1545 := &pb.UInt32Type{} + result830 := _t1545 + p.recordSpan(int(span_start829), "UInt32Type") + return result830 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - xs828 := []*pb.Binding{} - cond829 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond829 { - _t1540 := p.parse_binding() - item830 := _t1540 - xs828 = append(xs828, item830) - cond829 = p.matchLookaheadTerminal("SYMBOL", 0) + xs831 := []*pb.Binding{} + cond832 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond832 { + _t1546 := p.parse_binding() + item833 := _t1546 + xs831 = append(xs831, item833) + cond832 = p.matchLookaheadTerminal("SYMBOL", 0) } - bindings831 := xs828 - return bindings831 + bindings834 := xs831 + return bindings834 } func (p *Parser) parse_formula() *pb.Formula { - span_start846 := int64(p.spanStart()) - var _t1541 int64 + span_start849 := int64(p.spanStart()) + var _t1547 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1542 int64 + var _t1548 int64 if p.matchLookaheadLiteral("true", 1) { - _t1542 = 0 + _t1548 = 0 } else { - var _t1543 int64 + var _t1549 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t1543 = 11 + _t1549 = 11 } else { - var _t1544 int64 + var _t1550 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t1544 = 3 + _t1550 = 3 } else { - var _t1545 int64 + var _t1551 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1545 = 10 + _t1551 = 10 } else { - var _t1546 int64 + var _t1552 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t1546 = 9 + _t1552 = 9 } else { - var _t1547 int64 + var _t1553 int64 if p.matchLookaheadLiteral("or", 1) { - _t1547 = 5 + _t1553 = 5 } else { - var _t1548 int64 + var _t1554 int64 if p.matchLookaheadLiteral("not", 1) { - _t1548 = 6 + _t1554 = 6 } else { - var _t1549 int64 + var _t1555 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t1549 = 7 + _t1555 = 7 } else { - var _t1550 int64 + var _t1556 int64 if p.matchLookaheadLiteral("false", 1) { - _t1550 = 1 + _t1556 = 1 } else { - var _t1551 int64 + var _t1557 int64 if p.matchLookaheadLiteral("exists", 1) { - _t1551 = 2 + _t1557 = 2 } else { - var _t1552 int64 + var _t1558 int64 if p.matchLookaheadLiteral("cast", 1) { - _t1552 = 12 + _t1558 = 12 } else { - var _t1553 int64 + var _t1559 int64 if p.matchLookaheadLiteral("atom", 1) { - _t1553 = 8 + _t1559 = 8 } else { - var _t1554 int64 + var _t1560 int64 if p.matchLookaheadLiteral("and", 1) { - _t1554 = 4 + _t1560 = 4 } else { - var _t1555 int64 + var _t1561 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1555 = 10 + _t1561 = 10 } else { - var _t1556 int64 + var _t1562 int64 if p.matchLookaheadLiteral(">", 1) { - _t1556 = 10 + _t1562 = 10 } else { - var _t1557 int64 + var _t1563 int64 if p.matchLookaheadLiteral("=", 1) { - _t1557 = 10 + _t1563 = 10 } else { - var _t1558 int64 + var _t1564 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1558 = 10 + _t1564 = 10 } else { - var _t1559 int64 + var _t1565 int64 if p.matchLookaheadLiteral("<", 1) { - _t1559 = 10 + _t1565 = 10 } else { - var _t1560 int64 + var _t1566 int64 if p.matchLookaheadLiteral("/", 1) { - _t1560 = 10 + _t1566 = 10 } else { - var _t1561 int64 + var _t1567 int64 if p.matchLookaheadLiteral("-", 1) { - _t1561 = 10 + _t1567 = 10 } else { - var _t1562 int64 + var _t1568 int64 if p.matchLookaheadLiteral("+", 1) { - _t1562 = 10 + _t1568 = 10 } else { - var _t1563 int64 + var _t1569 int64 if p.matchLookaheadLiteral("*", 1) { - _t1563 = 10 + _t1569 = 10 } else { - _t1563 = -1 + _t1569 = -1 } - _t1562 = _t1563 + _t1568 = _t1569 } - _t1561 = _t1562 + _t1567 = _t1568 } - _t1560 = _t1561 + _t1566 = _t1567 } - _t1559 = _t1560 + _t1565 = _t1566 } - _t1558 = _t1559 + _t1564 = _t1565 } - _t1557 = _t1558 + _t1563 = _t1564 } - _t1556 = _t1557 + _t1562 = _t1563 } - _t1555 = _t1556 + _t1561 = _t1562 } - _t1554 = _t1555 + _t1560 = _t1561 } - _t1553 = _t1554 + _t1559 = _t1560 } - _t1552 = _t1553 + _t1558 = _t1559 } - _t1551 = _t1552 + _t1557 = _t1558 } - _t1550 = _t1551 + _t1556 = _t1557 } - _t1549 = _t1550 + _t1555 = _t1556 } - _t1548 = _t1549 + _t1554 = _t1555 } - _t1547 = _t1548 + _t1553 = _t1554 } - _t1546 = _t1547 + _t1552 = _t1553 } - _t1545 = _t1546 + _t1551 = _t1552 } - _t1544 = _t1545 + _t1550 = _t1551 } - _t1543 = _t1544 + _t1549 = _t1550 } - _t1542 = _t1543 + _t1548 = _t1549 } - _t1541 = _t1542 + _t1547 = _t1548 } else { - _t1541 = -1 - } - prediction832 := _t1541 - var _t1564 *pb.Formula - if prediction832 == 12 { - _t1565 := p.parse_cast() - cast845 := _t1565 - _t1566 := &pb.Formula{} - _t1566.FormulaType = &pb.Formula_Cast{Cast: cast845} - _t1564 = _t1566 + _t1547 = -1 + } + prediction835 := _t1547 + var _t1570 *pb.Formula + if prediction835 == 12 { + _t1571 := p.parse_cast() + cast848 := _t1571 + _t1572 := &pb.Formula{} + _t1572.FormulaType = &pb.Formula_Cast{Cast: cast848} + _t1570 = _t1572 } else { - var _t1567 *pb.Formula - if prediction832 == 11 { - _t1568 := p.parse_rel_atom() - rel_atom844 := _t1568 - _t1569 := &pb.Formula{} - _t1569.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom844} - _t1567 = _t1569 + var _t1573 *pb.Formula + if prediction835 == 11 { + _t1574 := p.parse_rel_atom() + rel_atom847 := _t1574 + _t1575 := &pb.Formula{} + _t1575.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom847} + _t1573 = _t1575 } else { - var _t1570 *pb.Formula - if prediction832 == 10 { - _t1571 := p.parse_primitive() - primitive843 := _t1571 - _t1572 := &pb.Formula{} - _t1572.FormulaType = &pb.Formula_Primitive{Primitive: primitive843} - _t1570 = _t1572 + var _t1576 *pb.Formula + if prediction835 == 10 { + _t1577 := p.parse_primitive() + primitive846 := _t1577 + _t1578 := &pb.Formula{} + _t1578.FormulaType = &pb.Formula_Primitive{Primitive: primitive846} + _t1576 = _t1578 } else { - var _t1573 *pb.Formula - if prediction832 == 9 { - _t1574 := p.parse_pragma() - pragma842 := _t1574 - _t1575 := &pb.Formula{} - _t1575.FormulaType = &pb.Formula_Pragma{Pragma: pragma842} - _t1573 = _t1575 + var _t1579 *pb.Formula + if prediction835 == 9 { + _t1580 := p.parse_pragma() + pragma845 := _t1580 + _t1581 := &pb.Formula{} + _t1581.FormulaType = &pb.Formula_Pragma{Pragma: pragma845} + _t1579 = _t1581 } else { - var _t1576 *pb.Formula - if prediction832 == 8 { - _t1577 := p.parse_atom() - atom841 := _t1577 - _t1578 := &pb.Formula{} - _t1578.FormulaType = &pb.Formula_Atom{Atom: atom841} - _t1576 = _t1578 + var _t1582 *pb.Formula + if prediction835 == 8 { + _t1583 := p.parse_atom() + atom844 := _t1583 + _t1584 := &pb.Formula{} + _t1584.FormulaType = &pb.Formula_Atom{Atom: atom844} + _t1582 = _t1584 } else { - var _t1579 *pb.Formula - if prediction832 == 7 { - _t1580 := p.parse_ffi() - ffi840 := _t1580 - _t1581 := &pb.Formula{} - _t1581.FormulaType = &pb.Formula_Ffi{Ffi: ffi840} - _t1579 = _t1581 + var _t1585 *pb.Formula + if prediction835 == 7 { + _t1586 := p.parse_ffi() + ffi843 := _t1586 + _t1587 := &pb.Formula{} + _t1587.FormulaType = &pb.Formula_Ffi{Ffi: ffi843} + _t1585 = _t1587 } else { - var _t1582 *pb.Formula - if prediction832 == 6 { - _t1583 := p.parse_not() - not839 := _t1583 - _t1584 := &pb.Formula{} - _t1584.FormulaType = &pb.Formula_Not{Not: not839} - _t1582 = _t1584 + var _t1588 *pb.Formula + if prediction835 == 6 { + _t1589 := p.parse_not() + not842 := _t1589 + _t1590 := &pb.Formula{} + _t1590.FormulaType = &pb.Formula_Not{Not: not842} + _t1588 = _t1590 } else { - var _t1585 *pb.Formula - if prediction832 == 5 { - _t1586 := p.parse_disjunction() - disjunction838 := _t1586 - _t1587 := &pb.Formula{} - _t1587.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction838} - _t1585 = _t1587 + var _t1591 *pb.Formula + if prediction835 == 5 { + _t1592 := p.parse_disjunction() + disjunction841 := _t1592 + _t1593 := &pb.Formula{} + _t1593.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction841} + _t1591 = _t1593 } else { - var _t1588 *pb.Formula - if prediction832 == 4 { - _t1589 := p.parse_conjunction() - conjunction837 := _t1589 - _t1590 := &pb.Formula{} - _t1590.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction837} - _t1588 = _t1590 + var _t1594 *pb.Formula + if prediction835 == 4 { + _t1595 := p.parse_conjunction() + conjunction840 := _t1595 + _t1596 := &pb.Formula{} + _t1596.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction840} + _t1594 = _t1596 } else { - var _t1591 *pb.Formula - if prediction832 == 3 { - _t1592 := p.parse_reduce() - reduce836 := _t1592 - _t1593 := &pb.Formula{} - _t1593.FormulaType = &pb.Formula_Reduce{Reduce: reduce836} - _t1591 = _t1593 + var _t1597 *pb.Formula + if prediction835 == 3 { + _t1598 := p.parse_reduce() + reduce839 := _t1598 + _t1599 := &pb.Formula{} + _t1599.FormulaType = &pb.Formula_Reduce{Reduce: reduce839} + _t1597 = _t1599 } else { - var _t1594 *pb.Formula - if prediction832 == 2 { - _t1595 := p.parse_exists() - exists835 := _t1595 - _t1596 := &pb.Formula{} - _t1596.FormulaType = &pb.Formula_Exists{Exists: exists835} - _t1594 = _t1596 + var _t1600 *pb.Formula + if prediction835 == 2 { + _t1601 := p.parse_exists() + exists838 := _t1601 + _t1602 := &pb.Formula{} + _t1602.FormulaType = &pb.Formula_Exists{Exists: exists838} + _t1600 = _t1602 } else { - var _t1597 *pb.Formula - if prediction832 == 1 { - _t1598 := p.parse_false() - false834 := _t1598 - _t1599 := &pb.Formula{} - _t1599.FormulaType = &pb.Formula_Disjunction{Disjunction: false834} - _t1597 = _t1599 + var _t1603 *pb.Formula + if prediction835 == 1 { + _t1604 := p.parse_false() + false837 := _t1604 + _t1605 := &pb.Formula{} + _t1605.FormulaType = &pb.Formula_Disjunction{Disjunction: false837} + _t1603 = _t1605 } else { - var _t1600 *pb.Formula - if prediction832 == 0 { - _t1601 := p.parse_true() - true833 := _t1601 - _t1602 := &pb.Formula{} - _t1602.FormulaType = &pb.Formula_Conjunction{Conjunction: true833} - _t1600 = _t1602 + var _t1606 *pb.Formula + if prediction835 == 0 { + _t1607 := p.parse_true() + true836 := _t1607 + _t1608 := &pb.Formula{} + _t1608.FormulaType = &pb.Formula_Conjunction{Conjunction: true836} + _t1606 = _t1608 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1597 = _t1600 + _t1603 = _t1606 } - _t1594 = _t1597 + _t1600 = _t1603 } - _t1591 = _t1594 + _t1597 = _t1600 } - _t1588 = _t1591 + _t1594 = _t1597 } - _t1585 = _t1588 + _t1591 = _t1594 } - _t1582 = _t1585 + _t1588 = _t1591 } - _t1579 = _t1582 + _t1585 = _t1588 } - _t1576 = _t1579 + _t1582 = _t1585 } - _t1573 = _t1576 + _t1579 = _t1582 } - _t1570 = _t1573 + _t1576 = _t1579 } - _t1567 = _t1570 + _t1573 = _t1576 } - _t1564 = _t1567 + _t1570 = _t1573 } - result847 := _t1564 - p.recordSpan(int(span_start846), "Formula") - return result847 + result850 := _t1570 + p.recordSpan(int(span_start849), "Formula") + return result850 } func (p *Parser) parse_true() *pb.Conjunction { - span_start848 := int64(p.spanStart()) + span_start851 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("true") p.consumeLiteral(")") - _t1603 := &pb.Conjunction{Args: []*pb.Formula{}} - result849 := _t1603 - p.recordSpan(int(span_start848), "Conjunction") - return result849 + _t1609 := &pb.Conjunction{Args: []*pb.Formula{}} + result852 := _t1609 + p.recordSpan(int(span_start851), "Conjunction") + return result852 } func (p *Parser) parse_false() *pb.Disjunction { - span_start850 := int64(p.spanStart()) + span_start853 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("false") p.consumeLiteral(")") - _t1604 := &pb.Disjunction{Args: []*pb.Formula{}} - result851 := _t1604 - p.recordSpan(int(span_start850), "Disjunction") - return result851 + _t1610 := &pb.Disjunction{Args: []*pb.Formula{}} + result854 := _t1610 + p.recordSpan(int(span_start853), "Disjunction") + return result854 } func (p *Parser) parse_exists() *pb.Exists { - span_start854 := int64(p.spanStart()) + span_start857 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("exists") - _t1605 := p.parse_bindings() - bindings852 := _t1605 - _t1606 := p.parse_formula() - formula853 := _t1606 + _t1611 := p.parse_bindings() + bindings855 := _t1611 + _t1612 := p.parse_formula() + formula856 := _t1612 p.consumeLiteral(")") - _t1607 := &pb.Abstraction{Vars: listConcat(bindings852[0].([]*pb.Binding), bindings852[1].([]*pb.Binding)), Value: formula853} - _t1608 := &pb.Exists{Body: _t1607} - result855 := _t1608 - p.recordSpan(int(span_start854), "Exists") - return result855 + _t1613 := &pb.Abstraction{Vars: listConcat(bindings855[0].([]*pb.Binding), bindings855[1].([]*pb.Binding)), Value: formula856} + _t1614 := &pb.Exists{Body: _t1613} + result858 := _t1614 + p.recordSpan(int(span_start857), "Exists") + return result858 } func (p *Parser) parse_reduce() *pb.Reduce { - span_start859 := int64(p.spanStart()) + span_start862 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("reduce") - _t1609 := p.parse_abstraction() - abstraction856 := _t1609 - _t1610 := p.parse_abstraction() - abstraction_3857 := _t1610 - _t1611 := p.parse_terms() - terms858 := _t1611 + _t1615 := p.parse_abstraction() + abstraction859 := _t1615 + _t1616 := p.parse_abstraction() + abstraction_3860 := _t1616 + _t1617 := p.parse_terms() + terms861 := _t1617 p.consumeLiteral(")") - _t1612 := &pb.Reduce{Op: abstraction856, Body: abstraction_3857, Terms: terms858} - result860 := _t1612 - p.recordSpan(int(span_start859), "Reduce") - return result860 + _t1618 := &pb.Reduce{Op: abstraction859, Body: abstraction_3860, Terms: terms861} + result863 := _t1618 + p.recordSpan(int(span_start862), "Reduce") + return result863 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - xs861 := []*pb.Term{} - cond862 := (((((((((((((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 cond862 { - _t1613 := p.parse_term() - item863 := _t1613 - xs861 = append(xs861, item863) - cond862 = (((((((((((((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)) - } - terms864 := xs861 + xs864 := []*pb.Term{} + cond865 := (((((((((((((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 cond865 { + _t1619 := p.parse_term() + item866 := _t1619 + xs864 = append(xs864, item866) + cond865 = (((((((((((((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)) + } + terms867 := xs864 p.consumeLiteral(")") - return terms864 + return terms867 } func (p *Parser) parse_term() *pb.Term { - span_start868 := int64(p.spanStart()) - var _t1614 int64 + span_start871 := int64(p.spanStart()) + var _t1620 int64 if p.matchLookaheadLiteral("true", 0) { - _t1614 = 1 + _t1620 = 1 } else { - var _t1615 int64 + var _t1621 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1615 = 1 + _t1621 = 1 } else { - var _t1616 int64 + var _t1622 int64 if p.matchLookaheadLiteral("false", 0) { - _t1616 = 1 + _t1622 = 1 } else { - var _t1617 int64 + var _t1623 int64 if p.matchLookaheadLiteral("(", 0) { - _t1617 = 1 + _t1623 = 1 } else { - var _t1618 int64 + var _t1624 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1618 = 0 + _t1624 = 0 } else { - var _t1619 int64 + var _t1625 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1619 = 1 + _t1625 = 1 } else { - var _t1620 int64 + var _t1626 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1620 = 1 + _t1626 = 1 } else { - var _t1621 int64 + var _t1627 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1621 = 1 + _t1627 = 1 } else { - var _t1622 int64 + var _t1628 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1622 = 1 + _t1628 = 1 } else { - var _t1623 int64 + var _t1629 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1623 = 1 + _t1629 = 1 } else { - var _t1624 int64 + var _t1630 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1624 = 1 + _t1630 = 1 } else { - var _t1625 int64 + var _t1631 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1625 = 1 + _t1631 = 1 } else { - var _t1626 int64 + var _t1632 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1626 = 1 + _t1632 = 1 } else { - var _t1627 int64 + var _t1633 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1627 = 1 + _t1633 = 1 } else { - _t1627 = -1 + _t1633 = -1 } - _t1626 = _t1627 + _t1632 = _t1633 } - _t1625 = _t1626 + _t1631 = _t1632 } - _t1624 = _t1625 + _t1630 = _t1631 } - _t1623 = _t1624 + _t1629 = _t1630 } - _t1622 = _t1623 + _t1628 = _t1629 } - _t1621 = _t1622 + _t1627 = _t1628 } - _t1620 = _t1621 + _t1626 = _t1627 } - _t1619 = _t1620 + _t1625 = _t1626 } - _t1618 = _t1619 + _t1624 = _t1625 } - _t1617 = _t1618 + _t1623 = _t1624 } - _t1616 = _t1617 + _t1622 = _t1623 } - _t1615 = _t1616 + _t1621 = _t1622 } - _t1614 = _t1615 - } - prediction865 := _t1614 - var _t1628 *pb.Term - if prediction865 == 1 { - _t1629 := p.parse_value() - value867 := _t1629 - _t1630 := &pb.Term{} - _t1630.TermType = &pb.Term_Constant{Constant: value867} - _t1628 = _t1630 + _t1620 = _t1621 + } + prediction868 := _t1620 + var _t1634 *pb.Term + if prediction868 == 1 { + _t1635 := p.parse_value() + value870 := _t1635 + _t1636 := &pb.Term{} + _t1636.TermType = &pb.Term_Constant{Constant: value870} + _t1634 = _t1636 } else { - var _t1631 *pb.Term - if prediction865 == 0 { - _t1632 := p.parse_var() - var866 := _t1632 - _t1633 := &pb.Term{} - _t1633.TermType = &pb.Term_Var{Var: var866} - _t1631 = _t1633 + var _t1637 *pb.Term + if prediction868 == 0 { + _t1638 := p.parse_var() + var869 := _t1638 + _t1639 := &pb.Term{} + _t1639.TermType = &pb.Term_Var{Var: var869} + _t1637 = _t1639 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1628 = _t1631 + _t1634 = _t1637 } - result869 := _t1628 - p.recordSpan(int(span_start868), "Term") - return result869 + result872 := _t1634 + p.recordSpan(int(span_start871), "Term") + return result872 } func (p *Parser) parse_var() *pb.Var { - span_start871 := int64(p.spanStart()) - symbol870 := p.consumeTerminal("SYMBOL").Value.str - _t1634 := &pb.Var{Name: symbol870} - result872 := _t1634 - p.recordSpan(int(span_start871), "Var") - return result872 + span_start874 := int64(p.spanStart()) + symbol873 := p.consumeTerminal("SYMBOL").Value.str + _t1640 := &pb.Var{Name: symbol873} + result875 := _t1640 + p.recordSpan(int(span_start874), "Var") + return result875 } func (p *Parser) parse_value() *pb.Value { - span_start886 := int64(p.spanStart()) - var _t1635 int64 + span_start889 := int64(p.spanStart()) + var _t1641 int64 if p.matchLookaheadLiteral("true", 0) { - _t1635 = 12 + _t1641 = 12 } else { - var _t1636 int64 + var _t1642 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1636 = 11 + _t1642 = 11 } else { - var _t1637 int64 + var _t1643 int64 if p.matchLookaheadLiteral("false", 0) { - _t1637 = 12 + _t1643 = 12 } else { - var _t1638 int64 + var _t1644 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1639 int64 + var _t1645 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1639 = 1 + _t1645 = 1 } else { - var _t1640 int64 + var _t1646 int64 if p.matchLookaheadLiteral("date", 1) { - _t1640 = 0 + _t1646 = 0 } else { - _t1640 = -1 + _t1646 = -1 } - _t1639 = _t1640 + _t1645 = _t1646 } - _t1638 = _t1639 + _t1644 = _t1645 } else { - var _t1641 int64 + var _t1647 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1641 = 7 + _t1647 = 7 } else { - var _t1642 int64 + var _t1648 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1642 = 8 + _t1648 = 8 } else { - var _t1643 int64 + var _t1649 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1643 = 2 + _t1649 = 2 } else { - var _t1644 int64 + var _t1650 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1644 = 3 + _t1650 = 3 } else { - var _t1645 int64 + var _t1651 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1645 = 9 + _t1651 = 9 } else { - var _t1646 int64 + var _t1652 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1646 = 4 + _t1652 = 4 } else { - var _t1647 int64 + var _t1653 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1647 = 5 + _t1653 = 5 } else { - var _t1648 int64 + var _t1654 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1648 = 6 + _t1654 = 6 } else { - var _t1649 int64 + var _t1655 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1649 = 10 + _t1655 = 10 } else { - _t1649 = -1 + _t1655 = -1 } - _t1648 = _t1649 + _t1654 = _t1655 } - _t1647 = _t1648 + _t1653 = _t1654 } - _t1646 = _t1647 + _t1652 = _t1653 } - _t1645 = _t1646 + _t1651 = _t1652 } - _t1644 = _t1645 + _t1650 = _t1651 } - _t1643 = _t1644 + _t1649 = _t1650 } - _t1642 = _t1643 + _t1648 = _t1649 } - _t1641 = _t1642 + _t1647 = _t1648 } - _t1638 = _t1641 + _t1644 = _t1647 } - _t1637 = _t1638 + _t1643 = _t1644 } - _t1636 = _t1637 + _t1642 = _t1643 } - _t1635 = _t1636 - } - prediction873 := _t1635 - var _t1650 *pb.Value - if prediction873 == 12 { - _t1651 := p.parse_boolean_value() - boolean_value885 := _t1651 - _t1652 := &pb.Value{} - _t1652.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value885} - _t1650 = _t1652 + _t1641 = _t1642 + } + prediction876 := _t1641 + var _t1656 *pb.Value + if prediction876 == 12 { + _t1657 := p.parse_boolean_value() + boolean_value888 := _t1657 + _t1658 := &pb.Value{} + _t1658.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value888} + _t1656 = _t1658 } else { - var _t1653 *pb.Value - if prediction873 == 11 { + var _t1659 *pb.Value + if prediction876 == 11 { p.consumeLiteral("missing") - _t1654 := &pb.MissingValue{} - _t1655 := &pb.Value{} - _t1655.Value = &pb.Value_MissingValue{MissingValue: _t1654} - _t1653 = _t1655 + _t1660 := &pb.MissingValue{} + _t1661 := &pb.Value{} + _t1661.Value = &pb.Value_MissingValue{MissingValue: _t1660} + _t1659 = _t1661 } else { - var _t1656 *pb.Value - if prediction873 == 10 { - formatted_decimal884 := p.consumeTerminal("DECIMAL").Value.decimal - _t1657 := &pb.Value{} - _t1657.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal884} - _t1656 = _t1657 + var _t1662 *pb.Value + if prediction876 == 10 { + formatted_decimal887 := p.consumeTerminal("DECIMAL").Value.decimal + _t1663 := &pb.Value{} + _t1663.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal887} + _t1662 = _t1663 } else { - var _t1658 *pb.Value - if prediction873 == 9 { - formatted_int128883 := p.consumeTerminal("INT128").Value.int128 - _t1659 := &pb.Value{} - _t1659.Value = &pb.Value_Int128Value{Int128Value: formatted_int128883} - _t1658 = _t1659 + var _t1664 *pb.Value + if prediction876 == 9 { + formatted_int128886 := p.consumeTerminal("INT128").Value.int128 + _t1665 := &pb.Value{} + _t1665.Value = &pb.Value_Int128Value{Int128Value: formatted_int128886} + _t1664 = _t1665 } else { - var _t1660 *pb.Value - if prediction873 == 8 { - formatted_uint128882 := p.consumeTerminal("UINT128").Value.uint128 - _t1661 := &pb.Value{} - _t1661.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128882} - _t1660 = _t1661 + var _t1666 *pb.Value + if prediction876 == 8 { + formatted_uint128885 := p.consumeTerminal("UINT128").Value.uint128 + _t1667 := &pb.Value{} + _t1667.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128885} + _t1666 = _t1667 } else { - var _t1662 *pb.Value - if prediction873 == 7 { - formatted_uint32881 := p.consumeTerminal("UINT32").Value.u32 - _t1663 := &pb.Value{} - _t1663.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32881} - _t1662 = _t1663 + var _t1668 *pb.Value + if prediction876 == 7 { + formatted_uint32884 := p.consumeTerminal("UINT32").Value.u32 + _t1669 := &pb.Value{} + _t1669.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32884} + _t1668 = _t1669 } else { - var _t1664 *pb.Value - if prediction873 == 6 { - formatted_float880 := p.consumeTerminal("FLOAT").Value.f64 - _t1665 := &pb.Value{} - _t1665.Value = &pb.Value_FloatValue{FloatValue: formatted_float880} - _t1664 = _t1665 + var _t1670 *pb.Value + if prediction876 == 6 { + formatted_float883 := p.consumeTerminal("FLOAT").Value.f64 + _t1671 := &pb.Value{} + _t1671.Value = &pb.Value_FloatValue{FloatValue: formatted_float883} + _t1670 = _t1671 } else { - var _t1666 *pb.Value - if prediction873 == 5 { - formatted_float32879 := p.consumeTerminal("FLOAT32").Value.f32 - _t1667 := &pb.Value{} - _t1667.Value = &pb.Value_Float32Value{Float32Value: formatted_float32879} - _t1666 = _t1667 + var _t1672 *pb.Value + if prediction876 == 5 { + formatted_float32882 := p.consumeTerminal("FLOAT32").Value.f32 + _t1673 := &pb.Value{} + _t1673.Value = &pb.Value_Float32Value{Float32Value: formatted_float32882} + _t1672 = _t1673 } else { - var _t1668 *pb.Value - if prediction873 == 4 { - formatted_int878 := p.consumeTerminal("INT").Value.i64 - _t1669 := &pb.Value{} - _t1669.Value = &pb.Value_IntValue{IntValue: formatted_int878} - _t1668 = _t1669 + var _t1674 *pb.Value + if prediction876 == 4 { + formatted_int881 := p.consumeTerminal("INT").Value.i64 + _t1675 := &pb.Value{} + _t1675.Value = &pb.Value_IntValue{IntValue: formatted_int881} + _t1674 = _t1675 } else { - var _t1670 *pb.Value - if prediction873 == 3 { - formatted_int32877 := p.consumeTerminal("INT32").Value.i32 - _t1671 := &pb.Value{} - _t1671.Value = &pb.Value_Int32Value{Int32Value: formatted_int32877} - _t1670 = _t1671 + var _t1676 *pb.Value + if prediction876 == 3 { + formatted_int32880 := p.consumeTerminal("INT32").Value.i32 + _t1677 := &pb.Value{} + _t1677.Value = &pb.Value_Int32Value{Int32Value: formatted_int32880} + _t1676 = _t1677 } else { - var _t1672 *pb.Value - if prediction873 == 2 { - formatted_string876 := p.consumeTerminal("STRING").Value.str - _t1673 := &pb.Value{} - _t1673.Value = &pb.Value_StringValue{StringValue: formatted_string876} - _t1672 = _t1673 + var _t1678 *pb.Value + if prediction876 == 2 { + formatted_string879 := p.consumeTerminal("STRING").Value.str + _t1679 := &pb.Value{} + _t1679.Value = &pb.Value_StringValue{StringValue: formatted_string879} + _t1678 = _t1679 } else { - var _t1674 *pb.Value - if prediction873 == 1 { - _t1675 := p.parse_datetime() - datetime875 := _t1675 - _t1676 := &pb.Value{} - _t1676.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime875} - _t1674 = _t1676 + var _t1680 *pb.Value + if prediction876 == 1 { + _t1681 := p.parse_datetime() + datetime878 := _t1681 + _t1682 := &pb.Value{} + _t1682.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime878} + _t1680 = _t1682 } else { - var _t1677 *pb.Value - if prediction873 == 0 { - _t1678 := p.parse_date() - date874 := _t1678 - _t1679 := &pb.Value{} - _t1679.Value = &pb.Value_DateValue{DateValue: date874} - _t1677 = _t1679 + var _t1683 *pb.Value + if prediction876 == 0 { + _t1684 := p.parse_date() + date877 := _t1684 + _t1685 := &pb.Value{} + _t1685.Value = &pb.Value_DateValue{DateValue: date877} + _t1683 = _t1685 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1674 = _t1677 + _t1680 = _t1683 } - _t1672 = _t1674 + _t1678 = _t1680 } - _t1670 = _t1672 + _t1676 = _t1678 } - _t1668 = _t1670 + _t1674 = _t1676 } - _t1666 = _t1668 + _t1672 = _t1674 } - _t1664 = _t1666 + _t1670 = _t1672 } - _t1662 = _t1664 + _t1668 = _t1670 } - _t1660 = _t1662 + _t1666 = _t1668 } - _t1658 = _t1660 + _t1664 = _t1666 } - _t1656 = _t1658 + _t1662 = _t1664 } - _t1653 = _t1656 + _t1659 = _t1662 } - _t1650 = _t1653 + _t1656 = _t1659 } - result887 := _t1650 - p.recordSpan(int(span_start886), "Value") - return result887 + result890 := _t1656 + p.recordSpan(int(span_start889), "Value") + return result890 } func (p *Parser) parse_date() *pb.DateValue { - span_start891 := int64(p.spanStart()) + span_start894 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - formatted_int888 := p.consumeTerminal("INT").Value.i64 - formatted_int_3889 := p.consumeTerminal("INT").Value.i64 - formatted_int_4890 := p.consumeTerminal("INT").Value.i64 + formatted_int891 := p.consumeTerminal("INT").Value.i64 + formatted_int_3892 := p.consumeTerminal("INT").Value.i64 + formatted_int_4893 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1680 := &pb.DateValue{Year: int32(formatted_int888), Month: int32(formatted_int_3889), Day: int32(formatted_int_4890)} - result892 := _t1680 - p.recordSpan(int(span_start891), "DateValue") - return result892 + _t1686 := &pb.DateValue{Year: int32(formatted_int891), Month: int32(formatted_int_3892), Day: int32(formatted_int_4893)} + result895 := _t1686 + p.recordSpan(int(span_start894), "DateValue") + return result895 } func (p *Parser) parse_datetime() *pb.DateTimeValue { - span_start900 := int64(p.spanStart()) + span_start903 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - formatted_int893 := p.consumeTerminal("INT").Value.i64 - formatted_int_3894 := p.consumeTerminal("INT").Value.i64 - formatted_int_4895 := p.consumeTerminal("INT").Value.i64 - formatted_int_5896 := p.consumeTerminal("INT").Value.i64 - formatted_int_6897 := p.consumeTerminal("INT").Value.i64 - formatted_int_7898 := p.consumeTerminal("INT").Value.i64 - var _t1681 *int64 + formatted_int896 := p.consumeTerminal("INT").Value.i64 + formatted_int_3897 := p.consumeTerminal("INT").Value.i64 + formatted_int_4898 := p.consumeTerminal("INT").Value.i64 + formatted_int_5899 := p.consumeTerminal("INT").Value.i64 + formatted_int_6900 := p.consumeTerminal("INT").Value.i64 + formatted_int_7901 := p.consumeTerminal("INT").Value.i64 + var _t1687 *int64 if p.matchLookaheadTerminal("INT", 0) { - _t1681 = ptr(p.consumeTerminal("INT").Value.i64) + _t1687 = ptr(p.consumeTerminal("INT").Value.i64) } - formatted_int_8899 := _t1681 + formatted_int_8902 := _t1687 p.consumeLiteral(")") - _t1682 := &pb.DateTimeValue{Year: int32(formatted_int893), Month: int32(formatted_int_3894), Day: int32(formatted_int_4895), Hour: int32(formatted_int_5896), Minute: int32(formatted_int_6897), Second: int32(formatted_int_7898), Microsecond: int32(deref(formatted_int_8899, 0))} - result901 := _t1682 - p.recordSpan(int(span_start900), "DateTimeValue") - return result901 + _t1688 := &pb.DateTimeValue{Year: int32(formatted_int896), Month: int32(formatted_int_3897), Day: int32(formatted_int_4898), Hour: int32(formatted_int_5899), Minute: int32(formatted_int_6900), Second: int32(formatted_int_7901), Microsecond: int32(deref(formatted_int_8902, 0))} + result904 := _t1688 + p.recordSpan(int(span_start903), "DateTimeValue") + return result904 } func (p *Parser) parse_conjunction() *pb.Conjunction { - span_start906 := int64(p.spanStart()) + span_start909 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("and") - xs902 := []*pb.Formula{} - cond903 := p.matchLookaheadLiteral("(", 0) - for cond903 { - _t1683 := p.parse_formula() - item904 := _t1683 - xs902 = append(xs902, item904) - cond903 = p.matchLookaheadLiteral("(", 0) - } - formulas905 := xs902 + xs905 := []*pb.Formula{} + cond906 := p.matchLookaheadLiteral("(", 0) + for cond906 { + _t1689 := p.parse_formula() + item907 := _t1689 + xs905 = append(xs905, item907) + cond906 = p.matchLookaheadLiteral("(", 0) + } + formulas908 := xs905 p.consumeLiteral(")") - _t1684 := &pb.Conjunction{Args: formulas905} - result907 := _t1684 - p.recordSpan(int(span_start906), "Conjunction") - return result907 + _t1690 := &pb.Conjunction{Args: formulas908} + result910 := _t1690 + p.recordSpan(int(span_start909), "Conjunction") + return result910 } func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start912 := int64(p.spanStart()) + span_start915 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") - xs908 := []*pb.Formula{} - cond909 := p.matchLookaheadLiteral("(", 0) - for cond909 { - _t1685 := p.parse_formula() - item910 := _t1685 - xs908 = append(xs908, item910) - cond909 = p.matchLookaheadLiteral("(", 0) - } - formulas911 := xs908 + xs911 := []*pb.Formula{} + cond912 := p.matchLookaheadLiteral("(", 0) + for cond912 { + _t1691 := p.parse_formula() + item913 := _t1691 + xs911 = append(xs911, item913) + cond912 = p.matchLookaheadLiteral("(", 0) + } + formulas914 := xs911 p.consumeLiteral(")") - _t1686 := &pb.Disjunction{Args: formulas911} - result913 := _t1686 - p.recordSpan(int(span_start912), "Disjunction") - return result913 + _t1692 := &pb.Disjunction{Args: formulas914} + result916 := _t1692 + p.recordSpan(int(span_start915), "Disjunction") + return result916 } func (p *Parser) parse_not() *pb.Not { - span_start915 := int64(p.spanStart()) + span_start918 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("not") - _t1687 := p.parse_formula() - formula914 := _t1687 + _t1693 := p.parse_formula() + formula917 := _t1693 p.consumeLiteral(")") - _t1688 := &pb.Not{Arg: formula914} - result916 := _t1688 - p.recordSpan(int(span_start915), "Not") - return result916 + _t1694 := &pb.Not{Arg: formula917} + result919 := _t1694 + p.recordSpan(int(span_start918), "Not") + return result919 } func (p *Parser) parse_ffi() *pb.FFI { - span_start920 := int64(p.spanStart()) + span_start923 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("ffi") - _t1689 := p.parse_name() - name917 := _t1689 - _t1690 := p.parse_ffi_args() - ffi_args918 := _t1690 - _t1691 := p.parse_terms() - terms919 := _t1691 + _t1695 := p.parse_name() + name920 := _t1695 + _t1696 := p.parse_ffi_args() + ffi_args921 := _t1696 + _t1697 := p.parse_terms() + terms922 := _t1697 p.consumeLiteral(")") - _t1692 := &pb.FFI{Name: name917, Args: ffi_args918, Terms: terms919} - result921 := _t1692 - p.recordSpan(int(span_start920), "FFI") - return result921 + _t1698 := &pb.FFI{Name: name920, Args: ffi_args921, Terms: terms922} + result924 := _t1698 + p.recordSpan(int(span_start923), "FFI") + return result924 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol922 := p.consumeTerminal("SYMBOL").Value.str - return symbol922 + symbol925 := p.consumeTerminal("SYMBOL").Value.str + return symbol925 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - xs923 := []*pb.Abstraction{} - cond924 := p.matchLookaheadLiteral("(", 0) - for cond924 { - _t1693 := p.parse_abstraction() - item925 := _t1693 - xs923 = append(xs923, item925) - cond924 = p.matchLookaheadLiteral("(", 0) - } - abstractions926 := xs923 + xs926 := []*pb.Abstraction{} + cond927 := p.matchLookaheadLiteral("(", 0) + for cond927 { + _t1699 := p.parse_abstraction() + item928 := _t1699 + xs926 = append(xs926, item928) + cond927 = p.matchLookaheadLiteral("(", 0) + } + abstractions929 := xs926 p.consumeLiteral(")") - return abstractions926 + return abstractions929 } func (p *Parser) parse_atom() *pb.Atom { - span_start932 := int64(p.spanStart()) + span_start935 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("atom") - _t1694 := p.parse_relation_id() - relation_id927 := _t1694 - xs928 := []*pb.Term{} - cond929 := (((((((((((((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 cond929 { - _t1695 := p.parse_term() - item930 := _t1695 - xs928 = append(xs928, item930) - cond929 = (((((((((((((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)) - } - terms931 := xs928 + _t1700 := p.parse_relation_id() + relation_id930 := _t1700 + xs931 := []*pb.Term{} + cond932 := (((((((((((((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 cond932 { + _t1701 := p.parse_term() + item933 := _t1701 + xs931 = append(xs931, item933) + cond932 = (((((((((((((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)) + } + terms934 := xs931 p.consumeLiteral(")") - _t1696 := &pb.Atom{Name: relation_id927, Terms: terms931} - result933 := _t1696 - p.recordSpan(int(span_start932), "Atom") - return result933 + _t1702 := &pb.Atom{Name: relation_id930, Terms: terms934} + result936 := _t1702 + p.recordSpan(int(span_start935), "Atom") + return result936 } func (p *Parser) parse_pragma() *pb.Pragma { - span_start939 := int64(p.spanStart()) + span_start942 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1697 := p.parse_name() - name934 := _t1697 - xs935 := []*pb.Term{} - cond936 := (((((((((((((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 cond936 { - _t1698 := p.parse_term() - item937 := _t1698 - xs935 = append(xs935, item937) - cond936 = (((((((((((((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)) - } - terms938 := xs935 + _t1703 := p.parse_name() + name937 := _t1703 + xs938 := []*pb.Term{} + cond939 := (((((((((((((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 cond939 { + _t1704 := p.parse_term() + item940 := _t1704 + xs938 = append(xs938, item940) + cond939 = (((((((((((((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)) + } + terms941 := xs938 p.consumeLiteral(")") - _t1699 := &pb.Pragma{Name: name934, Terms: terms938} - result940 := _t1699 - p.recordSpan(int(span_start939), "Pragma") - return result940 + _t1705 := &pb.Pragma{Name: name937, Terms: terms941} + result943 := _t1705 + p.recordSpan(int(span_start942), "Pragma") + return result943 } func (p *Parser) parse_primitive() *pb.Primitive { - span_start956 := int64(p.spanStart()) - var _t1700 int64 + span_start959 := int64(p.spanStart()) + var _t1706 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1701 int64 + var _t1707 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1701 = 9 + _t1707 = 9 } else { - var _t1702 int64 + var _t1708 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1702 = 4 + _t1708 = 4 } else { - var _t1703 int64 + var _t1709 int64 if p.matchLookaheadLiteral(">", 1) { - _t1703 = 3 + _t1709 = 3 } else { - var _t1704 int64 + var _t1710 int64 if p.matchLookaheadLiteral("=", 1) { - _t1704 = 0 + _t1710 = 0 } else { - var _t1705 int64 + var _t1711 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1705 = 2 + _t1711 = 2 } else { - var _t1706 int64 + var _t1712 int64 if p.matchLookaheadLiteral("<", 1) { - _t1706 = 1 + _t1712 = 1 } else { - var _t1707 int64 + var _t1713 int64 if p.matchLookaheadLiteral("/", 1) { - _t1707 = 8 + _t1713 = 8 } else { - var _t1708 int64 + var _t1714 int64 if p.matchLookaheadLiteral("-", 1) { - _t1708 = 6 + _t1714 = 6 } else { - var _t1709 int64 + var _t1715 int64 if p.matchLookaheadLiteral("+", 1) { - _t1709 = 5 + _t1715 = 5 } else { - var _t1710 int64 + var _t1716 int64 if p.matchLookaheadLiteral("*", 1) { - _t1710 = 7 + _t1716 = 7 } else { - _t1710 = -1 + _t1716 = -1 } - _t1709 = _t1710 + _t1715 = _t1716 } - _t1708 = _t1709 + _t1714 = _t1715 } - _t1707 = _t1708 + _t1713 = _t1714 } - _t1706 = _t1707 + _t1712 = _t1713 } - _t1705 = _t1706 + _t1711 = _t1712 } - _t1704 = _t1705 + _t1710 = _t1711 } - _t1703 = _t1704 + _t1709 = _t1710 } - _t1702 = _t1703 + _t1708 = _t1709 } - _t1701 = _t1702 + _t1707 = _t1708 } - _t1700 = _t1701 + _t1706 = _t1707 } else { - _t1700 = -1 + _t1706 = -1 } - prediction941 := _t1700 - var _t1711 *pb.Primitive - if prediction941 == 9 { + prediction944 := _t1706 + var _t1717 *pb.Primitive + if prediction944 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1712 := p.parse_name() - name951 := _t1712 - xs952 := []*pb.RelTerm{} - cond953 := ((((((((((((((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 cond953 { - _t1713 := p.parse_rel_term() - item954 := _t1713 - xs952 = append(xs952, item954) - cond953 = ((((((((((((((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)) + _t1718 := p.parse_name() + name954 := _t1718 + xs955 := []*pb.RelTerm{} + cond956 := ((((((((((((((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 cond956 { + _t1719 := p.parse_rel_term() + item957 := _t1719 + xs955 = append(xs955, item957) + cond956 = ((((((((((((((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_terms955 := xs952 + rel_terms958 := xs955 p.consumeLiteral(")") - _t1714 := &pb.Primitive{Name: name951, Terms: rel_terms955} - _t1711 = _t1714 + _t1720 := &pb.Primitive{Name: name954, Terms: rel_terms958} + _t1717 = _t1720 } else { - var _t1715 *pb.Primitive - if prediction941 == 8 { - _t1716 := p.parse_divide() - divide950 := _t1716 - _t1715 = divide950 + var _t1721 *pb.Primitive + if prediction944 == 8 { + _t1722 := p.parse_divide() + divide953 := _t1722 + _t1721 = divide953 } else { - var _t1717 *pb.Primitive - if prediction941 == 7 { - _t1718 := p.parse_multiply() - multiply949 := _t1718 - _t1717 = multiply949 + var _t1723 *pb.Primitive + if prediction944 == 7 { + _t1724 := p.parse_multiply() + multiply952 := _t1724 + _t1723 = multiply952 } else { - var _t1719 *pb.Primitive - if prediction941 == 6 { - _t1720 := p.parse_minus() - minus948 := _t1720 - _t1719 = minus948 + var _t1725 *pb.Primitive + if prediction944 == 6 { + _t1726 := p.parse_minus() + minus951 := _t1726 + _t1725 = minus951 } else { - var _t1721 *pb.Primitive - if prediction941 == 5 { - _t1722 := p.parse_add() - add947 := _t1722 - _t1721 = add947 + var _t1727 *pb.Primitive + if prediction944 == 5 { + _t1728 := p.parse_add() + add950 := _t1728 + _t1727 = add950 } else { - var _t1723 *pb.Primitive - if prediction941 == 4 { - _t1724 := p.parse_gt_eq() - gt_eq946 := _t1724 - _t1723 = gt_eq946 + var _t1729 *pb.Primitive + if prediction944 == 4 { + _t1730 := p.parse_gt_eq() + gt_eq949 := _t1730 + _t1729 = gt_eq949 } else { - var _t1725 *pb.Primitive - if prediction941 == 3 { - _t1726 := p.parse_gt() - gt945 := _t1726 - _t1725 = gt945 + var _t1731 *pb.Primitive + if prediction944 == 3 { + _t1732 := p.parse_gt() + gt948 := _t1732 + _t1731 = gt948 } else { - var _t1727 *pb.Primitive - if prediction941 == 2 { - _t1728 := p.parse_lt_eq() - lt_eq944 := _t1728 - _t1727 = lt_eq944 + var _t1733 *pb.Primitive + if prediction944 == 2 { + _t1734 := p.parse_lt_eq() + lt_eq947 := _t1734 + _t1733 = lt_eq947 } else { - var _t1729 *pb.Primitive - if prediction941 == 1 { - _t1730 := p.parse_lt() - lt943 := _t1730 - _t1729 = lt943 + var _t1735 *pb.Primitive + if prediction944 == 1 { + _t1736 := p.parse_lt() + lt946 := _t1736 + _t1735 = lt946 } else { - var _t1731 *pb.Primitive - if prediction941 == 0 { - _t1732 := p.parse_eq() - eq942 := _t1732 - _t1731 = eq942 + var _t1737 *pb.Primitive + if prediction944 == 0 { + _t1738 := p.parse_eq() + eq945 := _t1738 + _t1737 = eq945 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1729 = _t1731 + _t1735 = _t1737 } - _t1727 = _t1729 + _t1733 = _t1735 } - _t1725 = _t1727 + _t1731 = _t1733 } - _t1723 = _t1725 + _t1729 = _t1731 } - _t1721 = _t1723 + _t1727 = _t1729 } - _t1719 = _t1721 + _t1725 = _t1727 } - _t1717 = _t1719 + _t1723 = _t1725 } - _t1715 = _t1717 + _t1721 = _t1723 } - _t1711 = _t1715 + _t1717 = _t1721 } - result957 := _t1711 - p.recordSpan(int(span_start956), "Primitive") - return result957 + result960 := _t1717 + p.recordSpan(int(span_start959), "Primitive") + return result960 } func (p *Parser) parse_eq() *pb.Primitive { - span_start960 := int64(p.spanStart()) + span_start963 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("=") - _t1733 := p.parse_term() - term958 := _t1733 - _t1734 := p.parse_term() - term_3959 := _t1734 - p.consumeLiteral(")") - _t1735 := &pb.RelTerm{} - _t1735.RelTermType = &pb.RelTerm_Term{Term: term958} - _t1736 := &pb.RelTerm{} - _t1736.RelTermType = &pb.RelTerm_Term{Term: term_3959} - _t1737 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1735, _t1736}} - result961 := _t1737 - p.recordSpan(int(span_start960), "Primitive") - return result961 -} - -func (p *Parser) parse_lt() *pb.Primitive { - span_start964 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("<") - _t1738 := p.parse_term() - term962 := _t1738 _t1739 := p.parse_term() - term_3963 := _t1739 + term961 := _t1739 + _t1740 := p.parse_term() + term_3962 := _t1740 p.consumeLiteral(")") - _t1740 := &pb.RelTerm{} - _t1740.RelTermType = &pb.RelTerm_Term{Term: term962} _t1741 := &pb.RelTerm{} - _t1741.RelTermType = &pb.RelTerm_Term{Term: term_3963} - _t1742 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1740, _t1741}} - result965 := _t1742 - p.recordSpan(int(span_start964), "Primitive") - return result965 + _t1741.RelTermType = &pb.RelTerm_Term{Term: term961} + _t1742 := &pb.RelTerm{} + _t1742.RelTermType = &pb.RelTerm_Term{Term: term_3962} + _t1743 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1741, _t1742}} + result964 := _t1743 + p.recordSpan(int(span_start963), "Primitive") + return result964 } -func (p *Parser) parse_lt_eq() *pb.Primitive { - span_start968 := int64(p.spanStart()) +func (p *Parser) parse_lt() *pb.Primitive { + span_start967 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("<=") - _t1743 := p.parse_term() - term966 := _t1743 + p.consumeLiteral("<") _t1744 := p.parse_term() - term_3967 := _t1744 + term965 := _t1744 + _t1745 := p.parse_term() + term_3966 := _t1745 p.consumeLiteral(")") - _t1745 := &pb.RelTerm{} - _t1745.RelTermType = &pb.RelTerm_Term{Term: term966} _t1746 := &pb.RelTerm{} - _t1746.RelTermType = &pb.RelTerm_Term{Term: term_3967} - _t1747 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1745, _t1746}} - result969 := _t1747 - p.recordSpan(int(span_start968), "Primitive") - return result969 + _t1746.RelTermType = &pb.RelTerm_Term{Term: term965} + _t1747 := &pb.RelTerm{} + _t1747.RelTermType = &pb.RelTerm_Term{Term: term_3966} + _t1748 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1746, _t1747}} + result968 := _t1748 + p.recordSpan(int(span_start967), "Primitive") + return result968 } -func (p *Parser) parse_gt() *pb.Primitive { - span_start972 := int64(p.spanStart()) +func (p *Parser) parse_lt_eq() *pb.Primitive { + span_start971 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral(">") - _t1748 := p.parse_term() - term970 := _t1748 + p.consumeLiteral("<=") _t1749 := p.parse_term() - term_3971 := _t1749 + term969 := _t1749 + _t1750 := p.parse_term() + term_3970 := _t1750 p.consumeLiteral(")") - _t1750 := &pb.RelTerm{} - _t1750.RelTermType = &pb.RelTerm_Term{Term: term970} _t1751 := &pb.RelTerm{} - _t1751.RelTermType = &pb.RelTerm_Term{Term: term_3971} - _t1752 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1750, _t1751}} - result973 := _t1752 - p.recordSpan(int(span_start972), "Primitive") - return result973 + _t1751.RelTermType = &pb.RelTerm_Term{Term: term969} + _t1752 := &pb.RelTerm{} + _t1752.RelTermType = &pb.RelTerm_Term{Term: term_3970} + _t1753 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1751, _t1752}} + result972 := _t1753 + p.recordSpan(int(span_start971), "Primitive") + return result972 } -func (p *Parser) parse_gt_eq() *pb.Primitive { - span_start976 := int64(p.spanStart()) +func (p *Parser) parse_gt() *pb.Primitive { + span_start975 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral(">=") - _t1753 := p.parse_term() - term974 := _t1753 + p.consumeLiteral(">") _t1754 := p.parse_term() - term_3975 := _t1754 + term973 := _t1754 + _t1755 := p.parse_term() + term_3974 := _t1755 p.consumeLiteral(")") - _t1755 := &pb.RelTerm{} - _t1755.RelTermType = &pb.RelTerm_Term{Term: term974} _t1756 := &pb.RelTerm{} - _t1756.RelTermType = &pb.RelTerm_Term{Term: term_3975} - _t1757 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1755, _t1756}} - result977 := _t1757 - p.recordSpan(int(span_start976), "Primitive") - return result977 + _t1756.RelTermType = &pb.RelTerm_Term{Term: term973} + _t1757 := &pb.RelTerm{} + _t1757.RelTermType = &pb.RelTerm_Term{Term: term_3974} + _t1758 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1756, _t1757}} + result976 := _t1758 + p.recordSpan(int(span_start975), "Primitive") + return result976 } -func (p *Parser) parse_add() *pb.Primitive { - span_start981 := int64(p.spanStart()) +func (p *Parser) parse_gt_eq() *pb.Primitive { + span_start979 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("+") - _t1758 := p.parse_term() - term978 := _t1758 + p.consumeLiteral(">=") _t1759 := p.parse_term() - term_3979 := _t1759 + term977 := _t1759 _t1760 := p.parse_term() - term_4980 := _t1760 + term_3978 := _t1760 p.consumeLiteral(")") _t1761 := &pb.RelTerm{} - _t1761.RelTermType = &pb.RelTerm_Term{Term: term978} + _t1761.RelTermType = &pb.RelTerm_Term{Term: term977} _t1762 := &pb.RelTerm{} - _t1762.RelTermType = &pb.RelTerm_Term{Term: term_3979} - _t1763 := &pb.RelTerm{} - _t1763.RelTermType = &pb.RelTerm_Term{Term: term_4980} - _t1764 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1761, _t1762, _t1763}} - result982 := _t1764 - p.recordSpan(int(span_start981), "Primitive") - return result982 + _t1762.RelTermType = &pb.RelTerm_Term{Term: term_3978} + _t1763 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1761, _t1762}} + result980 := _t1763 + p.recordSpan(int(span_start979), "Primitive") + return result980 } -func (p *Parser) parse_minus() *pb.Primitive { - span_start986 := int64(p.spanStart()) +func (p *Parser) parse_add() *pb.Primitive { + span_start984 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("-") + p.consumeLiteral("+") + _t1764 := p.parse_term() + term981 := _t1764 _t1765 := p.parse_term() - term983 := _t1765 + term_3982 := _t1765 _t1766 := p.parse_term() - term_3984 := _t1766 - _t1767 := p.parse_term() - term_4985 := _t1767 + term_4983 := _t1766 p.consumeLiteral(")") + _t1767 := &pb.RelTerm{} + _t1767.RelTermType = &pb.RelTerm_Term{Term: term981} _t1768 := &pb.RelTerm{} - _t1768.RelTermType = &pb.RelTerm_Term{Term: term983} + _t1768.RelTermType = &pb.RelTerm_Term{Term: term_3982} _t1769 := &pb.RelTerm{} - _t1769.RelTermType = &pb.RelTerm_Term{Term: term_3984} - _t1770 := &pb.RelTerm{} - _t1770.RelTermType = &pb.RelTerm_Term{Term: term_4985} - _t1771 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1768, _t1769, _t1770}} - result987 := _t1771 - p.recordSpan(int(span_start986), "Primitive") - return result987 + _t1769.RelTermType = &pb.RelTerm_Term{Term: term_4983} + _t1770 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1767, _t1768, _t1769}} + result985 := _t1770 + p.recordSpan(int(span_start984), "Primitive") + return result985 } -func (p *Parser) parse_multiply() *pb.Primitive { - span_start991 := int64(p.spanStart()) +func (p *Parser) parse_minus() *pb.Primitive { + span_start989 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("*") + p.consumeLiteral("-") + _t1771 := p.parse_term() + term986 := _t1771 _t1772 := p.parse_term() - term988 := _t1772 + term_3987 := _t1772 _t1773 := p.parse_term() - term_3989 := _t1773 - _t1774 := p.parse_term() - term_4990 := _t1774 + term_4988 := _t1773 p.consumeLiteral(")") + _t1774 := &pb.RelTerm{} + _t1774.RelTermType = &pb.RelTerm_Term{Term: term986} _t1775 := &pb.RelTerm{} - _t1775.RelTermType = &pb.RelTerm_Term{Term: term988} + _t1775.RelTermType = &pb.RelTerm_Term{Term: term_3987} _t1776 := &pb.RelTerm{} - _t1776.RelTermType = &pb.RelTerm_Term{Term: term_3989} - _t1777 := &pb.RelTerm{} - _t1777.RelTermType = &pb.RelTerm_Term{Term: term_4990} - _t1778 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1775, _t1776, _t1777}} - result992 := _t1778 - p.recordSpan(int(span_start991), "Primitive") - return result992 + _t1776.RelTermType = &pb.RelTerm_Term{Term: term_4988} + _t1777 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1774, _t1775, _t1776}} + result990 := _t1777 + p.recordSpan(int(span_start989), "Primitive") + return result990 } -func (p *Parser) parse_divide() *pb.Primitive { - span_start996 := int64(p.spanStart()) +func (p *Parser) parse_multiply() *pb.Primitive { + span_start994 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("/") + p.consumeLiteral("*") + _t1778 := p.parse_term() + term991 := _t1778 _t1779 := p.parse_term() - term993 := _t1779 + term_3992 := _t1779 _t1780 := p.parse_term() - term_3994 := _t1780 - _t1781 := p.parse_term() - term_4995 := _t1781 + term_4993 := _t1780 p.consumeLiteral(")") + _t1781 := &pb.RelTerm{} + _t1781.RelTermType = &pb.RelTerm_Term{Term: term991} _t1782 := &pb.RelTerm{} - _t1782.RelTermType = &pb.RelTerm_Term{Term: term993} + _t1782.RelTermType = &pb.RelTerm_Term{Term: term_3992} _t1783 := &pb.RelTerm{} - _t1783.RelTermType = &pb.RelTerm_Term{Term: term_3994} - _t1784 := &pb.RelTerm{} - _t1784.RelTermType = &pb.RelTerm_Term{Term: term_4995} - _t1785 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1782, _t1783, _t1784}} - result997 := _t1785 - p.recordSpan(int(span_start996), "Primitive") - return result997 + _t1783.RelTermType = &pb.RelTerm_Term{Term: term_4993} + _t1784 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1781, _t1782, _t1783}} + result995 := _t1784 + p.recordSpan(int(span_start994), "Primitive") + return result995 +} + +func (p *Parser) parse_divide() *pb.Primitive { + span_start999 := int64(p.spanStart()) + p.consumeLiteral("(") + p.consumeLiteral("/") + _t1785 := p.parse_term() + term996 := _t1785 + _t1786 := p.parse_term() + term_3997 := _t1786 + _t1787 := p.parse_term() + term_4998 := _t1787 + p.consumeLiteral(")") + _t1788 := &pb.RelTerm{} + _t1788.RelTermType = &pb.RelTerm_Term{Term: term996} + _t1789 := &pb.RelTerm{} + _t1789.RelTermType = &pb.RelTerm_Term{Term: term_3997} + _t1790 := &pb.RelTerm{} + _t1790.RelTermType = &pb.RelTerm_Term{Term: term_4998} + _t1791 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1788, _t1789, _t1790}} + result1000 := _t1791 + p.recordSpan(int(span_start999), "Primitive") + return result1000 } func (p *Parser) parse_rel_term() *pb.RelTerm { - span_start1001 := int64(p.spanStart()) - var _t1786 int64 + span_start1004 := int64(p.spanStart()) + var _t1792 int64 if p.matchLookaheadLiteral("true", 0) { - _t1786 = 1 + _t1792 = 1 } else { - var _t1787 int64 + var _t1793 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1787 = 1 + _t1793 = 1 } else { - var _t1788 int64 + var _t1794 int64 if p.matchLookaheadLiteral("false", 0) { - _t1788 = 1 + _t1794 = 1 } else { - var _t1789 int64 + var _t1795 int64 if p.matchLookaheadLiteral("(", 0) { - _t1789 = 1 + _t1795 = 1 } else { - var _t1790 int64 + var _t1796 int64 if p.matchLookaheadLiteral("#", 0) { - _t1790 = 0 + _t1796 = 0 } else { - var _t1791 int64 + var _t1797 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1791 = 1 + _t1797 = 1 } else { - var _t1792 int64 + var _t1798 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1792 = 1 + _t1798 = 1 } else { - var _t1793 int64 + var _t1799 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1793 = 1 + _t1799 = 1 } else { - var _t1794 int64 + var _t1800 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1794 = 1 + _t1800 = 1 } else { - var _t1795 int64 + var _t1801 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1795 = 1 + _t1801 = 1 } else { - var _t1796 int64 + var _t1802 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1796 = 1 + _t1802 = 1 } else { - var _t1797 int64 + var _t1803 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1797 = 1 + _t1803 = 1 } else { - var _t1798 int64 + var _t1804 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1798 = 1 + _t1804 = 1 } else { - var _t1799 int64 + var _t1805 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1799 = 1 + _t1805 = 1 } else { - var _t1800 int64 + var _t1806 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1800 = 1 + _t1806 = 1 } else { - _t1800 = -1 + _t1806 = -1 } - _t1799 = _t1800 + _t1805 = _t1806 } - _t1798 = _t1799 + _t1804 = _t1805 } - _t1797 = _t1798 + _t1803 = _t1804 } - _t1796 = _t1797 + _t1802 = _t1803 } - _t1795 = _t1796 + _t1801 = _t1802 } - _t1794 = _t1795 + _t1800 = _t1801 } - _t1793 = _t1794 + _t1799 = _t1800 } - _t1792 = _t1793 + _t1798 = _t1799 } - _t1791 = _t1792 + _t1797 = _t1798 } - _t1790 = _t1791 + _t1796 = _t1797 } - _t1789 = _t1790 + _t1795 = _t1796 } - _t1788 = _t1789 + _t1794 = _t1795 } - _t1787 = _t1788 + _t1793 = _t1794 } - _t1786 = _t1787 - } - prediction998 := _t1786 - var _t1801 *pb.RelTerm - if prediction998 == 1 { - _t1802 := p.parse_term() - term1000 := _t1802 - _t1803 := &pb.RelTerm{} - _t1803.RelTermType = &pb.RelTerm_Term{Term: term1000} - _t1801 = _t1803 + _t1792 = _t1793 + } + prediction1001 := _t1792 + var _t1807 *pb.RelTerm + if prediction1001 == 1 { + _t1808 := p.parse_term() + term1003 := _t1808 + _t1809 := &pb.RelTerm{} + _t1809.RelTermType = &pb.RelTerm_Term{Term: term1003} + _t1807 = _t1809 } else { - var _t1804 *pb.RelTerm - if prediction998 == 0 { - _t1805 := p.parse_specialized_value() - specialized_value999 := _t1805 - _t1806 := &pb.RelTerm{} - _t1806.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value999} - _t1804 = _t1806 + var _t1810 *pb.RelTerm + if prediction1001 == 0 { + _t1811 := p.parse_specialized_value() + specialized_value1002 := _t1811 + _t1812 := &pb.RelTerm{} + _t1812.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1002} + _t1810 = _t1812 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1801 = _t1804 + _t1807 = _t1810 } - result1002 := _t1801 - p.recordSpan(int(span_start1001), "RelTerm") - return result1002 + result1005 := _t1807 + p.recordSpan(int(span_start1004), "RelTerm") + return result1005 } func (p *Parser) parse_specialized_value() *pb.Value { - span_start1004 := int64(p.spanStart()) + span_start1007 := int64(p.spanStart()) p.consumeLiteral("#") - _t1807 := p.parse_raw_value() - raw_value1003 := _t1807 - result1005 := raw_value1003 - p.recordSpan(int(span_start1004), "Value") - return result1005 + _t1813 := p.parse_raw_value() + raw_value1006 := _t1813 + result1008 := raw_value1006 + p.recordSpan(int(span_start1007), "Value") + return result1008 } func (p *Parser) parse_rel_atom() *pb.RelAtom { - span_start1011 := int64(p.spanStart()) + span_start1014 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1808 := p.parse_name() - name1006 := _t1808 - xs1007 := []*pb.RelTerm{} - cond1008 := ((((((((((((((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 cond1008 { - _t1809 := p.parse_rel_term() - item1009 := _t1809 - xs1007 = append(xs1007, item1009) - cond1008 = ((((((((((((((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_terms1010 := xs1007 + _t1814 := p.parse_name() + name1009 := _t1814 + xs1010 := []*pb.RelTerm{} + cond1011 := ((((((((((((((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 cond1011 { + _t1815 := p.parse_rel_term() + item1012 := _t1815 + xs1010 = append(xs1010, item1012) + cond1011 = ((((((((((((((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_terms1013 := xs1010 p.consumeLiteral(")") - _t1810 := &pb.RelAtom{Name: name1006, Terms: rel_terms1010} - result1012 := _t1810 - p.recordSpan(int(span_start1011), "RelAtom") - return result1012 + _t1816 := &pb.RelAtom{Name: name1009, Terms: rel_terms1013} + result1015 := _t1816 + p.recordSpan(int(span_start1014), "RelAtom") + return result1015 } func (p *Parser) parse_cast() *pb.Cast { - span_start1015 := int64(p.spanStart()) + span_start1018 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("cast") - _t1811 := p.parse_term() - term1013 := _t1811 - _t1812 := p.parse_term() - term_31014 := _t1812 + _t1817 := p.parse_term() + term1016 := _t1817 + _t1818 := p.parse_term() + term_31017 := _t1818 p.consumeLiteral(")") - _t1813 := &pb.Cast{Input: term1013, Result: term_31014} - result1016 := _t1813 - p.recordSpan(int(span_start1015), "Cast") - return result1016 + _t1819 := &pb.Cast{Input: term1016, Result: term_31017} + result1019 := _t1819 + p.recordSpan(int(span_start1018), "Cast") + return result1019 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") - xs1017 := []*pb.Attribute{} - cond1018 := p.matchLookaheadLiteral("(", 0) - for cond1018 { - _t1814 := p.parse_attribute() - item1019 := _t1814 - xs1017 = append(xs1017, item1019) - cond1018 = p.matchLookaheadLiteral("(", 0) - } - attributes1020 := xs1017 + xs1020 := []*pb.Attribute{} + cond1021 := p.matchLookaheadLiteral("(", 0) + for cond1021 { + _t1820 := p.parse_attribute() + item1022 := _t1820 + xs1020 = append(xs1020, item1022) + cond1021 = p.matchLookaheadLiteral("(", 0) + } + attributes1023 := xs1020 p.consumeLiteral(")") - return attributes1020 + return attributes1023 } func (p *Parser) parse_attribute() *pb.Attribute { - span_start1026 := int64(p.spanStart()) + span_start1029 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1815 := p.parse_name() - name1021 := _t1815 - xs1022 := []*pb.Value{} - cond1023 := ((((((((((((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 cond1023 { - _t1816 := p.parse_raw_value() - item1024 := _t1816 - xs1022 = append(xs1022, item1024) - cond1023 = ((((((((((((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_values1025 := xs1022 + _t1821 := p.parse_name() + name1024 := _t1821 + xs1025 := []*pb.Value{} + cond1026 := ((((((((((((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 cond1026 { + _t1822 := p.parse_raw_value() + item1027 := _t1822 + xs1025 = append(xs1025, item1027) + cond1026 = ((((((((((((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_values1028 := xs1025 p.consumeLiteral(")") - _t1817 := &pb.Attribute{Name: name1021, Args: raw_values1025} - result1027 := _t1817 - p.recordSpan(int(span_start1026), "Attribute") - return result1027 + _t1823 := &pb.Attribute{Name: name1024, Args: raw_values1028} + result1030 := _t1823 + p.recordSpan(int(span_start1029), "Attribute") + return result1030 } func (p *Parser) parse_algorithm() *pb.Algorithm { - span_start1034 := int64(p.spanStart()) + span_start1037 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs1028 := []*pb.RelationId{} - cond1029 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1029 { - _t1818 := p.parse_relation_id() - item1030 := _t1818 - xs1028 = append(xs1028, item1030) - cond1029 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1031 := xs1028 - _t1819 := p.parse_script() - script1032 := _t1819 - var _t1820 []*pb.Attribute + xs1031 := []*pb.RelationId{} + cond1032 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1032 { + _t1824 := p.parse_relation_id() + item1033 := _t1824 + xs1031 = append(xs1031, item1033) + cond1032 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1034 := xs1031 + _t1825 := p.parse_script() + script1035 := _t1825 + var _t1826 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1821 := p.parse_attrs() - _t1820 = _t1821 + _t1827 := p.parse_attrs() + _t1826 = _t1827 } - attrs1033 := _t1820 + attrs1036 := _t1826 p.consumeLiteral(")") - _t1822 := attrs1033 - if attrs1033 == nil { - _t1822 = []*pb.Attribute{} + _t1828 := attrs1036 + if attrs1036 == nil { + _t1828 = []*pb.Attribute{} } - _t1823 := &pb.Algorithm{Global: relation_ids1031, Body: script1032, Attrs: _t1822} - result1035 := _t1823 - p.recordSpan(int(span_start1034), "Algorithm") - return result1035 + _t1829 := &pb.Algorithm{Global: relation_ids1034, Body: script1035, Attrs: _t1828} + result1038 := _t1829 + p.recordSpan(int(span_start1037), "Algorithm") + return result1038 } func (p *Parser) parse_script() *pb.Script { - span_start1040 := int64(p.spanStart()) + span_start1043 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("script") - xs1036 := []*pb.Construct{} - cond1037 := p.matchLookaheadLiteral("(", 0) - for cond1037 { - _t1824 := p.parse_construct() - item1038 := _t1824 - xs1036 = append(xs1036, item1038) - cond1037 = p.matchLookaheadLiteral("(", 0) - } - constructs1039 := xs1036 + xs1039 := []*pb.Construct{} + cond1040 := p.matchLookaheadLiteral("(", 0) + for cond1040 { + _t1830 := p.parse_construct() + item1041 := _t1830 + xs1039 = append(xs1039, item1041) + cond1040 = p.matchLookaheadLiteral("(", 0) + } + constructs1042 := xs1039 p.consumeLiteral(")") - _t1825 := &pb.Script{Constructs: constructs1039} - result1041 := _t1825 - p.recordSpan(int(span_start1040), "Script") - return result1041 + _t1831 := &pb.Script{Constructs: constructs1042} + result1044 := _t1831 + p.recordSpan(int(span_start1043), "Script") + return result1044 } func (p *Parser) parse_construct() *pb.Construct { - span_start1045 := int64(p.spanStart()) - var _t1826 int64 + span_start1048 := int64(p.spanStart()) + var _t1832 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1827 int64 + var _t1833 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1827 = 1 + _t1833 = 1 } else { - var _t1828 int64 + var _t1834 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1828 = 1 + _t1834 = 1 } else { - var _t1829 int64 + var _t1835 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1829 = 1 + _t1835 = 1 } else { - var _t1830 int64 + var _t1836 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1830 = 0 + _t1836 = 0 } else { - var _t1831 int64 + var _t1837 int64 if p.matchLookaheadLiteral("break", 1) { - _t1831 = 1 + _t1837 = 1 } else { - var _t1832 int64 + var _t1838 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1832 = 1 + _t1838 = 1 } else { - _t1832 = -1 + _t1838 = -1 } - _t1831 = _t1832 + _t1837 = _t1838 } - _t1830 = _t1831 + _t1836 = _t1837 } - _t1829 = _t1830 + _t1835 = _t1836 } - _t1828 = _t1829 + _t1834 = _t1835 } - _t1827 = _t1828 + _t1833 = _t1834 } - _t1826 = _t1827 + _t1832 = _t1833 } else { - _t1826 = -1 - } - prediction1042 := _t1826 - var _t1833 *pb.Construct - if prediction1042 == 1 { - _t1834 := p.parse_instruction() - instruction1044 := _t1834 - _t1835 := &pb.Construct{} - _t1835.ConstructType = &pb.Construct_Instruction{Instruction: instruction1044} - _t1833 = _t1835 + _t1832 = -1 + } + prediction1045 := _t1832 + var _t1839 *pb.Construct + if prediction1045 == 1 { + _t1840 := p.parse_instruction() + instruction1047 := _t1840 + _t1841 := &pb.Construct{} + _t1841.ConstructType = &pb.Construct_Instruction{Instruction: instruction1047} + _t1839 = _t1841 } else { - var _t1836 *pb.Construct - if prediction1042 == 0 { - _t1837 := p.parse_loop() - loop1043 := _t1837 - _t1838 := &pb.Construct{} - _t1838.ConstructType = &pb.Construct_Loop{Loop: loop1043} - _t1836 = _t1838 + var _t1842 *pb.Construct + if prediction1045 == 0 { + _t1843 := p.parse_loop() + loop1046 := _t1843 + _t1844 := &pb.Construct{} + _t1844.ConstructType = &pb.Construct_Loop{Loop: loop1046} + _t1842 = _t1844 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1833 = _t1836 + _t1839 = _t1842 } - result1046 := _t1833 - p.recordSpan(int(span_start1045), "Construct") - return result1046 + result1049 := _t1839 + p.recordSpan(int(span_start1048), "Construct") + return result1049 } func (p *Parser) parse_loop() *pb.Loop { - span_start1050 := int64(p.spanStart()) + span_start1053 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("loop") - _t1839 := p.parse_init() - init1047 := _t1839 - _t1840 := p.parse_script() - script1048 := _t1840 - var _t1841 []*pb.Attribute + _t1845 := p.parse_init() + init1050 := _t1845 + _t1846 := p.parse_script() + script1051 := _t1846 + var _t1847 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1842 := p.parse_attrs() - _t1841 = _t1842 + _t1848 := p.parse_attrs() + _t1847 = _t1848 } - attrs1049 := _t1841 + attrs1052 := _t1847 p.consumeLiteral(")") - _t1843 := attrs1049 - if attrs1049 == nil { - _t1843 = []*pb.Attribute{} + _t1849 := attrs1052 + if attrs1052 == nil { + _t1849 = []*pb.Attribute{} } - _t1844 := &pb.Loop{Init: init1047, Body: script1048, Attrs: _t1843} - result1051 := _t1844 - p.recordSpan(int(span_start1050), "Loop") - return result1051 + _t1850 := &pb.Loop{Init: init1050, Body: script1051, Attrs: _t1849} + result1054 := _t1850 + p.recordSpan(int(span_start1053), "Loop") + return result1054 } func (p *Parser) parse_init() []*pb.Instruction { p.consumeLiteral("(") p.consumeLiteral("init") - xs1052 := []*pb.Instruction{} - cond1053 := p.matchLookaheadLiteral("(", 0) - for cond1053 { - _t1845 := p.parse_instruction() - item1054 := _t1845 - xs1052 = append(xs1052, item1054) - cond1053 = p.matchLookaheadLiteral("(", 0) - } - instructions1055 := xs1052 + xs1055 := []*pb.Instruction{} + cond1056 := p.matchLookaheadLiteral("(", 0) + for cond1056 { + _t1851 := p.parse_instruction() + item1057 := _t1851 + xs1055 = append(xs1055, item1057) + cond1056 = p.matchLookaheadLiteral("(", 0) + } + instructions1058 := xs1055 p.consumeLiteral(")") - return instructions1055 + return instructions1058 } func (p *Parser) parse_instruction() *pb.Instruction { - span_start1062 := int64(p.spanStart()) - var _t1846 int64 + span_start1065 := int64(p.spanStart()) + var _t1852 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1847 int64 + var _t1853 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1847 = 1 + _t1853 = 1 } else { - var _t1848 int64 + var _t1854 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1848 = 4 + _t1854 = 4 } else { - var _t1849 int64 + var _t1855 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1849 = 3 + _t1855 = 3 } else { - var _t1850 int64 + var _t1856 int64 if p.matchLookaheadLiteral("break", 1) { - _t1850 = 2 + _t1856 = 2 } else { - var _t1851 int64 + var _t1857 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1851 = 0 + _t1857 = 0 } else { - _t1851 = -1 + _t1857 = -1 } - _t1850 = _t1851 + _t1856 = _t1857 } - _t1849 = _t1850 + _t1855 = _t1856 } - _t1848 = _t1849 + _t1854 = _t1855 } - _t1847 = _t1848 + _t1853 = _t1854 } - _t1846 = _t1847 + _t1852 = _t1853 } else { - _t1846 = -1 - } - prediction1056 := _t1846 - var _t1852 *pb.Instruction - if prediction1056 == 4 { - _t1853 := p.parse_monus_def() - monus_def1061 := _t1853 - _t1854 := &pb.Instruction{} - _t1854.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1061} - _t1852 = _t1854 + _t1852 = -1 + } + prediction1059 := _t1852 + var _t1858 *pb.Instruction + if prediction1059 == 4 { + _t1859 := p.parse_monus_def() + monus_def1064 := _t1859 + _t1860 := &pb.Instruction{} + _t1860.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1064} + _t1858 = _t1860 } else { - var _t1855 *pb.Instruction - if prediction1056 == 3 { - _t1856 := p.parse_monoid_def() - monoid_def1060 := _t1856 - _t1857 := &pb.Instruction{} - _t1857.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1060} - _t1855 = _t1857 + var _t1861 *pb.Instruction + if prediction1059 == 3 { + _t1862 := p.parse_monoid_def() + monoid_def1063 := _t1862 + _t1863 := &pb.Instruction{} + _t1863.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1063} + _t1861 = _t1863 } else { - var _t1858 *pb.Instruction - if prediction1056 == 2 { - _t1859 := p.parse_break() - break1059 := _t1859 - _t1860 := &pb.Instruction{} - _t1860.InstrType = &pb.Instruction_Break{Break: break1059} - _t1858 = _t1860 + var _t1864 *pb.Instruction + if prediction1059 == 2 { + _t1865 := p.parse_break() + break1062 := _t1865 + _t1866 := &pb.Instruction{} + _t1866.InstrType = &pb.Instruction_Break{Break: break1062} + _t1864 = _t1866 } else { - var _t1861 *pb.Instruction - if prediction1056 == 1 { - _t1862 := p.parse_upsert() - upsert1058 := _t1862 - _t1863 := &pb.Instruction{} - _t1863.InstrType = &pb.Instruction_Upsert{Upsert: upsert1058} - _t1861 = _t1863 + var _t1867 *pb.Instruction + if prediction1059 == 1 { + _t1868 := p.parse_upsert() + upsert1061 := _t1868 + _t1869 := &pb.Instruction{} + _t1869.InstrType = &pb.Instruction_Upsert{Upsert: upsert1061} + _t1867 = _t1869 } else { - var _t1864 *pb.Instruction - if prediction1056 == 0 { - _t1865 := p.parse_assign() - assign1057 := _t1865 - _t1866 := &pb.Instruction{} - _t1866.InstrType = &pb.Instruction_Assign{Assign: assign1057} - _t1864 = _t1866 + var _t1870 *pb.Instruction + if prediction1059 == 0 { + _t1871 := p.parse_assign() + assign1060 := _t1871 + _t1872 := &pb.Instruction{} + _t1872.InstrType = &pb.Instruction_Assign{Assign: assign1060} + _t1870 = _t1872 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1861 = _t1864 + _t1867 = _t1870 } - _t1858 = _t1861 + _t1864 = _t1867 } - _t1855 = _t1858 + _t1861 = _t1864 } - _t1852 = _t1855 + _t1858 = _t1861 } - result1063 := _t1852 - p.recordSpan(int(span_start1062), "Instruction") - return result1063 + result1066 := _t1858 + p.recordSpan(int(span_start1065), "Instruction") + return result1066 } func (p *Parser) parse_assign() *pb.Assign { - span_start1067 := int64(p.spanStart()) + span_start1070 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("assign") - _t1867 := p.parse_relation_id() - relation_id1064 := _t1867 - _t1868 := p.parse_abstraction() - abstraction1065 := _t1868 - var _t1869 []*pb.Attribute + _t1873 := p.parse_relation_id() + relation_id1067 := _t1873 + _t1874 := p.parse_abstraction() + abstraction1068 := _t1874 + var _t1875 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1870 := p.parse_attrs() - _t1869 = _t1870 + _t1876 := p.parse_attrs() + _t1875 = _t1876 } - attrs1066 := _t1869 + attrs1069 := _t1875 p.consumeLiteral(")") - _t1871 := attrs1066 - if attrs1066 == nil { - _t1871 = []*pb.Attribute{} + _t1877 := attrs1069 + if attrs1069 == nil { + _t1877 = []*pb.Attribute{} } - _t1872 := &pb.Assign{Name: relation_id1064, Body: abstraction1065, Attrs: _t1871} - result1068 := _t1872 - p.recordSpan(int(span_start1067), "Assign") - return result1068 + _t1878 := &pb.Assign{Name: relation_id1067, Body: abstraction1068, Attrs: _t1877} + result1071 := _t1878 + p.recordSpan(int(span_start1070), "Assign") + return result1071 } func (p *Parser) parse_upsert() *pb.Upsert { - span_start1072 := int64(p.spanStart()) + span_start1075 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1873 := p.parse_relation_id() - relation_id1069 := _t1873 - _t1874 := p.parse_abstraction_with_arity() - abstraction_with_arity1070 := _t1874 - var _t1875 []*pb.Attribute + _t1879 := p.parse_relation_id() + relation_id1072 := _t1879 + _t1880 := p.parse_abstraction_with_arity() + abstraction_with_arity1073 := _t1880 + var _t1881 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1876 := p.parse_attrs() - _t1875 = _t1876 + _t1882 := p.parse_attrs() + _t1881 = _t1882 } - attrs1071 := _t1875 + attrs1074 := _t1881 p.consumeLiteral(")") - _t1877 := attrs1071 - if attrs1071 == nil { - _t1877 = []*pb.Attribute{} + _t1883 := attrs1074 + if attrs1074 == nil { + _t1883 = []*pb.Attribute{} } - _t1878 := &pb.Upsert{Name: relation_id1069, Body: abstraction_with_arity1070[0].(*pb.Abstraction), Attrs: _t1877, ValueArity: abstraction_with_arity1070[1].(int64)} - result1073 := _t1878 - p.recordSpan(int(span_start1072), "Upsert") - return result1073 + _t1884 := &pb.Upsert{Name: relation_id1072, Body: abstraction_with_arity1073[0].(*pb.Abstraction), Attrs: _t1883, ValueArity: abstraction_with_arity1073[1].(int64)} + result1076 := _t1884 + p.recordSpan(int(span_start1075), "Upsert") + return result1076 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") - _t1879 := p.parse_bindings() - bindings1074 := _t1879 - _t1880 := p.parse_formula() - formula1075 := _t1880 + _t1885 := p.parse_bindings() + bindings1077 := _t1885 + _t1886 := p.parse_formula() + formula1078 := _t1886 p.consumeLiteral(")") - _t1881 := &pb.Abstraction{Vars: listConcat(bindings1074[0].([]*pb.Binding), bindings1074[1].([]*pb.Binding)), Value: formula1075} - return []interface{}{_t1881, int64(len(bindings1074[1].([]*pb.Binding)))} + _t1887 := &pb.Abstraction{Vars: listConcat(bindings1077[0].([]*pb.Binding), bindings1077[1].([]*pb.Binding)), Value: formula1078} + return []interface{}{_t1887, int64(len(bindings1077[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { - span_start1079 := int64(p.spanStart()) + span_start1082 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("break") - _t1882 := p.parse_relation_id() - relation_id1076 := _t1882 - _t1883 := p.parse_abstraction() - abstraction1077 := _t1883 - var _t1884 []*pb.Attribute + _t1888 := p.parse_relation_id() + relation_id1079 := _t1888 + _t1889 := p.parse_abstraction() + abstraction1080 := _t1889 + var _t1890 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1885 := p.parse_attrs() - _t1884 = _t1885 + _t1891 := p.parse_attrs() + _t1890 = _t1891 } - attrs1078 := _t1884 + attrs1081 := _t1890 p.consumeLiteral(")") - _t1886 := attrs1078 - if attrs1078 == nil { - _t1886 = []*pb.Attribute{} + _t1892 := attrs1081 + if attrs1081 == nil { + _t1892 = []*pb.Attribute{} } - _t1887 := &pb.Break{Name: relation_id1076, Body: abstraction1077, Attrs: _t1886} - result1080 := _t1887 - p.recordSpan(int(span_start1079), "Break") - return result1080 + _t1893 := &pb.Break{Name: relation_id1079, Body: abstraction1080, Attrs: _t1892} + result1083 := _t1893 + p.recordSpan(int(span_start1082), "Break") + return result1083 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { - span_start1085 := int64(p.spanStart()) + span_start1088 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1888 := p.parse_monoid() - monoid1081 := _t1888 - _t1889 := p.parse_relation_id() - relation_id1082 := _t1889 - _t1890 := p.parse_abstraction_with_arity() - abstraction_with_arity1083 := _t1890 - var _t1891 []*pb.Attribute + _t1894 := p.parse_monoid() + monoid1084 := _t1894 + _t1895 := p.parse_relation_id() + relation_id1085 := _t1895 + _t1896 := p.parse_abstraction_with_arity() + abstraction_with_arity1086 := _t1896 + var _t1897 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1892 := p.parse_attrs() - _t1891 = _t1892 + _t1898 := p.parse_attrs() + _t1897 = _t1898 } - attrs1084 := _t1891 + attrs1087 := _t1897 p.consumeLiteral(")") - _t1893 := attrs1084 - if attrs1084 == nil { - _t1893 = []*pb.Attribute{} + _t1899 := attrs1087 + if attrs1087 == nil { + _t1899 = []*pb.Attribute{} } - _t1894 := &pb.MonoidDef{Monoid: monoid1081, Name: relation_id1082, Body: abstraction_with_arity1083[0].(*pb.Abstraction), Attrs: _t1893, ValueArity: abstraction_with_arity1083[1].(int64)} - result1086 := _t1894 - p.recordSpan(int(span_start1085), "MonoidDef") - return result1086 + _t1900 := &pb.MonoidDef{Monoid: monoid1084, Name: relation_id1085, Body: abstraction_with_arity1086[0].(*pb.Abstraction), Attrs: _t1899, ValueArity: abstraction_with_arity1086[1].(int64)} + result1089 := _t1900 + p.recordSpan(int(span_start1088), "MonoidDef") + return result1089 } func (p *Parser) parse_monoid() *pb.Monoid { - span_start1092 := int64(p.spanStart()) - var _t1895 int64 + span_start1095 := int64(p.spanStart()) + var _t1901 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1896 int64 + var _t1902 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1896 = 3 + _t1902 = 3 } else { - var _t1897 int64 + var _t1903 int64 if p.matchLookaheadLiteral("or", 1) { - _t1897 = 0 + _t1903 = 0 } else { - var _t1898 int64 + var _t1904 int64 if p.matchLookaheadLiteral("min", 1) { - _t1898 = 1 + _t1904 = 1 } else { - var _t1899 int64 + var _t1905 int64 if p.matchLookaheadLiteral("max", 1) { - _t1899 = 2 + _t1905 = 2 } else { - _t1899 = -1 + _t1905 = -1 } - _t1898 = _t1899 + _t1904 = _t1905 } - _t1897 = _t1898 + _t1903 = _t1904 } - _t1896 = _t1897 + _t1902 = _t1903 } - _t1895 = _t1896 + _t1901 = _t1902 } else { - _t1895 = -1 - } - prediction1087 := _t1895 - var _t1900 *pb.Monoid - if prediction1087 == 3 { - _t1901 := p.parse_sum_monoid() - sum_monoid1091 := _t1901 - _t1902 := &pb.Monoid{} - _t1902.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1091} - _t1900 = _t1902 + _t1901 = -1 + } + prediction1090 := _t1901 + var _t1906 *pb.Monoid + if prediction1090 == 3 { + _t1907 := p.parse_sum_monoid() + sum_monoid1094 := _t1907 + _t1908 := &pb.Monoid{} + _t1908.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1094} + _t1906 = _t1908 } else { - var _t1903 *pb.Monoid - if prediction1087 == 2 { - _t1904 := p.parse_max_monoid() - max_monoid1090 := _t1904 - _t1905 := &pb.Monoid{} - _t1905.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1090} - _t1903 = _t1905 + var _t1909 *pb.Monoid + if prediction1090 == 2 { + _t1910 := p.parse_max_monoid() + max_monoid1093 := _t1910 + _t1911 := &pb.Monoid{} + _t1911.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1093} + _t1909 = _t1911 } else { - var _t1906 *pb.Monoid - if prediction1087 == 1 { - _t1907 := p.parse_min_monoid() - min_monoid1089 := _t1907 - _t1908 := &pb.Monoid{} - _t1908.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1089} - _t1906 = _t1908 + var _t1912 *pb.Monoid + if prediction1090 == 1 { + _t1913 := p.parse_min_monoid() + min_monoid1092 := _t1913 + _t1914 := &pb.Monoid{} + _t1914.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1092} + _t1912 = _t1914 } else { - var _t1909 *pb.Monoid - if prediction1087 == 0 { - _t1910 := p.parse_or_monoid() - or_monoid1088 := _t1910 - _t1911 := &pb.Monoid{} - _t1911.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1088} - _t1909 = _t1911 + var _t1915 *pb.Monoid + if prediction1090 == 0 { + _t1916 := p.parse_or_monoid() + or_monoid1091 := _t1916 + _t1917 := &pb.Monoid{} + _t1917.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1091} + _t1915 = _t1917 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1906 = _t1909 + _t1912 = _t1915 } - _t1903 = _t1906 + _t1909 = _t1912 } - _t1900 = _t1903 + _t1906 = _t1909 } - result1093 := _t1900 - p.recordSpan(int(span_start1092), "Monoid") - return result1093 + result1096 := _t1906 + p.recordSpan(int(span_start1095), "Monoid") + return result1096 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { - span_start1094 := int64(p.spanStart()) + span_start1097 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1912 := &pb.OrMonoid{} - result1095 := _t1912 - p.recordSpan(int(span_start1094), "OrMonoid") - return result1095 + _t1918 := &pb.OrMonoid{} + result1098 := _t1918 + p.recordSpan(int(span_start1097), "OrMonoid") + return result1098 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { - span_start1097 := int64(p.spanStart()) + span_start1100 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("min") - _t1913 := p.parse_type() - type1096 := _t1913 + _t1919 := p.parse_type() + type1099 := _t1919 p.consumeLiteral(")") - _t1914 := &pb.MinMonoid{Type: type1096} - result1098 := _t1914 - p.recordSpan(int(span_start1097), "MinMonoid") - return result1098 + _t1920 := &pb.MinMonoid{Type: type1099} + result1101 := _t1920 + p.recordSpan(int(span_start1100), "MinMonoid") + return result1101 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { - span_start1100 := int64(p.spanStart()) + span_start1103 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("max") - _t1915 := p.parse_type() - type1099 := _t1915 + _t1921 := p.parse_type() + type1102 := _t1921 p.consumeLiteral(")") - _t1916 := &pb.MaxMonoid{Type: type1099} - result1101 := _t1916 - p.recordSpan(int(span_start1100), "MaxMonoid") - return result1101 + _t1922 := &pb.MaxMonoid{Type: type1102} + result1104 := _t1922 + p.recordSpan(int(span_start1103), "MaxMonoid") + return result1104 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { - span_start1103 := int64(p.spanStart()) + span_start1106 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sum") - _t1917 := p.parse_type() - type1102 := _t1917 + _t1923 := p.parse_type() + type1105 := _t1923 p.consumeLiteral(")") - _t1918 := &pb.SumMonoid{Type: type1102} - result1104 := _t1918 - p.recordSpan(int(span_start1103), "SumMonoid") - return result1104 + _t1924 := &pb.SumMonoid{Type: type1105} + result1107 := _t1924 + p.recordSpan(int(span_start1106), "SumMonoid") + return result1107 } func (p *Parser) parse_monus_def() *pb.MonusDef { - span_start1109 := int64(p.spanStart()) + span_start1112 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monus") - _t1919 := p.parse_monoid() - monoid1105 := _t1919 - _t1920 := p.parse_relation_id() - relation_id1106 := _t1920 - _t1921 := p.parse_abstraction_with_arity() - abstraction_with_arity1107 := _t1921 - var _t1922 []*pb.Attribute + _t1925 := p.parse_monoid() + monoid1108 := _t1925 + _t1926 := p.parse_relation_id() + relation_id1109 := _t1926 + _t1927 := p.parse_abstraction_with_arity() + abstraction_with_arity1110 := _t1927 + var _t1928 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1923 := p.parse_attrs() - _t1922 = _t1923 + _t1929 := p.parse_attrs() + _t1928 = _t1929 } - attrs1108 := _t1922 + attrs1111 := _t1928 p.consumeLiteral(")") - _t1924 := attrs1108 - if attrs1108 == nil { - _t1924 = []*pb.Attribute{} + _t1930 := attrs1111 + if attrs1111 == nil { + _t1930 = []*pb.Attribute{} } - _t1925 := &pb.MonusDef{Monoid: monoid1105, Name: relation_id1106, Body: abstraction_with_arity1107[0].(*pb.Abstraction), Attrs: _t1924, ValueArity: abstraction_with_arity1107[1].(int64)} - result1110 := _t1925 - p.recordSpan(int(span_start1109), "MonusDef") - return result1110 + _t1931 := &pb.MonusDef{Monoid: monoid1108, Name: relation_id1109, Body: abstraction_with_arity1110[0].(*pb.Abstraction), Attrs: _t1930, ValueArity: abstraction_with_arity1110[1].(int64)} + result1113 := _t1931 + p.recordSpan(int(span_start1112), "MonusDef") + return result1113 } func (p *Parser) parse_constraint() *pb.Constraint { - span_start1115 := int64(p.spanStart()) + span_start1118 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t1926 := p.parse_relation_id() - relation_id1111 := _t1926 - _t1927 := p.parse_abstraction() - abstraction1112 := _t1927 - _t1928 := p.parse_functional_dependency_keys() - functional_dependency_keys1113 := _t1928 - _t1929 := p.parse_functional_dependency_values() - functional_dependency_values1114 := _t1929 + _t1932 := p.parse_relation_id() + relation_id1114 := _t1932 + _t1933 := p.parse_abstraction() + abstraction1115 := _t1933 + _t1934 := p.parse_functional_dependency_keys() + functional_dependency_keys1116 := _t1934 + _t1935 := p.parse_functional_dependency_values() + functional_dependency_values1117 := _t1935 p.consumeLiteral(")") - _t1930 := &pb.FunctionalDependency{Guard: abstraction1112, Keys: functional_dependency_keys1113, Values: functional_dependency_values1114} - _t1931 := &pb.Constraint{Name: relation_id1111} - _t1931.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1930} - result1116 := _t1931 - p.recordSpan(int(span_start1115), "Constraint") - return result1116 + _t1936 := &pb.FunctionalDependency{Guard: abstraction1115, Keys: functional_dependency_keys1116, Values: functional_dependency_values1117} + _t1937 := &pb.Constraint{Name: relation_id1114} + _t1937.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1936} + result1119 := _t1937 + p.recordSpan(int(span_start1118), "Constraint") + return result1119 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1117 := []*pb.Var{} - cond1118 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1118 { - _t1932 := p.parse_var() - item1119 := _t1932 - xs1117 = append(xs1117, item1119) - cond1118 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1120 := xs1117 + xs1120 := []*pb.Var{} + cond1121 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1121 { + _t1938 := p.parse_var() + item1122 := _t1938 + xs1120 = append(xs1120, item1122) + cond1121 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1123 := xs1120 p.consumeLiteral(")") - return vars1120 + return vars1123 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - xs1121 := []*pb.Var{} - cond1122 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1122 { - _t1933 := p.parse_var() - item1123 := _t1933 - xs1121 = append(xs1121, item1123) - cond1122 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1124 := xs1121 + xs1124 := []*pb.Var{} + cond1125 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1125 { + _t1939 := p.parse_var() + item1126 := _t1939 + xs1124 = append(xs1124, item1126) + cond1125 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1127 := xs1124 p.consumeLiteral(")") - return vars1124 + return vars1127 } func (p *Parser) parse_data() *pb.Data { - span_start1130 := int64(p.spanStart()) - var _t1934 int64 + span_start1133 := int64(p.spanStart()) + var _t1940 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1935 int64 + var _t1941 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1935 = 3 + _t1941 = 3 } else { - var _t1936 int64 + var _t1942 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1936 = 0 + _t1942 = 0 } else { - var _t1937 int64 + var _t1943 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1937 = 2 + _t1943 = 2 } else { - var _t1938 int64 + var _t1944 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1938 = 1 + _t1944 = 1 } else { - _t1938 = -1 + _t1944 = -1 } - _t1937 = _t1938 + _t1943 = _t1944 } - _t1936 = _t1937 + _t1942 = _t1943 } - _t1935 = _t1936 + _t1941 = _t1942 } - _t1934 = _t1935 + _t1940 = _t1941 } else { - _t1934 = -1 - } - prediction1125 := _t1934 - var _t1939 *pb.Data - if prediction1125 == 3 { - _t1940 := p.parse_iceberg_data() - iceberg_data1129 := _t1940 - _t1941 := &pb.Data{} - _t1941.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1129} - _t1939 = _t1941 + _t1940 = -1 + } + prediction1128 := _t1940 + var _t1945 *pb.Data + if prediction1128 == 3 { + _t1946 := p.parse_iceberg_data() + iceberg_data1132 := _t1946 + _t1947 := &pb.Data{} + _t1947.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1132} + _t1945 = _t1947 } else { - var _t1942 *pb.Data - if prediction1125 == 2 { - _t1943 := p.parse_csv_data() - csv_data1128 := _t1943 - _t1944 := &pb.Data{} - _t1944.DataType = &pb.Data_CsvData{CsvData: csv_data1128} - _t1942 = _t1944 + var _t1948 *pb.Data + if prediction1128 == 2 { + _t1949 := p.parse_csv_data() + csv_data1131 := _t1949 + _t1950 := &pb.Data{} + _t1950.DataType = &pb.Data_CsvData{CsvData: csv_data1131} + _t1948 = _t1950 } else { - var _t1945 *pb.Data - if prediction1125 == 1 { - _t1946 := p.parse_betree_relation() - betree_relation1127 := _t1946 - _t1947 := &pb.Data{} - _t1947.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1127} - _t1945 = _t1947 + var _t1951 *pb.Data + if prediction1128 == 1 { + _t1952 := p.parse_betree_relation() + betree_relation1130 := _t1952 + _t1953 := &pb.Data{} + _t1953.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1130} + _t1951 = _t1953 } else { - var _t1948 *pb.Data - if prediction1125 == 0 { - _t1949 := p.parse_edb() - edb1126 := _t1949 - _t1950 := &pb.Data{} - _t1950.DataType = &pb.Data_Edb{Edb: edb1126} - _t1948 = _t1950 + var _t1954 *pb.Data + if prediction1128 == 0 { + _t1955 := p.parse_edb() + edb1129 := _t1955 + _t1956 := &pb.Data{} + _t1956.DataType = &pb.Data_Edb{Edb: edb1129} + _t1954 = _t1956 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1945 = _t1948 + _t1951 = _t1954 } - _t1942 = _t1945 + _t1948 = _t1951 } - _t1939 = _t1942 + _t1945 = _t1948 } - result1131 := _t1939 - p.recordSpan(int(span_start1130), "Data") - return result1131 + result1134 := _t1945 + p.recordSpan(int(span_start1133), "Data") + return result1134 } func (p *Parser) parse_edb() *pb.EDB { - span_start1135 := int64(p.spanStart()) + span_start1138 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("edb") - _t1951 := p.parse_relation_id() - relation_id1132 := _t1951 - _t1952 := p.parse_edb_path() - edb_path1133 := _t1952 - _t1953 := p.parse_edb_types() - edb_types1134 := _t1953 + _t1957 := p.parse_relation_id() + relation_id1135 := _t1957 + _t1958 := p.parse_edb_path() + edb_path1136 := _t1958 + _t1959 := p.parse_edb_types() + edb_types1137 := _t1959 p.consumeLiteral(")") - _t1954 := &pb.EDB{TargetId: relation_id1132, Path: edb_path1133, Types: edb_types1134} - result1136 := _t1954 - p.recordSpan(int(span_start1135), "EDB") - return result1136 + _t1960 := &pb.EDB{TargetId: relation_id1135, Path: edb_path1136, Types: edb_types1137} + result1139 := _t1960 + p.recordSpan(int(span_start1138), "EDB") + return result1139 } func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") - xs1137 := []string{} - cond1138 := p.matchLookaheadTerminal("STRING", 0) - for cond1138 { - item1139 := p.consumeTerminal("STRING").Value.str - xs1137 = append(xs1137, item1139) - cond1138 = p.matchLookaheadTerminal("STRING", 0) - } - strings1140 := xs1137 + xs1140 := []string{} + cond1141 := p.matchLookaheadTerminal("STRING", 0) + for cond1141 { + item1142 := p.consumeTerminal("STRING").Value.str + xs1140 = append(xs1140, item1142) + cond1141 = p.matchLookaheadTerminal("STRING", 0) + } + strings1143 := xs1140 p.consumeLiteral("]") - return strings1140 + return strings1143 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - xs1141 := []*pb.Type{} - cond1142 := (((((((((((((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 cond1142 { - _t1955 := p.parse_type() - item1143 := _t1955 - xs1141 = append(xs1141, item1143) - cond1142 = (((((((((((((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)) - } - types1144 := xs1141 + xs1144 := []*pb.Type{} + cond1145 := (((((((((((((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 cond1145 { + _t1961 := p.parse_type() + item1146 := _t1961 + xs1144 = append(xs1144, item1146) + cond1145 = (((((((((((((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)) + } + types1147 := xs1144 p.consumeLiteral("]") - return types1144 + return types1147 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { - span_start1147 := int64(p.spanStart()) + span_start1150 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t1956 := p.parse_relation_id() - relation_id1145 := _t1956 - _t1957 := p.parse_betree_info() - betree_info1146 := _t1957 + _t1962 := p.parse_relation_id() + relation_id1148 := _t1962 + _t1963 := p.parse_betree_info() + betree_info1149 := _t1963 p.consumeLiteral(")") - _t1958 := &pb.BeTreeRelation{Name: relation_id1145, RelationInfo: betree_info1146} - result1148 := _t1958 - p.recordSpan(int(span_start1147), "BeTreeRelation") - return result1148 + _t1964 := &pb.BeTreeRelation{Name: relation_id1148, RelationInfo: betree_info1149} + result1151 := _t1964 + p.recordSpan(int(span_start1150), "BeTreeRelation") + return result1151 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { - span_start1152 := int64(p.spanStart()) + span_start1155 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t1959 := p.parse_betree_info_key_types() - betree_info_key_types1149 := _t1959 - _t1960 := p.parse_betree_info_value_types() - betree_info_value_types1150 := _t1960 - _t1961 := p.parse_config_dict() - config_dict1151 := _t1961 + _t1965 := p.parse_betree_info_key_types() + betree_info_key_types1152 := _t1965 + _t1966 := p.parse_betree_info_value_types() + betree_info_value_types1153 := _t1966 + _t1967 := p.parse_config_dict() + config_dict1154 := _t1967 p.consumeLiteral(")") - _t1962 := p.construct_betree_info(betree_info_key_types1149, betree_info_value_types1150, config_dict1151) - result1153 := _t1962 - p.recordSpan(int(span_start1152), "BeTreeInfo") - return result1153 + _t1968 := p.construct_betree_info(betree_info_key_types1152, betree_info_value_types1153, config_dict1154) + result1156 := _t1968 + p.recordSpan(int(span_start1155), "BeTreeInfo") + return result1156 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") - xs1154 := []*pb.Type{} - cond1155 := (((((((((((((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 cond1155 { - _t1963 := p.parse_type() - item1156 := _t1963 - xs1154 = append(xs1154, item1156) - cond1155 = (((((((((((((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)) - } - types1157 := xs1154 + xs1157 := []*pb.Type{} + cond1158 := (((((((((((((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 cond1158 { + _t1969 := p.parse_type() + item1159 := _t1969 + xs1157 = append(xs1157, item1159) + cond1158 = (((((((((((((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)) + } + types1160 := xs1157 p.consumeLiteral(")") - return types1157 + return types1160 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - xs1158 := []*pb.Type{} - cond1159 := (((((((((((((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 cond1159 { - _t1964 := p.parse_type() - item1160 := _t1964 - xs1158 = append(xs1158, item1160) - cond1159 = (((((((((((((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)) - } - types1161 := xs1158 + xs1161 := []*pb.Type{} + cond1162 := (((((((((((((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 cond1162 { + _t1970 := p.parse_type() + item1163 := _t1970 + xs1161 = append(xs1161, item1163) + cond1162 = (((((((((((((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)) + } + types1164 := xs1161 p.consumeLiteral(")") - return types1161 + return types1164 } func (p *Parser) parse_csv_data() *pb.CSVData { - span_start1166 := int64(p.spanStart()) + span_start1169 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t1965 := p.parse_csvlocator() - csvlocator1162 := _t1965 - _t1966 := p.parse_csv_config() - csv_config1163 := _t1966 - _t1967 := p.parse_gnf_columns() - gnf_columns1164 := _t1967 - _t1968 := p.parse_csv_asof() - csv_asof1165 := _t1968 + _t1971 := p.parse_csvlocator() + csvlocator1165 := _t1971 + _t1972 := p.parse_csv_config() + csv_config1166 := _t1972 + _t1973 := p.parse_gnf_columns() + gnf_columns1167 := _t1973 + _t1974 := p.parse_csv_asof() + csv_asof1168 := _t1974 p.consumeLiteral(")") - _t1969 := &pb.CSVData{Locator: csvlocator1162, Config: csv_config1163, Columns: gnf_columns1164, Asof: csv_asof1165} - result1167 := _t1969 - p.recordSpan(int(span_start1166), "CSVData") - return result1167 + _t1975 := &pb.CSVData{Locator: csvlocator1165, Config: csv_config1166, Columns: gnf_columns1167, Asof: csv_asof1168} + result1170 := _t1975 + p.recordSpan(int(span_start1169), "CSVData") + return result1170 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { - span_start1170 := int64(p.spanStart()) + span_start1173 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t1970 []string + var _t1976 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t1971 := p.parse_csv_locator_paths() - _t1970 = _t1971 + _t1977 := p.parse_csv_locator_paths() + _t1976 = _t1977 } - csv_locator_paths1168 := _t1970 - var _t1972 *string + csv_locator_paths1171 := _t1976 + var _t1978 *string if p.matchLookaheadLiteral("(", 0) { - _t1973 := p.parse_csv_locator_inline_data() - _t1972 = ptr(_t1973) + _t1979 := p.parse_csv_locator_inline_data() + _t1978 = ptr(_t1979) } - csv_locator_inline_data1169 := _t1972 + csv_locator_inline_data1172 := _t1978 p.consumeLiteral(")") - _t1974 := csv_locator_paths1168 - if csv_locator_paths1168 == nil { - _t1974 = []string{} + _t1980 := csv_locator_paths1171 + if csv_locator_paths1171 == nil { + _t1980 = []string{} } - _t1975 := &pb.CSVLocator{Paths: _t1974, InlineData: []byte(deref(csv_locator_inline_data1169, ""))} - result1171 := _t1975 - p.recordSpan(int(span_start1170), "CSVLocator") - return result1171 + _t1981 := &pb.CSVLocator{Paths: _t1980, InlineData: []byte(deref(csv_locator_inline_data1172, ""))} + result1174 := _t1981 + p.recordSpan(int(span_start1173), "CSVLocator") + return result1174 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") - xs1172 := []string{} - cond1173 := p.matchLookaheadTerminal("STRING", 0) - for cond1173 { - item1174 := p.consumeTerminal("STRING").Value.str - xs1172 = append(xs1172, item1174) - cond1173 = p.matchLookaheadTerminal("STRING", 0) - } - strings1175 := xs1172 + xs1175 := []string{} + cond1176 := p.matchLookaheadTerminal("STRING", 0) + for cond1176 { + item1177 := p.consumeTerminal("STRING").Value.str + xs1175 = append(xs1175, item1177) + cond1176 = p.matchLookaheadTerminal("STRING", 0) + } + strings1178 := xs1175 p.consumeLiteral(")") - return strings1175 + return strings1178 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - formatted_string1176 := p.consumeTerminal("STRING").Value.str + formatted_string1179 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return formatted_string1176 + return formatted_string1179 } func (p *Parser) parse_csv_config() *pb.CSVConfig { - span_start1179 := int64(p.spanStart()) + span_start1182 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t1976 := p.parse_config_dict() - config_dict1177 := _t1976 - var _t1977 [][]interface{} + _t1982 := p.parse_config_dict() + config_dict1180 := _t1982 + var _t1983 [][]interface{} if p.matchLookaheadLiteral("(", 0) { - _t1978 := p.parse__storage_integration() - _t1977 = _t1978 + _t1984 := p.parse__storage_integration() + _t1983 = _t1984 } - _storage_integration1178 := _t1977 + _storage_integration1181 := _t1983 p.consumeLiteral(")") - _t1979 := p.construct_csv_config(config_dict1177, _storage_integration1178) - result1180 := _t1979 - p.recordSpan(int(span_start1179), "CSVConfig") - return result1180 + _t1985 := p.construct_csv_config(config_dict1180, _storage_integration1181) + result1183 := _t1985 + p.recordSpan(int(span_start1182), "CSVConfig") + return result1183 } func (p *Parser) parse__storage_integration() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("storage_integration") - _t1980 := p.parse_config_dict() - config_dict1181 := _t1980 + _t1986 := p.parse_config_dict() + config_dict1184 := _t1986 p.consumeLiteral(")") - return config_dict1181 + return config_dict1184 } func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1182 := []*pb.GNFColumn{} - cond1183 := p.matchLookaheadLiteral("(", 0) - for cond1183 { - _t1981 := p.parse_gnf_column() - item1184 := _t1981 - xs1182 = append(xs1182, item1184) - cond1183 = p.matchLookaheadLiteral("(", 0) - } - gnf_columns1185 := xs1182 + xs1185 := []*pb.GNFColumn{} + cond1186 := p.matchLookaheadLiteral("(", 0) + for cond1186 { + _t1987 := p.parse_gnf_column() + item1187 := _t1987 + xs1185 = append(xs1185, item1187) + cond1186 = p.matchLookaheadLiteral("(", 0) + } + gnf_columns1188 := xs1185 p.consumeLiteral(")") - return gnf_columns1185 + return gnf_columns1188 } func (p *Parser) parse_gnf_column() *pb.GNFColumn { - span_start1192 := int64(p.spanStart()) + span_start1195 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - _t1982 := p.parse_gnf_column_path() - gnf_column_path1186 := _t1982 - var _t1983 *pb.RelationId + _t1988 := p.parse_gnf_column_path() + gnf_column_path1189 := _t1988 + var _t1989 *pb.RelationId if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t1984 := p.parse_relation_id() - _t1983 = _t1984 + _t1990 := p.parse_relation_id() + _t1989 = _t1990 } - relation_id1187 := _t1983 + relation_id1190 := _t1989 p.consumeLiteral("[") - xs1188 := []*pb.Type{} - cond1189 := (((((((((((((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 cond1189 { - _t1985 := p.parse_type() - item1190 := _t1985 - xs1188 = append(xs1188, item1190) - cond1189 = (((((((((((((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)) - } - types1191 := xs1188 + xs1191 := []*pb.Type{} + cond1192 := (((((((((((((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 cond1192 { + _t1991 := p.parse_type() + item1193 := _t1991 + xs1191 = append(xs1191, item1193) + cond1192 = (((((((((((((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)) + } + types1194 := xs1191 p.consumeLiteral("]") p.consumeLiteral(")") - _t1986 := &pb.GNFColumn{ColumnPath: gnf_column_path1186, TargetId: relation_id1187, Types: types1191} - result1193 := _t1986 - p.recordSpan(int(span_start1192), "GNFColumn") - return result1193 + _t1992 := &pb.GNFColumn{ColumnPath: gnf_column_path1189, TargetId: relation_id1190, Types: types1194} + result1196 := _t1992 + p.recordSpan(int(span_start1195), "GNFColumn") + return result1196 } func (p *Parser) parse_gnf_column_path() []string { - var _t1987 int64 + var _t1993 int64 if p.matchLookaheadLiteral("[", 0) { - _t1987 = 1 + _t1993 = 1 } else { - var _t1988 int64 + var _t1994 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1988 = 0 + _t1994 = 0 } else { - _t1988 = -1 + _t1994 = -1 } - _t1987 = _t1988 + _t1993 = _t1994 } - prediction1194 := _t1987 - var _t1989 []string - if prediction1194 == 1 { + prediction1197 := _t1993 + var _t1995 []string + if prediction1197 == 1 { p.consumeLiteral("[") - xs1196 := []string{} - cond1197 := p.matchLookaheadTerminal("STRING", 0) - for cond1197 { - item1198 := p.consumeTerminal("STRING").Value.str - xs1196 = append(xs1196, item1198) - cond1197 = p.matchLookaheadTerminal("STRING", 0) + xs1199 := []string{} + cond1200 := p.matchLookaheadTerminal("STRING", 0) + for cond1200 { + item1201 := p.consumeTerminal("STRING").Value.str + xs1199 = append(xs1199, item1201) + cond1200 = p.matchLookaheadTerminal("STRING", 0) } - strings1199 := xs1196 + strings1202 := xs1199 p.consumeLiteral("]") - _t1989 = strings1199 + _t1995 = strings1202 } else { - var _t1990 []string - if prediction1194 == 0 { - string1195 := p.consumeTerminal("STRING").Value.str - _ = string1195 - _t1990 = []string{string1195} + var _t1996 []string + if prediction1197 == 0 { + string1198 := p.consumeTerminal("STRING").Value.str + _ = string1198 + _t1996 = []string{string1198} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1989 = _t1990 + _t1995 = _t1996 } - return _t1989 + return _t1995 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - string1200 := p.consumeTerminal("STRING").Value.str + string1203 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1200 + return string1203 } func (p *Parser) parse_iceberg_data() *pb.IcebergData { - span_start1207 := int64(p.spanStart()) + span_start1210 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_data") - _t1991 := p.parse_iceberg_locator() - iceberg_locator1201 := _t1991 - _t1992 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1202 := _t1992 - _t1993 := p.parse_gnf_columns() - gnf_columns1203 := _t1993 - var _t1994 *string + _t1997 := p.parse_iceberg_locator() + iceberg_locator1204 := _t1997 + _t1998 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1205 := _t1998 + _t1999 := p.parse_gnf_columns() + gnf_columns1206 := _t1999 + var _t2000 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("from_snapshot", 1)) { - _t1995 := p.parse_iceberg_from_snapshot() - _t1994 = ptr(_t1995) + _t2001 := p.parse_iceberg_from_snapshot() + _t2000 = ptr(_t2001) } - iceberg_from_snapshot1204 := _t1994 - var _t1996 *string + iceberg_from_snapshot1207 := _t2000 + var _t2002 *string if p.matchLookaheadLiteral("(", 0) { - _t1997 := p.parse_iceberg_to_snapshot() - _t1996 = ptr(_t1997) + _t2003 := p.parse_iceberg_to_snapshot() + _t2002 = ptr(_t2003) } - iceberg_to_snapshot1205 := _t1996 - _t1998 := p.parse_boolean_value() - boolean_value1206 := _t1998 + iceberg_to_snapshot1208 := _t2002 + _t2004 := p.parse_boolean_value() + boolean_value1209 := _t2004 p.consumeLiteral(")") - _t1999 := p.construct_iceberg_data(iceberg_locator1201, iceberg_catalog_config1202, gnf_columns1203, iceberg_from_snapshot1204, iceberg_to_snapshot1205, boolean_value1206) - result1208 := _t1999 - p.recordSpan(int(span_start1207), "IcebergData") - return result1208 + _t2005 := p.construct_iceberg_data(iceberg_locator1204, iceberg_catalog_config1205, gnf_columns1206, iceberg_from_snapshot1207, iceberg_to_snapshot1208, boolean_value1209) + result1211 := _t2005 + p.recordSpan(int(span_start1210), "IcebergData") + return result1211 } func (p *Parser) parse_iceberg_locator() *pb.IcebergLocator { - span_start1212 := int64(p.spanStart()) + span_start1215 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_locator") - _t2000 := p.parse_iceberg_locator_table_name() - iceberg_locator_table_name1209 := _t2000 - _t2001 := p.parse_iceberg_locator_namespace() - iceberg_locator_namespace1210 := _t2001 - _t2002 := p.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1211 := _t2002 + _t2006 := p.parse_iceberg_locator_table_name() + iceberg_locator_table_name1212 := _t2006 + _t2007 := p.parse_iceberg_locator_namespace() + iceberg_locator_namespace1213 := _t2007 + _t2008 := p.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1214 := _t2008 p.consumeLiteral(")") - _t2003 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1209, Namespace: iceberg_locator_namespace1210, Warehouse: iceberg_locator_warehouse1211} - result1213 := _t2003 - p.recordSpan(int(span_start1212), "IcebergLocator") - return result1213 + _t2009 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1212, Namespace: iceberg_locator_namespace1213, Warehouse: iceberg_locator_warehouse1214} + result1216 := _t2009 + p.recordSpan(int(span_start1215), "IcebergLocator") + return result1216 } func (p *Parser) parse_iceberg_locator_table_name() string { p.consumeLiteral("(") p.consumeLiteral("table_name") - string1214 := p.consumeTerminal("STRING").Value.str + string1217 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1214 + return string1217 } func (p *Parser) parse_iceberg_locator_namespace() []string { p.consumeLiteral("(") p.consumeLiteral("namespace") - 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 + xs1218 := []string{} + cond1219 := p.matchLookaheadTerminal("STRING", 0) + for cond1219 { + item1220 := p.consumeTerminal("STRING").Value.str + xs1218 = append(xs1218, item1220) + cond1219 = p.matchLookaheadTerminal("STRING", 0) + } + strings1221 := xs1218 p.consumeLiteral(")") - return strings1218 + return strings1221 } func (p *Parser) parse_iceberg_locator_warehouse() string { p.consumeLiteral("(") p.consumeLiteral("warehouse") - string1219 := p.consumeTerminal("STRING").Value.str + string1222 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1219 + return string1222 } func (p *Parser) parse_iceberg_catalog_config() *pb.IcebergCatalogConfig { - span_start1224 := int64(p.spanStart()) + span_start1227 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_catalog_config") - _t2004 := p.parse_iceberg_catalog_uri() - iceberg_catalog_uri1220 := _t2004 - var _t2005 *string + _t2010 := p.parse_iceberg_catalog_uri() + iceberg_catalog_uri1223 := _t2010 + var _t2011 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("scope", 1)) { - _t2006 := p.parse_iceberg_catalog_config_scope() - _t2005 = ptr(_t2006) - } - iceberg_catalog_config_scope1221 := _t2005 - _t2007 := p.parse_iceberg_properties() - iceberg_properties1222 := _t2007 - _t2008 := p.parse_iceberg_auth_properties() - iceberg_auth_properties1223 := _t2008 + _t2012 := p.parse_iceberg_catalog_config_scope() + _t2011 = ptr(_t2012) + } + iceberg_catalog_config_scope1224 := _t2011 + _t2013 := p.parse_iceberg_properties() + iceberg_properties1225 := _t2013 + _t2014 := p.parse_iceberg_auth_properties() + iceberg_auth_properties1226 := _t2014 p.consumeLiteral(")") - _t2009 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1220, iceberg_catalog_config_scope1221, iceberg_properties1222, iceberg_auth_properties1223) - result1225 := _t2009 - p.recordSpan(int(span_start1224), "IcebergCatalogConfig") - return result1225 + _t2015 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1223, iceberg_catalog_config_scope1224, iceberg_properties1225, iceberg_auth_properties1226) + result1228 := _t2015 + p.recordSpan(int(span_start1227), "IcebergCatalogConfig") + return result1228 } func (p *Parser) parse_iceberg_catalog_uri() string { p.consumeLiteral("(") p.consumeLiteral("catalog_uri") - string1226 := p.consumeTerminal("STRING").Value.str + string1229 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1226 + return string1229 } func (p *Parser) parse_iceberg_catalog_config_scope() string { p.consumeLiteral("(") p.consumeLiteral("scope") - string1227 := p.consumeTerminal("STRING").Value.str + string1230 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1227 + return string1230 } func (p *Parser) parse_iceberg_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("properties") - xs1228 := [][]interface{}{} - cond1229 := p.matchLookaheadLiteral("(", 0) - for cond1229 { - _t2010 := p.parse_iceberg_property_entry() - item1230 := _t2010 - xs1228 = append(xs1228, item1230) - cond1229 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1231 := xs1228 + xs1231 := [][]interface{}{} + cond1232 := p.matchLookaheadLiteral("(", 0) + for cond1232 { + _t2016 := p.parse_iceberg_property_entry() + item1233 := _t2016 + xs1231 = append(xs1231, item1233) + cond1232 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1234 := xs1231 p.consumeLiteral(")") - return iceberg_property_entrys1231 + return iceberg_property_entrys1234 } func (p *Parser) parse_iceberg_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1232 := p.consumeTerminal("STRING").Value.str - string_31233 := p.consumeTerminal("STRING").Value.str + string1235 := p.consumeTerminal("STRING").Value.str + string_31236 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1232, string_31233} + return []interface{}{string1235, string_31236} } func (p *Parser) parse_iceberg_auth_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("auth_properties") - xs1234 := [][]interface{}{} - cond1235 := p.matchLookaheadLiteral("(", 0) - for cond1235 { - _t2011 := p.parse_iceberg_masked_property_entry() - item1236 := _t2011 - xs1234 = append(xs1234, item1236) - cond1235 = p.matchLookaheadLiteral("(", 0) - } - iceberg_masked_property_entrys1237 := xs1234 + xs1237 := [][]interface{}{} + cond1238 := p.matchLookaheadLiteral("(", 0) + for cond1238 { + _t2017 := p.parse_iceberg_masked_property_entry() + item1239 := _t2017 + xs1237 = append(xs1237, item1239) + cond1238 = p.matchLookaheadLiteral("(", 0) + } + iceberg_masked_property_entrys1240 := xs1237 p.consumeLiteral(")") - return iceberg_masked_property_entrys1237 + return iceberg_masked_property_entrys1240 } func (p *Parser) parse_iceberg_masked_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1238 := p.consumeTerminal("STRING").Value.str - string_31239 := p.consumeTerminal("STRING").Value.str + string1241 := p.consumeTerminal("STRING").Value.str + string_31242 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1238, string_31239} + return []interface{}{string1241, string_31242} } func (p *Parser) parse_iceberg_from_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("from_snapshot") - string1240 := p.consumeTerminal("STRING").Value.str + string1243 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1240 + return string1243 } func (p *Parser) parse_iceberg_to_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("to_snapshot") - string1241 := p.consumeTerminal("STRING").Value.str + string1244 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1241 + return string1244 } func (p *Parser) parse_undefine() *pb.Undefine { - span_start1243 := int64(p.spanStart()) + span_start1246 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("undefine") - _t2012 := p.parse_fragment_id() - fragment_id1242 := _t2012 + _t2018 := p.parse_fragment_id() + fragment_id1245 := _t2018 p.consumeLiteral(")") - _t2013 := &pb.Undefine{FragmentId: fragment_id1242} - result1244 := _t2013 - p.recordSpan(int(span_start1243), "Undefine") - return result1244 + _t2019 := &pb.Undefine{FragmentId: fragment_id1245} + result1247 := _t2019 + p.recordSpan(int(span_start1246), "Undefine") + return result1247 } func (p *Parser) parse_context() *pb.Context { - span_start1249 := int64(p.spanStart()) + span_start1252 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("context") - xs1245 := []*pb.RelationId{} - cond1246 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1246 { - _t2014 := p.parse_relation_id() - item1247 := _t2014 - xs1245 = append(xs1245, item1247) - cond1246 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1248 := xs1245 + xs1248 := []*pb.RelationId{} + cond1249 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + for cond1249 { + _t2020 := p.parse_relation_id() + item1250 := _t2020 + xs1248 = append(xs1248, item1250) + cond1249 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) + } + relation_ids1251 := xs1248 p.consumeLiteral(")") - _t2015 := &pb.Context{Relations: relation_ids1248} - result1250 := _t2015 - p.recordSpan(int(span_start1249), "Context") - return result1250 + _t2021 := &pb.Context{Relations: relation_ids1251} + result1253 := _t2021 + p.recordSpan(int(span_start1252), "Context") + return result1253 } func (p *Parser) parse_snapshot() *pb.Snapshot { - span_start1256 := int64(p.spanStart()) + span_start1259 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t2016 := p.parse_edb_path() - edb_path1251 := _t2016 - xs1252 := []*pb.SnapshotMapping{} - cond1253 := p.matchLookaheadLiteral("[", 0) - for cond1253 { - _t2017 := p.parse_snapshot_mapping() - item1254 := _t2017 - xs1252 = append(xs1252, item1254) - cond1253 = p.matchLookaheadLiteral("[", 0) - } - snapshot_mappings1255 := xs1252 + _t2022 := p.parse_edb_path() + edb_path1254 := _t2022 + xs1255 := []*pb.SnapshotMapping{} + cond1256 := p.matchLookaheadLiteral("[", 0) + for cond1256 { + _t2023 := p.parse_snapshot_mapping() + item1257 := _t2023 + xs1255 = append(xs1255, item1257) + cond1256 = p.matchLookaheadLiteral("[", 0) + } + snapshot_mappings1258 := xs1255 p.consumeLiteral(")") - _t2018 := &pb.Snapshot{Prefix: edb_path1251, Mappings: snapshot_mappings1255} - result1257 := _t2018 - p.recordSpan(int(span_start1256), "Snapshot") - return result1257 + _t2024 := &pb.Snapshot{Prefix: edb_path1254, Mappings: snapshot_mappings1258} + result1260 := _t2024 + p.recordSpan(int(span_start1259), "Snapshot") + return result1260 } func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { - span_start1260 := int64(p.spanStart()) - _t2019 := p.parse_edb_path() - edb_path1258 := _t2019 - _t2020 := p.parse_relation_id() - relation_id1259 := _t2020 - _t2021 := &pb.SnapshotMapping{DestinationPath: edb_path1258, SourceRelation: relation_id1259} - result1261 := _t2021 - p.recordSpan(int(span_start1260), "SnapshotMapping") - return result1261 + span_start1263 := int64(p.spanStart()) + _t2025 := p.parse_edb_path() + edb_path1261 := _t2025 + _t2026 := p.parse_relation_id() + relation_id1262 := _t2026 + _t2027 := &pb.SnapshotMapping{DestinationPath: edb_path1261, SourceRelation: relation_id1262} + result1264 := _t2027 + p.recordSpan(int(span_start1263), "SnapshotMapping") + return result1264 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") - xs1262 := []*pb.Read{} - cond1263 := p.matchLookaheadLiteral("(", 0) - for cond1263 { - _t2022 := p.parse_read() - item1264 := _t2022 - xs1262 = append(xs1262, item1264) - cond1263 = p.matchLookaheadLiteral("(", 0) - } - reads1265 := xs1262 + xs1265 := []*pb.Read{} + cond1266 := p.matchLookaheadLiteral("(", 0) + for cond1266 { + _t2028 := p.parse_read() + item1267 := _t2028 + xs1265 = append(xs1265, item1267) + cond1266 = p.matchLookaheadLiteral("(", 0) + } + reads1268 := xs1265 p.consumeLiteral(")") - return reads1265 + return reads1268 } func (p *Parser) parse_read() *pb.Read { - span_start1272 := int64(p.spanStart()) - var _t2023 int64 + span_start1275 := int64(p.spanStart()) + var _t2029 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2024 int64 + var _t2030 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t2024 = 2 + _t2030 = 2 } else { - var _t2025 int64 + var _t2031 int64 if p.matchLookaheadLiteral("output", 1) { - _t2025 = 1 + _t2031 = 1 } else { - var _t2026 int64 + var _t2032 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2026 = 4 + _t2032 = 4 } else { - var _t2027 int64 + var _t2033 int64 if p.matchLookaheadLiteral("export", 1) { - _t2027 = 4 + _t2033 = 4 } else { - var _t2028 int64 + var _t2034 int64 if p.matchLookaheadLiteral("demand", 1) { - _t2028 = 0 + _t2034 = 0 } else { - var _t2029 int64 + var _t2035 int64 if p.matchLookaheadLiteral("abort", 1) { - _t2029 = 3 + _t2035 = 3 } else { - _t2029 = -1 + _t2035 = -1 } - _t2028 = _t2029 + _t2034 = _t2035 } - _t2027 = _t2028 + _t2033 = _t2034 } - _t2026 = _t2027 + _t2032 = _t2033 } - _t2025 = _t2026 + _t2031 = _t2032 } - _t2024 = _t2025 + _t2030 = _t2031 } - _t2023 = _t2024 + _t2029 = _t2030 } else { - _t2023 = -1 - } - prediction1266 := _t2023 - var _t2030 *pb.Read - if prediction1266 == 4 { - _t2031 := p.parse_export() - export1271 := _t2031 - _t2032 := &pb.Read{} - _t2032.ReadType = &pb.Read_Export{Export: export1271} - _t2030 = _t2032 + _t2029 = -1 + } + prediction1269 := _t2029 + var _t2036 *pb.Read + if prediction1269 == 4 { + _t2037 := p.parse_export() + export1274 := _t2037 + _t2038 := &pb.Read{} + _t2038.ReadType = &pb.Read_Export{Export: export1274} + _t2036 = _t2038 } else { - var _t2033 *pb.Read - if prediction1266 == 3 { - _t2034 := p.parse_abort() - abort1270 := _t2034 - _t2035 := &pb.Read{} - _t2035.ReadType = &pb.Read_Abort{Abort: abort1270} - _t2033 = _t2035 + var _t2039 *pb.Read + if prediction1269 == 3 { + _t2040 := p.parse_abort() + abort1273 := _t2040 + _t2041 := &pb.Read{} + _t2041.ReadType = &pb.Read_Abort{Abort: abort1273} + _t2039 = _t2041 } else { - var _t2036 *pb.Read - if prediction1266 == 2 { - _t2037 := p.parse_what_if() - what_if1269 := _t2037 - _t2038 := &pb.Read{} - _t2038.ReadType = &pb.Read_WhatIf{WhatIf: what_if1269} - _t2036 = _t2038 + var _t2042 *pb.Read + if prediction1269 == 2 { + _t2043 := p.parse_what_if() + what_if1272 := _t2043 + _t2044 := &pb.Read{} + _t2044.ReadType = &pb.Read_WhatIf{WhatIf: what_if1272} + _t2042 = _t2044 } else { - var _t2039 *pb.Read - if prediction1266 == 1 { - _t2040 := p.parse_output() - output1268 := _t2040 - _t2041 := &pb.Read{} - _t2041.ReadType = &pb.Read_Output{Output: output1268} - _t2039 = _t2041 + var _t2045 *pb.Read + if prediction1269 == 1 { + _t2046 := p.parse_output() + output1271 := _t2046 + _t2047 := &pb.Read{} + _t2047.ReadType = &pb.Read_Output{Output: output1271} + _t2045 = _t2047 } else { - var _t2042 *pb.Read - if prediction1266 == 0 { - _t2043 := p.parse_demand() - demand1267 := _t2043 - _t2044 := &pb.Read{} - _t2044.ReadType = &pb.Read_Demand{Demand: demand1267} - _t2042 = _t2044 + var _t2048 *pb.Read + if prediction1269 == 0 { + _t2049 := p.parse_demand() + demand1270 := _t2049 + _t2050 := &pb.Read{} + _t2050.ReadType = &pb.Read_Demand{Demand: demand1270} + _t2048 = _t2050 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2039 = _t2042 + _t2045 = _t2048 } - _t2036 = _t2039 + _t2042 = _t2045 } - _t2033 = _t2036 + _t2039 = _t2042 } - _t2030 = _t2033 + _t2036 = _t2039 } - result1273 := _t2030 - p.recordSpan(int(span_start1272), "Read") - return result1273 + result1276 := _t2036 + p.recordSpan(int(span_start1275), "Read") + return result1276 } func (p *Parser) parse_demand() *pb.Demand { - span_start1275 := int64(p.spanStart()) + span_start1278 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("demand") - _t2045 := p.parse_relation_id() - relation_id1274 := _t2045 + _t2051 := p.parse_relation_id() + relation_id1277 := _t2051 p.consumeLiteral(")") - _t2046 := &pb.Demand{RelationId: relation_id1274} - result1276 := _t2046 - p.recordSpan(int(span_start1275), "Demand") - return result1276 + _t2052 := &pb.Demand{RelationId: relation_id1277} + result1279 := _t2052 + p.recordSpan(int(span_start1278), "Demand") + return result1279 } func (p *Parser) parse_output() *pb.Output { - span_start1279 := int64(p.spanStart()) + span_start1282 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("output") - _t2047 := p.parse_name() - name1277 := _t2047 - _t2048 := p.parse_relation_id() - relation_id1278 := _t2048 + _t2053 := p.parse_name() + name1280 := _t2053 + _t2054 := p.parse_relation_id() + relation_id1281 := _t2054 p.consumeLiteral(")") - _t2049 := &pb.Output{Name: name1277, RelationId: relation_id1278} - result1280 := _t2049 - p.recordSpan(int(span_start1279), "Output") - return result1280 + _t2055 := &pb.Output{Name: name1280, RelationId: relation_id1281} + result1283 := _t2055 + p.recordSpan(int(span_start1282), "Output") + return result1283 } func (p *Parser) parse_what_if() *pb.WhatIf { - span_start1283 := int64(p.spanStart()) + span_start1286 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("what_if") - _t2050 := p.parse_name() - name1281 := _t2050 - _t2051 := p.parse_epoch() - epoch1282 := _t2051 + _t2056 := p.parse_name() + name1284 := _t2056 + _t2057 := p.parse_epoch() + epoch1285 := _t2057 p.consumeLiteral(")") - _t2052 := &pb.WhatIf{Branch: name1281, Epoch: epoch1282} - result1284 := _t2052 - p.recordSpan(int(span_start1283), "WhatIf") - return result1284 + _t2058 := &pb.WhatIf{Branch: name1284, Epoch: epoch1285} + result1287 := _t2058 + p.recordSpan(int(span_start1286), "WhatIf") + return result1287 } func (p *Parser) parse_abort() *pb.Abort { - span_start1287 := int64(p.spanStart()) + span_start1290 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("abort") - var _t2053 *string + var _t2059 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2054 := p.parse_name() - _t2053 = ptr(_t2054) + _t2060 := p.parse_name() + _t2059 = ptr(_t2060) } - name1285 := _t2053 - _t2055 := p.parse_relation_id() - relation_id1286 := _t2055 + name1288 := _t2059 + _t2061 := p.parse_relation_id() + relation_id1289 := _t2061 p.consumeLiteral(")") - _t2056 := &pb.Abort{Name: deref(name1285, "abort"), RelationId: relation_id1286} - result1288 := _t2056 - p.recordSpan(int(span_start1287), "Abort") - return result1288 + _t2062 := &pb.Abort{Name: deref(name1288, "abort"), RelationId: relation_id1289} + result1291 := _t2062 + p.recordSpan(int(span_start1290), "Abort") + return result1291 } func (p *Parser) parse_export() *pb.Export { - span_start1292 := int64(p.spanStart()) - var _t2057 int64 + span_start1295 := int64(p.spanStart()) + var _t2063 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2058 int64 + var _t2064 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2058 = 1 + _t2064 = 1 } else { - var _t2059 int64 + var _t2065 int64 if p.matchLookaheadLiteral("export", 1) { - _t2059 = 0 + _t2065 = 0 } else { - _t2059 = -1 + _t2065 = -1 } - _t2058 = _t2059 + _t2064 = _t2065 } - _t2057 = _t2058 + _t2063 = _t2064 } else { - _t2057 = -1 + _t2063 = -1 } - prediction1289 := _t2057 - var _t2060 *pb.Export - if prediction1289 == 1 { + prediction1292 := _t2063 + var _t2066 *pb.Export + if prediction1292 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_iceberg") - _t2061 := p.parse_export_iceberg_config() - export_iceberg_config1291 := _t2061 + _t2067 := p.parse_export_iceberg_config() + export_iceberg_config1294 := _t2067 p.consumeLiteral(")") - _t2062 := &pb.Export{} - _t2062.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1291} - _t2060 = _t2062 + _t2068 := &pb.Export{} + _t2068.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1294} + _t2066 = _t2068 } else { - var _t2063 *pb.Export - if prediction1289 == 0 { + var _t2069 *pb.Export + if prediction1292 == 0 { p.consumeLiteral("(") p.consumeLiteral("export") - _t2064 := p.parse_export_csv_config() - export_csv_config1290 := _t2064 + _t2070 := p.parse_export_csv_config() + export_csv_config1293 := _t2070 p.consumeLiteral(")") - _t2065 := &pb.Export{} - _t2065.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1290} - _t2063 = _t2065 + _t2071 := &pb.Export{} + _t2071.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1293} + _t2069 = _t2071 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2060 = _t2063 + _t2066 = _t2069 } - result1293 := _t2060 - p.recordSpan(int(span_start1292), "Export") - return result1293 + result1296 := _t2066 + p.recordSpan(int(span_start1295), "Export") + return result1296 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1301 := int64(p.spanStart()) - var _t2066 int64 + span_start1304 := int64(p.spanStart()) + var _t2072 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2067 int64 + var _t2073 int64 if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2067 = 0 + _t2073 = 0 } else { - var _t2068 int64 + var _t2074 int64 if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2068 = 1 + _t2074 = 1 } else { - _t2068 = -1 + _t2074 = -1 } - _t2067 = _t2068 + _t2073 = _t2074 } - _t2066 = _t2067 + _t2072 = _t2073 } else { - _t2066 = -1 + _t2072 = -1 } - prediction1294 := _t2066 - var _t2069 *pb.ExportCSVConfig - if prediction1294 == 1 { + prediction1297 := _t2072 + var _t2075 *pb.ExportCSVConfig + if prediction1297 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t2070 := p.parse_export_csv_path() - export_csv_path1298 := _t2070 - _t2071 := p.parse_export_csv_columns_list() - export_csv_columns_list1299 := _t2071 - _t2072 := p.parse_config_dict() - config_dict1300 := _t2072 + _t2076 := p.parse_export_csv_path() + export_csv_path1301 := _t2076 + _t2077 := p.parse_export_csv_columns_list() + export_csv_columns_list1302 := _t2077 + _t2078 := p.parse_config_dict() + config_dict1303 := _t2078 p.consumeLiteral(")") - _t2073 := p.construct_export_csv_config(export_csv_path1298, export_csv_columns_list1299, config_dict1300) - _t2069 = _t2073 + _t2079 := p.construct_export_csv_config(export_csv_path1301, export_csv_columns_list1302, config_dict1303) + _t2075 = _t2079 } else { - var _t2074 *pb.ExportCSVConfig - if prediction1294 == 0 { + var _t2080 *pb.ExportCSVConfig + if prediction1297 == 0 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config_v2") - _t2075 := p.parse_export_csv_path() - export_csv_path1295 := _t2075 - _t2076 := p.parse_export_csv_source() - export_csv_source1296 := _t2076 - _t2077 := p.parse_csv_config() - csv_config1297 := _t2077 + _t2081 := p.parse_export_csv_output_location() + export_csv_output_location1298 := _t2081 + _t2082 := p.parse_export_csv_source() + export_csv_source1299 := _t2082 + _t2083 := p.parse_csv_config() + csv_config1300 := _t2083 p.consumeLiteral(")") - _t2078 := p.construct_export_csv_config_with_source(export_csv_path1295, export_csv_source1296, csv_config1297) - _t2074 = _t2078 + _t2084 := p.construct_export_csv_config_with_location(export_csv_output_location1298, export_csv_source1299, csv_config1300) + _t2080 = _t2084 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_config", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2069 = _t2074 + _t2075 = _t2080 } - result1302 := _t2069 - p.recordSpan(int(span_start1301), "ExportCSVConfig") - return result1302 + result1305 := _t2075 + p.recordSpan(int(span_start1304), "ExportCSVConfig") + return result1305 } -func (p *Parser) parse_export_csv_path() string { - p.consumeLiteral("(") - p.consumeLiteral("path") - string1303 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1303 +func (p *Parser) parse_export_csv_output_location() []interface{} { + var _t2085 int64 + if p.matchLookaheadLiteral("(", 0) { + var _t2086 int64 + if p.matchLookaheadLiteral("transaction_output_name", 1) { + _t2086 = 1 + } else { + var _t2087 int64 + if p.matchLookaheadLiteral("path", 1) { + _t2087 = 0 + } else { + _t2087 = -1 + } + _t2086 = _t2087 + } + _t2085 = _t2086 + } else { + _t2085 = -1 + } + prediction1306 := _t2085 + var _t2088 []interface{} + if prediction1306 == 1 { + p.consumeLiteral("(") + p.consumeLiteral("transaction_output_name") + _t2089 := p.parse_name() + name1308 := _t2089 + p.consumeLiteral(")") + _t2088 = []interface{}{"", name1308} + } else { + var _t2090 []interface{} + if prediction1306 == 0 { + p.consumeLiteral("(") + p.consumeLiteral("path") + string1307 := p.consumeTerminal("STRING").Value.str + p.consumeLiteral(")") + _t2090 = []interface{}{string1307, ""} + } else { + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_output_location", p.lookahead(0).Type, p.lookahead(0).Value)}) + } + _t2088 = _t2090 + } + return _t2088 } func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1310 := int64(p.spanStart()) - var _t2079 int64 + span_start1315 := int64(p.spanStart()) + var _t2091 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2080 int64 + var _t2092 int64 if p.matchLookaheadLiteral("table_def", 1) { - _t2080 = 1 + _t2092 = 1 } else { - var _t2081 int64 + var _t2093 int64 if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2081 = 0 + _t2093 = 0 } else { - _t2081 = -1 + _t2093 = -1 } - _t2080 = _t2081 + _t2092 = _t2093 } - _t2079 = _t2080 + _t2091 = _t2092 } else { - _t2079 = -1 + _t2091 = -1 } - prediction1304 := _t2079 - var _t2082 *pb.ExportCSVSource - if prediction1304 == 1 { + prediction1309 := _t2091 + var _t2094 *pb.ExportCSVSource + if prediction1309 == 1 { p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2083 := p.parse_relation_id() - relation_id1309 := _t2083 + _t2095 := p.parse_relation_id() + relation_id1314 := _t2095 p.consumeLiteral(")") - _t2084 := &pb.ExportCSVSource{} - _t2084.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1309} - _t2082 = _t2084 + _t2096 := &pb.ExportCSVSource{} + _t2096.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1314} + _t2094 = _t2096 } else { - var _t2085 *pb.ExportCSVSource - if prediction1304 == 0 { + var _t2097 *pb.ExportCSVSource + if prediction1309 == 0 { p.consumeLiteral("(") p.consumeLiteral("gnf_columns") - xs1305 := []*pb.ExportCSVColumn{} - cond1306 := p.matchLookaheadLiteral("(", 0) - for cond1306 { - _t2086 := p.parse_export_csv_column() - item1307 := _t2086 - xs1305 = append(xs1305, item1307) - cond1306 = p.matchLookaheadLiteral("(", 0) + xs1310 := []*pb.ExportCSVColumn{} + cond1311 := p.matchLookaheadLiteral("(", 0) + for cond1311 { + _t2098 := p.parse_export_csv_column() + item1312 := _t2098 + xs1310 = append(xs1310, item1312) + cond1311 = p.matchLookaheadLiteral("(", 0) } - export_csv_columns1308 := xs1305 + export_csv_columns1313 := xs1310 p.consumeLiteral(")") - _t2087 := &pb.ExportCSVColumns{Columns: export_csv_columns1308} - _t2088 := &pb.ExportCSVSource{} - _t2088.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2087} - _t2085 = _t2088 + _t2099 := &pb.ExportCSVColumns{Columns: export_csv_columns1313} + _t2100 := &pb.ExportCSVSource{} + _t2100.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2099} + _t2097 = _t2100 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_source", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2082 = _t2085 + _t2094 = _t2097 } - result1311 := _t2082 - p.recordSpan(int(span_start1310), "ExportCSVSource") - return result1311 + result1316 := _t2094 + p.recordSpan(int(span_start1315), "ExportCSVSource") + return result1316 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1314 := int64(p.spanStart()) + span_start1319 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1312 := p.consumeTerminal("STRING").Value.str - _t2089 := p.parse_relation_id() - relation_id1313 := _t2089 + string1317 := p.consumeTerminal("STRING").Value.str + _t2101 := p.parse_relation_id() + relation_id1318 := _t2101 + p.consumeLiteral(")") + _t2102 := &pb.ExportCSVColumn{ColumnName: string1317, ColumnData: relation_id1318} + result1320 := _t2102 + p.recordSpan(int(span_start1319), "ExportCSVColumn") + return result1320 +} + +func (p *Parser) parse_export_csv_path() string { + p.consumeLiteral("(") + p.consumeLiteral("path") + string1321 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - _t2090 := &pb.ExportCSVColumn{ColumnName: string1312, ColumnData: relation_id1313} - result1315 := _t2090 - p.recordSpan(int(span_start1314), "ExportCSVColumn") - return result1315 + return string1321 } func (p *Parser) parse_export_csv_columns_list() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - xs1316 := []*pb.ExportCSVColumn{} - cond1317 := p.matchLookaheadLiteral("(", 0) - for cond1317 { - _t2091 := p.parse_export_csv_column() - item1318 := _t2091 - xs1316 = append(xs1316, item1318) - cond1317 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1319 := xs1316 + xs1322 := []*pb.ExportCSVColumn{} + cond1323 := p.matchLookaheadLiteral("(", 0) + for cond1323 { + _t2103 := p.parse_export_csv_column() + item1324 := _t2103 + xs1322 = append(xs1322, item1324) + cond1323 = p.matchLookaheadLiteral("(", 0) + } + export_csv_columns1325 := xs1322 p.consumeLiteral(")") - return export_csv_columns1319 + return export_csv_columns1325 } func (p *Parser) parse_export_iceberg_config() *pb.ExportIcebergConfig { - span_start1325 := int64(p.spanStart()) + span_start1331 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("export_iceberg_config") - _t2092 := p.parse_iceberg_locator() - iceberg_locator1320 := _t2092 - _t2093 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1321 := _t2093 - _t2094 := p.parse_export_iceberg_table_def() - export_iceberg_table_def1322 := _t2094 - _t2095 := p.parse_iceberg_table_properties() - iceberg_table_properties1323 := _t2095 - var _t2096 [][]interface{} + _t2104 := p.parse_iceberg_locator() + iceberg_locator1326 := _t2104 + _t2105 := p.parse_iceberg_catalog_config() + iceberg_catalog_config1327 := _t2105 + _t2106 := p.parse_export_iceberg_table_def() + export_iceberg_table_def1328 := _t2106 + _t2107 := p.parse_iceberg_table_properties() + iceberg_table_properties1329 := _t2107 + var _t2108 [][]interface{} if p.matchLookaheadLiteral("{", 0) { - _t2097 := p.parse_config_dict() - _t2096 = _t2097 + _t2109 := p.parse_config_dict() + _t2108 = _t2109 } - config_dict1324 := _t2096 + config_dict1330 := _t2108 p.consumeLiteral(")") - _t2098 := p.construct_export_iceberg_config_full(iceberg_locator1320, iceberg_catalog_config1321, export_iceberg_table_def1322, iceberg_table_properties1323, config_dict1324) - result1326 := _t2098 - p.recordSpan(int(span_start1325), "ExportIcebergConfig") - return result1326 + _t2110 := p.construct_export_iceberg_config_full(iceberg_locator1326, iceberg_catalog_config1327, export_iceberg_table_def1328, iceberg_table_properties1329, config_dict1330) + result1332 := _t2110 + p.recordSpan(int(span_start1331), "ExportIcebergConfig") + return result1332 } func (p *Parser) parse_export_iceberg_table_def() *pb.RelationId { - span_start1328 := int64(p.spanStart()) + span_start1334 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2099 := p.parse_relation_id() - relation_id1327 := _t2099 + _t2111 := p.parse_relation_id() + relation_id1333 := _t2111 p.consumeLiteral(")") - result1329 := relation_id1327 - p.recordSpan(int(span_start1328), "RelationId") - return result1329 + result1335 := relation_id1333 + p.recordSpan(int(span_start1334), "RelationId") + return result1335 } func (p *Parser) parse_iceberg_table_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("table_properties") - xs1330 := [][]interface{}{} - cond1331 := p.matchLookaheadLiteral("(", 0) - for cond1331 { - _t2100 := p.parse_iceberg_property_entry() - item1332 := _t2100 - xs1330 = append(xs1330, item1332) - cond1331 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1333 := xs1330 + xs1336 := [][]interface{}{} + cond1337 := p.matchLookaheadLiteral("(", 0) + for cond1337 { + _t2112 := p.parse_iceberg_property_entry() + item1338 := _t2112 + xs1336 = append(xs1336, item1338) + cond1337 = p.matchLookaheadLiteral("(", 0) + } + iceberg_property_entrys1339 := xs1336 p.consumeLiteral(")") - return iceberg_property_entrys1333 + return iceberg_property_entrys1339 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index 9d97d637..730086da 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -342,189 +342,193 @@ func formatBool(b bool) string { // --- Helper functions --- +func (p *PrettyPrinter) deconstruct_export_csv_output_location(msg *pb.ExportCSVConfig) []interface{} { + return []interface{}{msg.GetPath(), msg.GetTransactionOutputName()} +} + func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1742 := &pb.Value{} - _t1742.Value = &pb.Value_Int32Value{Int32Value: v} - return _t1742 + _t1755 := &pb.Value{} + _t1755.Value = &pb.Value_Int32Value{Int32Value: v} + return _t1755 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1743 := &pb.Value{} - _t1743.Value = &pb.Value_IntValue{IntValue: v} - return _t1743 + _t1756 := &pb.Value{} + _t1756.Value = &pb.Value_IntValue{IntValue: v} + return _t1756 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1744 := &pb.Value{} - _t1744.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1744 + _t1757 := &pb.Value{} + _t1757.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1757 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1745 := &pb.Value{} - _t1745.Value = &pb.Value_StringValue{StringValue: v} - return _t1745 + _t1758 := &pb.Value{} + _t1758.Value = &pb.Value_StringValue{StringValue: v} + return _t1758 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1746 := &pb.Value{} - _t1746.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1746 + _t1759 := &pb.Value{} + _t1759.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1759 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1747 := &pb.Value{} - _t1747.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1747 + _t1760 := &pb.Value{} + _t1760.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1760 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { - _t1748 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1748}) + _t1761 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1761}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1749 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1749}) + _t1762 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1762}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1750 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1750}) + _t1763 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1763}) } } } - _t1751 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1751}) + _t1764 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1764}) return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} - _t1752 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1752}) - _t1753 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1753}) + _t1765 := p._make_value_int32(msg.GetHeaderRow()) + result = append(result, []interface{}{"csv_header_row", _t1765}) + _t1766 := p._make_value_int64(msg.GetSkip()) + result = append(result, []interface{}{"csv_skip", _t1766}) if msg.GetNewLine() != "" { - _t1754 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1754}) - } - _t1755 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1755}) - _t1756 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1756}) - _t1757 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1757}) + _t1767 := p._make_value_string(msg.GetNewLine()) + result = append(result, []interface{}{"csv_new_line", _t1767}) + } + _t1768 := p._make_value_string(msg.GetDelimiter()) + result = append(result, []interface{}{"csv_delimiter", _t1768}) + _t1769 := p._make_value_string(msg.GetQuotechar()) + result = append(result, []interface{}{"csv_quotechar", _t1769}) + _t1770 := p._make_value_string(msg.GetEscapechar()) + result = append(result, []interface{}{"csv_escapechar", _t1770}) if msg.GetComment() != "" { - _t1758 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1758}) + _t1771 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1771}) } for _, missing_string := range msg.GetMissingStrings() { - _t1759 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1759}) - } - _t1760 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1760}) - _t1761 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1761}) - _t1762 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1762}) + _t1772 := p._make_value_string(missing_string) + result = append(result, []interface{}{"csv_missing_strings", _t1772}) + } + _t1773 := p._make_value_string(msg.GetDecimalSeparator()) + result = append(result, []interface{}{"csv_decimal_separator", _t1773}) + _t1774 := p._make_value_string(msg.GetEncoding()) + result = append(result, []interface{}{"csv_encoding", _t1774}) + _t1775 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"csv_compression", _t1775}) if msg.GetPartitionSizeMb() != 0 { - _t1763 := p._make_value_int64(msg.GetPartitionSizeMb()) - result = append(result, []interface{}{"csv_partition_size_mb", _t1763}) + _t1776 := p._make_value_int64(msg.GetPartitionSizeMb()) + result = append(result, []interface{}{"csv_partition_size_mb", _t1776}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_storage_integration_optional(msg *pb.CSVConfig) [][]interface{} { - var _t1764 interface{} + var _t1777 interface{} if !(hasProtoField(msg, "storage_integration")) { return nil } - _ = _t1764 + _ = _t1777 si := msg.GetStorageIntegration() result := [][]interface{}{} if si.GetProvider() != "" { - _t1765 := p._make_value_string(si.GetProvider()) - result = append(result, []interface{}{"provider", _t1765}) + _t1778 := p._make_value_string(si.GetProvider()) + result = append(result, []interface{}{"provider", _t1778}) } if si.GetAzureSasToken() != "" { - _t1766 := p._make_value_string("***") - result = append(result, []interface{}{"azure_sas_token", _t1766}) + _t1779 := p._make_value_string("***") + result = append(result, []interface{}{"azure_sas_token", _t1779}) } if si.GetS3Region() != "" { - _t1767 := p._make_value_string(si.GetS3Region()) - result = append(result, []interface{}{"s3_region", _t1767}) + _t1780 := p._make_value_string(si.GetS3Region()) + result = append(result, []interface{}{"s3_region", _t1780}) } if si.GetS3AccessKeyId() != "" { - _t1768 := p._make_value_string("***") - result = append(result, []interface{}{"s3_access_key_id", _t1768}) + _t1781 := p._make_value_string("***") + result = append(result, []interface{}{"s3_access_key_id", _t1781}) } if si.GetS3SecretAccessKey() != "" { - _t1769 := p._make_value_string("***") - result = append(result, []interface{}{"s3_secret_access_key", _t1769}) + _t1782 := p._make_value_string("***") + result = append(result, []interface{}{"s3_secret_access_key", _t1782}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} - _t1770 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1770}) - _t1771 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1771}) - _t1772 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1772}) - _t1773 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1773}) + _t1783 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) + result = append(result, []interface{}{"betree_config_epsilon", _t1783}) + _t1784 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) + result = append(result, []interface{}{"betree_config_max_pivots", _t1784}) + _t1785 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) + result = append(result, []interface{}{"betree_config_max_deltas", _t1785}) + _t1786 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) + result = append(result, []interface{}{"betree_config_max_leaf", _t1786}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1774 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1774}) + _t1787 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1787}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { - _t1775 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1775}) + _t1788 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1788}) } } - _t1776 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1776}) - _t1777 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1777}) + _t1789 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) + result = append(result, []interface{}{"betree_locator_element_count", _t1789}) + _t1790 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) + result = append(result, []interface{}{"betree_locator_tree_height", _t1790}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { - _t1778 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1778}) + _t1791 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1791}) } if msg.Compression != nil { - _t1779 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1779}) + _t1792 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1792}) } if msg.SyntaxHeaderRow != nil { - _t1780 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1780}) + _t1793 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1793}) } if msg.SyntaxMissingString != nil { - _t1781 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1781}) + _t1794 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1794}) } if msg.SyntaxDelim != nil { - _t1782 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1782}) + _t1795 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1795}) } if msg.SyntaxQuotechar != nil { - _t1783 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1783}) + _t1796 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1796}) } if msg.SyntaxEscapechar != nil { - _t1784 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1784}) + _t1797 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1797}) } return listSort(result) } @@ -534,51 +538,51 @@ func (p *PrettyPrinter) mask_secret_value(pair []interface{}) string { } func (p *PrettyPrinter) deconstruct_iceberg_catalog_config_scope_optional(msg *pb.IcebergCatalogConfig) *string { - var _t1785 interface{} + var _t1798 interface{} if *msg.Scope != "" { return ptr(*msg.Scope) } - _ = _t1785 + _ = _t1798 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_from_snapshot_optional(msg *pb.IcebergData) *string { - var _t1786 interface{} + var _t1799 interface{} if *msg.FromSnapshot != "" { return ptr(*msg.FromSnapshot) } - _ = _t1786 + _ = _t1799 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_to_snapshot_optional(msg *pb.IcebergData) *string { - var _t1787 interface{} + var _t1800 interface{} if *msg.ToSnapshot != "" { return ptr(*msg.ToSnapshot) } - _ = _t1787 + _ = _t1800 return nil } func (p *PrettyPrinter) deconstruct_export_iceberg_config_optional(msg *pb.ExportIcebergConfig) [][]interface{} { result := [][]interface{}{} if *msg.Prefix != "" { - _t1788 := p._make_value_string(*msg.Prefix) - result = append(result, []interface{}{"prefix", _t1788}) + _t1801 := p._make_value_string(*msg.Prefix) + result = append(result, []interface{}{"prefix", _t1801}) } if *msg.TargetFileSizeBytes != 0 { - _t1789 := p._make_value_int64(*msg.TargetFileSizeBytes) - result = append(result, []interface{}{"target_file_size_bytes", _t1789}) + _t1802 := p._make_value_int64(*msg.TargetFileSizeBytes) + result = append(result, []interface{}{"target_file_size_bytes", _t1802}) } if msg.GetCompression() != "" { - _t1790 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"compression", _t1790}) + _t1803 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"compression", _t1803}) } - var _t1791 interface{} + var _t1804 interface{} if int64(len(result)) == 0 { return nil } - _ = _t1791 + _ = _t1804 return listSort(result) } @@ -589,11 +593,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 _t1792 interface{} + var _t1805 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1792 + _ = _t1805 return nil } @@ -611,45 +615,45 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { - flat808 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat808 != nil { - p.write(*flat808) + flat813 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat813 != nil { + p.write(*flat813) return nil } else { _dollar_dollar := msg - var _t1598 *pb.Configure + var _t1608 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1598 = _dollar_dollar.GetConfigure() + _t1608 = _dollar_dollar.GetConfigure() } - var _t1599 *pb.Sync + var _t1609 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1599 = _dollar_dollar.GetSync() + _t1609 = _dollar_dollar.GetSync() } - fields799 := []interface{}{_t1598, _t1599, _dollar_dollar.GetEpochs()} - unwrapped_fields800 := fields799 + fields804 := []interface{}{_t1608, _t1609, _dollar_dollar.GetEpochs()} + unwrapped_fields805 := fields804 p.write("(") p.write("transaction") p.indentSexp() - field801 := unwrapped_fields800[0].(*pb.Configure) - if field801 != nil { + field806 := unwrapped_fields805[0].(*pb.Configure) + if field806 != nil { p.newline() - opt_val802 := field801 - p.pretty_configure(opt_val802) + opt_val807 := field806 + p.pretty_configure(opt_val807) } - field803 := unwrapped_fields800[1].(*pb.Sync) - if field803 != nil { + field808 := unwrapped_fields805[1].(*pb.Sync) + if field808 != nil { p.newline() - opt_val804 := field803 - p.pretty_sync(opt_val804) + opt_val809 := field808 + p.pretty_sync(opt_val809) } - field805 := unwrapped_fields800[2].([]*pb.Epoch) - if !(len(field805) == 0) { + field810 := unwrapped_fields805[2].([]*pb.Epoch) + if !(len(field810) == 0) { p.newline() - for i807, elem806 := range field805 { - if (i807 > 0) { + for i812, elem811 := range field810 { + if (i812 > 0) { p.newline() } - p.pretty_epoch(elem806) + p.pretty_epoch(elem811) } } p.dedent() @@ -659,20 +663,20 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - flat811 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat811 != nil { - p.write(*flat811) + flat816 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat816 != nil { + p.write(*flat816) return nil } else { _dollar_dollar := msg - _t1600 := p.deconstruct_configure(_dollar_dollar) - fields809 := _t1600 - unwrapped_fields810 := fields809 + _t1610 := p.deconstruct_configure(_dollar_dollar) + fields814 := _t1610 + unwrapped_fields815 := fields814 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields810) + p.pretty_config_dict(unwrapped_fields815) p.dedent() p.write(")") } @@ -680,21 +684,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - flat815 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat815 != nil { - p.write(*flat815) + flat820 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat820 != nil { + p.write(*flat820) return nil } else { - fields812 := msg + fields817 := msg p.write("{") p.indent() - if !(len(fields812) == 0) { + if !(len(fields817) == 0) { p.newline() - for i814, elem813 := range fields812 { - if (i814 > 0) { + for i819, elem818 := range fields817 { + if (i819 > 0) { p.newline() } - p.pretty_config_key_value(elem813) + p.pretty_config_key_value(elem818) } } p.dedent() @@ -704,152 +708,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - flat820 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat820 != nil { - p.write(*flat820) + flat825 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat825 != nil { + p.write(*flat825) return nil } else { _dollar_dollar := msg - fields816 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} - unwrapped_fields817 := fields816 + fields821 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} + unwrapped_fields822 := fields821 p.write(":") - field818 := unwrapped_fields817[0].(string) - p.write(field818) + field823 := unwrapped_fields822[0].(string) + p.write(field823) p.write(" ") - field819 := unwrapped_fields817[1].(*pb.Value) - p.pretty_raw_value(field819) + field824 := unwrapped_fields822[1].(*pb.Value) + p.pretty_raw_value(field824) } return nil } func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { - flat846 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) - if flat846 != nil { - p.write(*flat846) + flat851 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) + if flat851 != nil { + p.write(*flat851) return nil } else { _dollar_dollar := msg - var _t1601 *pb.DateValue + var _t1611 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1601 = _dollar_dollar.GetDateValue() + _t1611 = _dollar_dollar.GetDateValue() } - deconstruct_result844 := _t1601 - if deconstruct_result844 != nil { - unwrapped845 := deconstruct_result844 - p.pretty_raw_date(unwrapped845) + deconstruct_result849 := _t1611 + if deconstruct_result849 != nil { + unwrapped850 := deconstruct_result849 + p.pretty_raw_date(unwrapped850) } else { _dollar_dollar := msg - var _t1602 *pb.DateTimeValue + var _t1612 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1602 = _dollar_dollar.GetDatetimeValue() + _t1612 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result842 := _t1602 - if deconstruct_result842 != nil { - unwrapped843 := deconstruct_result842 - p.pretty_raw_datetime(unwrapped843) + deconstruct_result847 := _t1612 + if deconstruct_result847 != nil { + unwrapped848 := deconstruct_result847 + p.pretty_raw_datetime(unwrapped848) } else { _dollar_dollar := msg - var _t1603 *string + var _t1613 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1603 = ptr(_dollar_dollar.GetStringValue()) + _t1613 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result840 := _t1603 - if deconstruct_result840 != nil { - unwrapped841 := *deconstruct_result840 - p.write(p.formatStringValue(unwrapped841)) + deconstruct_result845 := _t1613 + if deconstruct_result845 != nil { + unwrapped846 := *deconstruct_result845 + p.write(p.formatStringValue(unwrapped846)) } else { _dollar_dollar := msg - var _t1604 *int32 + var _t1614 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1604 = ptr(_dollar_dollar.GetInt32Value()) + _t1614 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result838 := _t1604 - if deconstruct_result838 != nil { - unwrapped839 := *deconstruct_result838 - p.write(fmt.Sprintf("%di32", unwrapped839)) + deconstruct_result843 := _t1614 + if deconstruct_result843 != nil { + unwrapped844 := *deconstruct_result843 + p.write(fmt.Sprintf("%di32", unwrapped844)) } else { _dollar_dollar := msg - var _t1605 *int64 + var _t1615 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1605 = ptr(_dollar_dollar.GetIntValue()) + _t1615 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result836 := _t1605 - if deconstruct_result836 != nil { - unwrapped837 := *deconstruct_result836 - p.write(fmt.Sprintf("%d", unwrapped837)) + deconstruct_result841 := _t1615 + if deconstruct_result841 != nil { + unwrapped842 := *deconstruct_result841 + p.write(fmt.Sprintf("%d", unwrapped842)) } else { _dollar_dollar := msg - var _t1606 *float32 + var _t1616 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1606 = ptr(_dollar_dollar.GetFloat32Value()) + _t1616 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result834 := _t1606 - if deconstruct_result834 != nil { - unwrapped835 := *deconstruct_result834 - p.write(formatFloat32(unwrapped835)) + deconstruct_result839 := _t1616 + if deconstruct_result839 != nil { + unwrapped840 := *deconstruct_result839 + p.write(formatFloat32(unwrapped840)) } else { _dollar_dollar := msg - var _t1607 *float64 + var _t1617 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1607 = ptr(_dollar_dollar.GetFloatValue()) + _t1617 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result832 := _t1607 - if deconstruct_result832 != nil { - unwrapped833 := *deconstruct_result832 - p.write(formatFloat64(unwrapped833)) + deconstruct_result837 := _t1617 + if deconstruct_result837 != nil { + unwrapped838 := *deconstruct_result837 + p.write(formatFloat64(unwrapped838)) } else { _dollar_dollar := msg - var _t1608 *uint32 + var _t1618 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1608 = ptr(_dollar_dollar.GetUint32Value()) + _t1618 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result830 := _t1608 - if deconstruct_result830 != nil { - unwrapped831 := *deconstruct_result830 - p.write(fmt.Sprintf("%du32", unwrapped831)) + deconstruct_result835 := _t1618 + if deconstruct_result835 != nil { + unwrapped836 := *deconstruct_result835 + p.write(fmt.Sprintf("%du32", unwrapped836)) } else { _dollar_dollar := msg - var _t1609 *pb.UInt128Value + var _t1619 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1609 = _dollar_dollar.GetUint128Value() + _t1619 = _dollar_dollar.GetUint128Value() } - deconstruct_result828 := _t1609 - if deconstruct_result828 != nil { - unwrapped829 := deconstruct_result828 - p.write(p.formatUint128(unwrapped829)) + deconstruct_result833 := _t1619 + if deconstruct_result833 != nil { + unwrapped834 := deconstruct_result833 + p.write(p.formatUint128(unwrapped834)) } else { _dollar_dollar := msg - var _t1610 *pb.Int128Value + var _t1620 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1610 = _dollar_dollar.GetInt128Value() + _t1620 = _dollar_dollar.GetInt128Value() } - deconstruct_result826 := _t1610 - if deconstruct_result826 != nil { - unwrapped827 := deconstruct_result826 - p.write(p.formatInt128(unwrapped827)) + deconstruct_result831 := _t1620 + if deconstruct_result831 != nil { + unwrapped832 := deconstruct_result831 + p.write(p.formatInt128(unwrapped832)) } else { _dollar_dollar := msg - var _t1611 *pb.DecimalValue + var _t1621 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1611 = _dollar_dollar.GetDecimalValue() + _t1621 = _dollar_dollar.GetDecimalValue() } - deconstruct_result824 := _t1611 - if deconstruct_result824 != nil { - unwrapped825 := deconstruct_result824 - p.write(p.formatDecimal(unwrapped825)) + deconstruct_result829 := _t1621 + if deconstruct_result829 != nil { + unwrapped830 := deconstruct_result829 + p.write(p.formatDecimal(unwrapped830)) } else { _dollar_dollar := msg - var _t1612 *bool + var _t1622 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1612 = ptr(_dollar_dollar.GetBooleanValue()) + _t1622 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result822 := _t1612 - if deconstruct_result822 != nil { - unwrapped823 := *deconstruct_result822 - p.pretty_boolean_value(unwrapped823) + deconstruct_result827 := _t1622 + if deconstruct_result827 != nil { + unwrapped828 := *deconstruct_result827 + p.pretty_boolean_value(unwrapped828) } else { - fields821 := msg - _ = fields821 + fields826 := msg + _ = fields826 p.write("missing") } } @@ -868,26 +872,26 @@ func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { - flat852 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) - if flat852 != nil { - p.write(*flat852) + flat857 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) + if flat857 != nil { + p.write(*flat857) return nil } else { _dollar_dollar := msg - fields847 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields848 := fields847 + fields852 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields853 := fields852 p.write("(") p.write("date") p.indentSexp() p.newline() - field849 := unwrapped_fields848[0].(int64) - p.write(fmt.Sprintf("%d", field849)) + field854 := unwrapped_fields853[0].(int64) + p.write(fmt.Sprintf("%d", field854)) p.newline() - field850 := unwrapped_fields848[1].(int64) - p.write(fmt.Sprintf("%d", field850)) + field855 := unwrapped_fields853[1].(int64) + p.write(fmt.Sprintf("%d", field855)) p.newline() - field851 := unwrapped_fields848[2].(int64) - p.write(fmt.Sprintf("%d", field851)) + field856 := unwrapped_fields853[2].(int64) + p.write(fmt.Sprintf("%d", field856)) p.dedent() p.write(")") } @@ -895,40 +899,40 @@ func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { - flat863 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) - if flat863 != nil { - p.write(*flat863) + flat868 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) + if flat868 != nil { + p.write(*flat868) return nil } else { _dollar_dollar := msg - fields853 := []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_fields854 := fields853 + fields858 := []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_fields859 := fields858 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field855 := unwrapped_fields854[0].(int64) - p.write(fmt.Sprintf("%d", field855)) + field860 := unwrapped_fields859[0].(int64) + p.write(fmt.Sprintf("%d", field860)) p.newline() - field856 := unwrapped_fields854[1].(int64) - p.write(fmt.Sprintf("%d", field856)) + field861 := unwrapped_fields859[1].(int64) + p.write(fmt.Sprintf("%d", field861)) p.newline() - field857 := unwrapped_fields854[2].(int64) - p.write(fmt.Sprintf("%d", field857)) + field862 := unwrapped_fields859[2].(int64) + p.write(fmt.Sprintf("%d", field862)) p.newline() - field858 := unwrapped_fields854[3].(int64) - p.write(fmt.Sprintf("%d", field858)) + field863 := unwrapped_fields859[3].(int64) + p.write(fmt.Sprintf("%d", field863)) p.newline() - field859 := unwrapped_fields854[4].(int64) - p.write(fmt.Sprintf("%d", field859)) + field864 := unwrapped_fields859[4].(int64) + p.write(fmt.Sprintf("%d", field864)) p.newline() - field860 := unwrapped_fields854[5].(int64) - p.write(fmt.Sprintf("%d", field860)) - field861 := unwrapped_fields854[6].(*int64) - if field861 != nil { + field865 := unwrapped_fields859[5].(int64) + p.write(fmt.Sprintf("%d", field865)) + field866 := unwrapped_fields859[6].(*int64) + if field866 != nil { p.newline() - opt_val862 := *field861 - p.write(fmt.Sprintf("%d", opt_val862)) + opt_val867 := *field866 + p.write(fmt.Sprintf("%d", opt_val867)) } p.dedent() p.write(")") @@ -938,25 +942,25 @@ func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { _dollar_dollar := msg - var _t1613 []interface{} + var _t1623 []interface{} if _dollar_dollar { - _t1613 = []interface{}{} + _t1623 = []interface{}{} } - deconstruct_result866 := _t1613 - if deconstruct_result866 != nil { - unwrapped867 := deconstruct_result866 - _ = unwrapped867 + deconstruct_result871 := _t1623 + if deconstruct_result871 != nil { + unwrapped872 := deconstruct_result871 + _ = unwrapped872 p.write("true") } else { _dollar_dollar := msg - var _t1614 []interface{} + var _t1624 []interface{} if !(_dollar_dollar) { - _t1614 = []interface{}{} + _t1624 = []interface{}{} } - deconstruct_result864 := _t1614 - if deconstruct_result864 != nil { - unwrapped865 := deconstruct_result864 - _ = unwrapped865 + deconstruct_result869 := _t1624 + if deconstruct_result869 != nil { + unwrapped870 := deconstruct_result869 + _ = unwrapped870 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -966,24 +970,24 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - flat872 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat872 != nil { - p.write(*flat872) + flat877 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat877 != nil { + p.write(*flat877) return nil } else { _dollar_dollar := msg - fields868 := _dollar_dollar.GetFragments() - unwrapped_fields869 := fields868 + fields873 := _dollar_dollar.GetFragments() + unwrapped_fields874 := fields873 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields869) == 0) { + if !(len(unwrapped_fields874) == 0) { p.newline() - for i871, elem870 := range unwrapped_fields869 { - if (i871 > 0) { + for i876, elem875 := range unwrapped_fields874 { + if (i876 > 0) { p.newline() } - p.pretty_fragment_id(elem870) + p.pretty_fragment_id(elem875) } } p.dedent() @@ -993,51 +997,51 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - flat875 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat875 != nil { - p.write(*flat875) + flat880 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat880 != nil { + p.write(*flat880) return nil } else { _dollar_dollar := msg - fields873 := p.fragmentIdToString(_dollar_dollar) - unwrapped_fields874 := fields873 + fields878 := p.fragmentIdToString(_dollar_dollar) + unwrapped_fields879 := fields878 p.write(":") - p.write(unwrapped_fields874) + p.write(unwrapped_fields879) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - flat882 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat882 != nil { - p.write(*flat882) + flat887 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat887 != nil { + p.write(*flat887) return nil } else { _dollar_dollar := msg - var _t1615 []*pb.Write + var _t1625 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1615 = _dollar_dollar.GetWrites() + _t1625 = _dollar_dollar.GetWrites() } - var _t1616 []*pb.Read + var _t1626 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1616 = _dollar_dollar.GetReads() + _t1626 = _dollar_dollar.GetReads() } - fields876 := []interface{}{_t1615, _t1616} - unwrapped_fields877 := fields876 + fields881 := []interface{}{_t1625, _t1626} + unwrapped_fields882 := fields881 p.write("(") p.write("epoch") p.indentSexp() - field878 := unwrapped_fields877[0].([]*pb.Write) - if field878 != nil { + field883 := unwrapped_fields882[0].([]*pb.Write) + if field883 != nil { p.newline() - opt_val879 := field878 - p.pretty_epoch_writes(opt_val879) + opt_val884 := field883 + p.pretty_epoch_writes(opt_val884) } - field880 := unwrapped_fields877[1].([]*pb.Read) - if field880 != nil { + field885 := unwrapped_fields882[1].([]*pb.Read) + if field885 != nil { p.newline() - opt_val881 := field880 - p.pretty_epoch_reads(opt_val881) + opt_val886 := field885 + p.pretty_epoch_reads(opt_val886) } p.dedent() p.write(")") @@ -1046,22 +1050,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - flat886 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat886 != nil { - p.write(*flat886) + flat891 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat891 != nil { + p.write(*flat891) return nil } else { - fields883 := msg + fields888 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields883) == 0) { + if !(len(fields888) == 0) { p.newline() - for i885, elem884 := range fields883 { - if (i885 > 0) { + for i890, elem889 := range fields888 { + if (i890 > 0) { p.newline() } - p.pretty_write(elem884) + p.pretty_write(elem889) } } p.dedent() @@ -1071,50 +1075,50 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat895 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat895 != nil { - p.write(*flat895) + flat900 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat900 != nil { + p.write(*flat900) return nil } else { _dollar_dollar := msg - var _t1617 *pb.Define + var _t1627 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1617 = _dollar_dollar.GetDefine() + _t1627 = _dollar_dollar.GetDefine() } - deconstruct_result893 := _t1617 - if deconstruct_result893 != nil { - unwrapped894 := deconstruct_result893 - p.pretty_define(unwrapped894) + deconstruct_result898 := _t1627 + if deconstruct_result898 != nil { + unwrapped899 := deconstruct_result898 + p.pretty_define(unwrapped899) } else { _dollar_dollar := msg - var _t1618 *pb.Undefine + var _t1628 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1618 = _dollar_dollar.GetUndefine() + _t1628 = _dollar_dollar.GetUndefine() } - deconstruct_result891 := _t1618 - if deconstruct_result891 != nil { - unwrapped892 := deconstruct_result891 - p.pretty_undefine(unwrapped892) + deconstruct_result896 := _t1628 + if deconstruct_result896 != nil { + unwrapped897 := deconstruct_result896 + p.pretty_undefine(unwrapped897) } else { _dollar_dollar := msg - var _t1619 *pb.Context + var _t1629 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1619 = _dollar_dollar.GetContext() + _t1629 = _dollar_dollar.GetContext() } - deconstruct_result889 := _t1619 - if deconstruct_result889 != nil { - unwrapped890 := deconstruct_result889 - p.pretty_context(unwrapped890) + deconstruct_result894 := _t1629 + if deconstruct_result894 != nil { + unwrapped895 := deconstruct_result894 + p.pretty_context(unwrapped895) } else { _dollar_dollar := msg - var _t1620 *pb.Snapshot + var _t1630 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1620 = _dollar_dollar.GetSnapshot() + _t1630 = _dollar_dollar.GetSnapshot() } - deconstruct_result887 := _t1620 - if deconstruct_result887 != nil { - unwrapped888 := deconstruct_result887 - p.pretty_snapshot(unwrapped888) + deconstruct_result892 := _t1630 + if deconstruct_result892 != nil { + unwrapped893 := deconstruct_result892 + p.pretty_snapshot(unwrapped893) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1126,19 +1130,19 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - flat898 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat898 != nil { - p.write(*flat898) + flat903 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat903 != nil { + p.write(*flat903) return nil } else { _dollar_dollar := msg - fields896 := _dollar_dollar.GetFragment() - unwrapped_fields897 := fields896 + fields901 := _dollar_dollar.GetFragment() + unwrapped_fields902 := fields901 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields897) + p.pretty_fragment(unwrapped_fields902) p.dedent() p.write(")") } @@ -1146,29 +1150,29 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat905 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat905 != nil { - p.write(*flat905) + flat910 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat910 != nil { + p.write(*flat910) return nil } else { _dollar_dollar := msg p.startPrettyFragment(_dollar_dollar) - fields899 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} - unwrapped_fields900 := fields899 + fields904 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} + unwrapped_fields905 := fields904 p.write("(") p.write("fragment") p.indentSexp() p.newline() - field901 := unwrapped_fields900[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field901) - field902 := unwrapped_fields900[1].([]*pb.Declaration) - if !(len(field902) == 0) { + field906 := unwrapped_fields905[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field906) + field907 := unwrapped_fields905[1].([]*pb.Declaration) + if !(len(field907) == 0) { p.newline() - for i904, elem903 := range field902 { - if (i904 > 0) { + for i909, elem908 := range field907 { + if (i909 > 0) { p.newline() } - p.pretty_declaration(elem903) + p.pretty_declaration(elem908) } } p.dedent() @@ -1178,62 +1182,62 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - flat907 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat907 != nil { - p.write(*flat907) + flat912 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat912 != nil { + p.write(*flat912) return nil } else { - fields906 := msg - p.pretty_fragment_id(fields906) + fields911 := msg + p.pretty_fragment_id(fields911) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - flat916 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat916 != nil { - p.write(*flat916) + flat921 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat921 != nil { + p.write(*flat921) return nil } else { _dollar_dollar := msg - var _t1621 *pb.Def + var _t1631 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1621 = _dollar_dollar.GetDef() + _t1631 = _dollar_dollar.GetDef() } - deconstruct_result914 := _t1621 - if deconstruct_result914 != nil { - unwrapped915 := deconstruct_result914 - p.pretty_def(unwrapped915) + deconstruct_result919 := _t1631 + if deconstruct_result919 != nil { + unwrapped920 := deconstruct_result919 + p.pretty_def(unwrapped920) } else { _dollar_dollar := msg - var _t1622 *pb.Algorithm + var _t1632 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1622 = _dollar_dollar.GetAlgorithm() + _t1632 = _dollar_dollar.GetAlgorithm() } - deconstruct_result912 := _t1622 - if deconstruct_result912 != nil { - unwrapped913 := deconstruct_result912 - p.pretty_algorithm(unwrapped913) + deconstruct_result917 := _t1632 + if deconstruct_result917 != nil { + unwrapped918 := deconstruct_result917 + p.pretty_algorithm(unwrapped918) } else { _dollar_dollar := msg - var _t1623 *pb.Constraint + var _t1633 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1623 = _dollar_dollar.GetConstraint() + _t1633 = _dollar_dollar.GetConstraint() } - deconstruct_result910 := _t1623 - if deconstruct_result910 != nil { - unwrapped911 := deconstruct_result910 - p.pretty_constraint(unwrapped911) + deconstruct_result915 := _t1633 + if deconstruct_result915 != nil { + unwrapped916 := deconstruct_result915 + p.pretty_constraint(unwrapped916) } else { _dollar_dollar := msg - var _t1624 *pb.Data + var _t1634 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1624 = _dollar_dollar.GetData() + _t1634 = _dollar_dollar.GetData() } - deconstruct_result908 := _t1624 - if deconstruct_result908 != nil { - unwrapped909 := deconstruct_result908 - p.pretty_data(unwrapped909) + deconstruct_result913 := _t1634 + if deconstruct_result913 != nil { + unwrapped914 := deconstruct_result913 + p.pretty_data(unwrapped914) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1245,32 +1249,32 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - flat923 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat923 != nil { - p.write(*flat923) + flat928 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat928 != nil { + p.write(*flat928) return nil } else { _dollar_dollar := msg - var _t1625 []*pb.Attribute + var _t1635 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1625 = _dollar_dollar.GetAttrs() + _t1635 = _dollar_dollar.GetAttrs() } - fields917 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1625} - unwrapped_fields918 := fields917 + fields922 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1635} + unwrapped_fields923 := fields922 p.write("(") p.write("def") p.indentSexp() p.newline() - field919 := unwrapped_fields918[0].(*pb.RelationId) - p.pretty_relation_id(field919) + field924 := unwrapped_fields923[0].(*pb.RelationId) + p.pretty_relation_id(field924) p.newline() - field920 := unwrapped_fields918[1].(*pb.Abstraction) - p.pretty_abstraction(field920) - field921 := unwrapped_fields918[2].([]*pb.Attribute) - if field921 != nil { + field925 := unwrapped_fields923[1].(*pb.Abstraction) + p.pretty_abstraction(field925) + field926 := unwrapped_fields923[2].([]*pb.Attribute) + if field926 != nil { p.newline() - opt_val922 := field921 - p.pretty_attrs(opt_val922) + opt_val927 := field926 + p.pretty_attrs(opt_val927) } p.dedent() p.write(")") @@ -1279,29 +1283,29 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - flat928 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat928 != nil { - p.write(*flat928) + flat933 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat933 != nil { + p.write(*flat933) return nil } else { _dollar_dollar := msg - var _t1626 *string + var _t1636 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1627 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1626 = ptr(_t1627) + _t1637 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1636 = ptr(_t1637) } - deconstruct_result926 := _t1626 - if deconstruct_result926 != nil { - unwrapped927 := *deconstruct_result926 + deconstruct_result931 := _t1636 + if deconstruct_result931 != nil { + unwrapped932 := *deconstruct_result931 p.write(":") - p.write(unwrapped927) + p.write(unwrapped932) } else { _dollar_dollar := msg - _t1628 := p.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result924 := _t1628 - if deconstruct_result924 != nil { - unwrapped925 := deconstruct_result924 - p.write(p.formatUint128(unwrapped925)) + _t1638 := p.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result929 := _t1638 + if deconstruct_result929 != nil { + unwrapped930 := deconstruct_result929 + p.write(p.formatUint128(unwrapped930)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -1311,22 +1315,22 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - flat933 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat933 != nil { - p.write(*flat933) + flat938 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat938 != nil { + p.write(*flat938) return nil } else { _dollar_dollar := msg - _t1629 := p.deconstruct_bindings(_dollar_dollar) - fields929 := []interface{}{_t1629, _dollar_dollar.GetValue()} - unwrapped_fields930 := fields929 + _t1639 := p.deconstruct_bindings(_dollar_dollar) + fields934 := []interface{}{_t1639, _dollar_dollar.GetValue()} + unwrapped_fields935 := fields934 p.write("(") p.indent() - field931 := unwrapped_fields930[0].([]interface{}) - p.pretty_bindings(field931) + field936 := unwrapped_fields935[0].([]interface{}) + p.pretty_bindings(field936) p.newline() - field932 := unwrapped_fields930[1].(*pb.Formula) - p.pretty_formula(field932) + field937 := unwrapped_fields935[1].(*pb.Formula) + p.pretty_formula(field937) p.dedent() p.write(")") } @@ -1334,32 +1338,32 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - flat941 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat941 != nil { - p.write(*flat941) + flat946 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat946 != nil { + p.write(*flat946) return nil } else { _dollar_dollar := msg - var _t1630 []*pb.Binding + var _t1640 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1630 = _dollar_dollar[1].([]*pb.Binding) + _t1640 = _dollar_dollar[1].([]*pb.Binding) } - fields934 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1630} - unwrapped_fields935 := fields934 + fields939 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1640} + unwrapped_fields940 := fields939 p.write("[") p.indent() - field936 := unwrapped_fields935[0].([]*pb.Binding) - for i938, elem937 := range field936 { - if (i938 > 0) { + field941 := unwrapped_fields940[0].([]*pb.Binding) + for i943, elem942 := range field941 { + if (i943 > 0) { p.newline() } - p.pretty_binding(elem937) + p.pretty_binding(elem942) } - field939 := unwrapped_fields935[1].([]*pb.Binding) - if field939 != nil { + field944 := unwrapped_fields940[1].([]*pb.Binding) + if field944 != nil { p.newline() - opt_val940 := field939 - p.pretty_value_bindings(opt_val940) + opt_val945 := field944 + p.pretty_value_bindings(opt_val945) } p.dedent() p.write("]") @@ -1368,168 +1372,168 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - flat946 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat946 != nil { - p.write(*flat946) + flat951 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat951 != nil { + p.write(*flat951) return nil } else { _dollar_dollar := msg - fields942 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} - unwrapped_fields943 := fields942 - field944 := unwrapped_fields943[0].(string) - p.write(field944) + fields947 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} + unwrapped_fields948 := fields947 + field949 := unwrapped_fields948[0].(string) + p.write(field949) p.write("::") - field945 := unwrapped_fields943[1].(*pb.Type) - p.pretty_type(field945) + field950 := unwrapped_fields948[1].(*pb.Type) + p.pretty_type(field950) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - flat975 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat975 != nil { - p.write(*flat975) + flat980 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat980 != nil { + p.write(*flat980) return nil } else { _dollar_dollar := msg - var _t1631 *pb.UnspecifiedType + var _t1641 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1631 = _dollar_dollar.GetUnspecifiedType() + _t1641 = _dollar_dollar.GetUnspecifiedType() } - deconstruct_result973 := _t1631 - if deconstruct_result973 != nil { - unwrapped974 := deconstruct_result973 - p.pretty_unspecified_type(unwrapped974) + deconstruct_result978 := _t1641 + if deconstruct_result978 != nil { + unwrapped979 := deconstruct_result978 + p.pretty_unspecified_type(unwrapped979) } else { _dollar_dollar := msg - var _t1632 *pb.StringType + var _t1642 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1632 = _dollar_dollar.GetStringType() + _t1642 = _dollar_dollar.GetStringType() } - deconstruct_result971 := _t1632 - if deconstruct_result971 != nil { - unwrapped972 := deconstruct_result971 - p.pretty_string_type(unwrapped972) + deconstruct_result976 := _t1642 + if deconstruct_result976 != nil { + unwrapped977 := deconstruct_result976 + p.pretty_string_type(unwrapped977) } else { _dollar_dollar := msg - var _t1633 *pb.IntType + var _t1643 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1633 = _dollar_dollar.GetIntType() + _t1643 = _dollar_dollar.GetIntType() } - deconstruct_result969 := _t1633 - if deconstruct_result969 != nil { - unwrapped970 := deconstruct_result969 - p.pretty_int_type(unwrapped970) + deconstruct_result974 := _t1643 + if deconstruct_result974 != nil { + unwrapped975 := deconstruct_result974 + p.pretty_int_type(unwrapped975) } else { _dollar_dollar := msg - var _t1634 *pb.FloatType + var _t1644 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1634 = _dollar_dollar.GetFloatType() + _t1644 = _dollar_dollar.GetFloatType() } - deconstruct_result967 := _t1634 - if deconstruct_result967 != nil { - unwrapped968 := deconstruct_result967 - p.pretty_float_type(unwrapped968) + deconstruct_result972 := _t1644 + if deconstruct_result972 != nil { + unwrapped973 := deconstruct_result972 + p.pretty_float_type(unwrapped973) } else { _dollar_dollar := msg - var _t1635 *pb.UInt128Type + var _t1645 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1635 = _dollar_dollar.GetUint128Type() + _t1645 = _dollar_dollar.GetUint128Type() } - deconstruct_result965 := _t1635 - if deconstruct_result965 != nil { - unwrapped966 := deconstruct_result965 - p.pretty_uint128_type(unwrapped966) + deconstruct_result970 := _t1645 + if deconstruct_result970 != nil { + unwrapped971 := deconstruct_result970 + p.pretty_uint128_type(unwrapped971) } else { _dollar_dollar := msg - var _t1636 *pb.Int128Type + var _t1646 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1636 = _dollar_dollar.GetInt128Type() + _t1646 = _dollar_dollar.GetInt128Type() } - deconstruct_result963 := _t1636 - if deconstruct_result963 != nil { - unwrapped964 := deconstruct_result963 - p.pretty_int128_type(unwrapped964) + deconstruct_result968 := _t1646 + if deconstruct_result968 != nil { + unwrapped969 := deconstruct_result968 + p.pretty_int128_type(unwrapped969) } else { _dollar_dollar := msg - var _t1637 *pb.DateType + var _t1647 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1637 = _dollar_dollar.GetDateType() + _t1647 = _dollar_dollar.GetDateType() } - deconstruct_result961 := _t1637 - if deconstruct_result961 != nil { - unwrapped962 := deconstruct_result961 - p.pretty_date_type(unwrapped962) + deconstruct_result966 := _t1647 + if deconstruct_result966 != nil { + unwrapped967 := deconstruct_result966 + p.pretty_date_type(unwrapped967) } else { _dollar_dollar := msg - var _t1638 *pb.DateTimeType + var _t1648 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1638 = _dollar_dollar.GetDatetimeType() + _t1648 = _dollar_dollar.GetDatetimeType() } - deconstruct_result959 := _t1638 - if deconstruct_result959 != nil { - unwrapped960 := deconstruct_result959 - p.pretty_datetime_type(unwrapped960) + deconstruct_result964 := _t1648 + if deconstruct_result964 != nil { + unwrapped965 := deconstruct_result964 + p.pretty_datetime_type(unwrapped965) } else { _dollar_dollar := msg - var _t1639 *pb.MissingType + var _t1649 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1639 = _dollar_dollar.GetMissingType() + _t1649 = _dollar_dollar.GetMissingType() } - deconstruct_result957 := _t1639 - if deconstruct_result957 != nil { - unwrapped958 := deconstruct_result957 - p.pretty_missing_type(unwrapped958) + deconstruct_result962 := _t1649 + if deconstruct_result962 != nil { + unwrapped963 := deconstruct_result962 + p.pretty_missing_type(unwrapped963) } else { _dollar_dollar := msg - var _t1640 *pb.DecimalType + var _t1650 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1640 = _dollar_dollar.GetDecimalType() + _t1650 = _dollar_dollar.GetDecimalType() } - deconstruct_result955 := _t1640 - if deconstruct_result955 != nil { - unwrapped956 := deconstruct_result955 - p.pretty_decimal_type(unwrapped956) + deconstruct_result960 := _t1650 + if deconstruct_result960 != nil { + unwrapped961 := deconstruct_result960 + p.pretty_decimal_type(unwrapped961) } else { _dollar_dollar := msg - var _t1641 *pb.BooleanType + var _t1651 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1641 = _dollar_dollar.GetBooleanType() + _t1651 = _dollar_dollar.GetBooleanType() } - deconstruct_result953 := _t1641 - if deconstruct_result953 != nil { - unwrapped954 := deconstruct_result953 - p.pretty_boolean_type(unwrapped954) + deconstruct_result958 := _t1651 + if deconstruct_result958 != nil { + unwrapped959 := deconstruct_result958 + p.pretty_boolean_type(unwrapped959) } else { _dollar_dollar := msg - var _t1642 *pb.Int32Type + var _t1652 *pb.Int32Type if hasProtoField(_dollar_dollar, "int32_type") { - _t1642 = _dollar_dollar.GetInt32Type() + _t1652 = _dollar_dollar.GetInt32Type() } - deconstruct_result951 := _t1642 - if deconstruct_result951 != nil { - unwrapped952 := deconstruct_result951 - p.pretty_int32_type(unwrapped952) + deconstruct_result956 := _t1652 + if deconstruct_result956 != nil { + unwrapped957 := deconstruct_result956 + p.pretty_int32_type(unwrapped957) } else { _dollar_dollar := msg - var _t1643 *pb.Float32Type + var _t1653 *pb.Float32Type if hasProtoField(_dollar_dollar, "float32_type") { - _t1643 = _dollar_dollar.GetFloat32Type() + _t1653 = _dollar_dollar.GetFloat32Type() } - deconstruct_result949 := _t1643 - if deconstruct_result949 != nil { - unwrapped950 := deconstruct_result949 - p.pretty_float32_type(unwrapped950) + deconstruct_result954 := _t1653 + if deconstruct_result954 != nil { + unwrapped955 := deconstruct_result954 + p.pretty_float32_type(unwrapped955) } else { _dollar_dollar := msg - var _t1644 *pb.UInt32Type + var _t1654 *pb.UInt32Type if hasProtoField(_dollar_dollar, "uint32_type") { - _t1644 = _dollar_dollar.GetUint32Type() + _t1654 = _dollar_dollar.GetUint32Type() } - deconstruct_result947 := _t1644 - if deconstruct_result947 != nil { - unwrapped948 := deconstruct_result947 - p.pretty_uint32_type(unwrapped948) + deconstruct_result952 := _t1654 + if deconstruct_result952 != nil { + unwrapped953 := deconstruct_result952 + p.pretty_uint32_type(unwrapped953) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -1551,86 +1555,86 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields976 := msg - _ = fields976 + fields981 := msg + _ = fields981 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields977 := msg - _ = fields977 + fields982 := msg + _ = fields982 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields978 := msg - _ = fields978 + fields983 := msg + _ = fields983 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields979 := msg - _ = fields979 + fields984 := msg + _ = fields984 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields980 := msg - _ = fields980 + fields985 := msg + _ = fields985 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields981 := msg - _ = fields981 + fields986 := msg + _ = fields986 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields982 := msg - _ = fields982 + fields987 := msg + _ = fields987 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields983 := msg - _ = fields983 + fields988 := msg + _ = fields988 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields984 := msg - _ = fields984 + fields989 := msg + _ = fields989 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - flat989 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat989 != nil { - p.write(*flat989) + flat994 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat994 != nil { + p.write(*flat994) return nil } else { _dollar_dollar := msg - fields985 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} - unwrapped_fields986 := fields985 + fields990 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} + unwrapped_fields991 := fields990 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - field987 := unwrapped_fields986[0].(int64) - p.write(fmt.Sprintf("%d", field987)) + field992 := unwrapped_fields991[0].(int64) + p.write(fmt.Sprintf("%d", field992)) p.newline() - field988 := unwrapped_fields986[1].(int64) - p.write(fmt.Sprintf("%d", field988)) + field993 := unwrapped_fields991[1].(int64) + p.write(fmt.Sprintf("%d", field993)) p.dedent() p.write(")") } @@ -1638,48 +1642,48 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields990 := msg - _ = fields990 + fields995 := msg + _ = fields995 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_int32_type(msg *pb.Int32Type) interface{} { - fields991 := msg - _ = fields991 + fields996 := msg + _ = fields996 p.write("INT32") return nil } func (p *PrettyPrinter) pretty_float32_type(msg *pb.Float32Type) interface{} { - fields992 := msg - _ = fields992 + fields997 := msg + _ = fields997 p.write("FLOAT32") return nil } func (p *PrettyPrinter) pretty_uint32_type(msg *pb.UInt32Type) interface{} { - fields993 := msg - _ = fields993 + fields998 := msg + _ = fields998 p.write("UINT32") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - flat997 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat997 != nil { - p.write(*flat997) + flat1002 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat1002 != nil { + p.write(*flat1002) return nil } else { - fields994 := msg + fields999 := msg p.write("|") - if !(len(fields994) == 0) { + if !(len(fields999) == 0) { p.write(" ") - for i996, elem995 := range fields994 { - if (i996 > 0) { + for i1001, elem1000 := range fields999 { + if (i1001 > 0) { p.newline() } - p.pretty_binding(elem995) + p.pretty_binding(elem1000) } } } @@ -1687,140 +1691,140 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - flat1024 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat1024 != nil { - p.write(*flat1024) + flat1029 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat1029 != nil { + p.write(*flat1029) return nil } else { _dollar_dollar := msg - var _t1645 *pb.Conjunction + var _t1655 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1645 = _dollar_dollar.GetConjunction() + _t1655 = _dollar_dollar.GetConjunction() } - deconstruct_result1022 := _t1645 - if deconstruct_result1022 != nil { - unwrapped1023 := deconstruct_result1022 - p.pretty_true(unwrapped1023) + deconstruct_result1027 := _t1655 + if deconstruct_result1027 != nil { + unwrapped1028 := deconstruct_result1027 + p.pretty_true(unwrapped1028) } else { _dollar_dollar := msg - var _t1646 *pb.Disjunction + var _t1656 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1646 = _dollar_dollar.GetDisjunction() + _t1656 = _dollar_dollar.GetDisjunction() } - deconstruct_result1020 := _t1646 - if deconstruct_result1020 != nil { - unwrapped1021 := deconstruct_result1020 - p.pretty_false(unwrapped1021) + deconstruct_result1025 := _t1656 + if deconstruct_result1025 != nil { + unwrapped1026 := deconstruct_result1025 + p.pretty_false(unwrapped1026) } else { _dollar_dollar := msg - var _t1647 *pb.Exists + var _t1657 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1647 = _dollar_dollar.GetExists() + _t1657 = _dollar_dollar.GetExists() } - deconstruct_result1018 := _t1647 - if deconstruct_result1018 != nil { - unwrapped1019 := deconstruct_result1018 - p.pretty_exists(unwrapped1019) + deconstruct_result1023 := _t1657 + if deconstruct_result1023 != nil { + unwrapped1024 := deconstruct_result1023 + p.pretty_exists(unwrapped1024) } else { _dollar_dollar := msg - var _t1648 *pb.Reduce + var _t1658 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1648 = _dollar_dollar.GetReduce() + _t1658 = _dollar_dollar.GetReduce() } - deconstruct_result1016 := _t1648 - if deconstruct_result1016 != nil { - unwrapped1017 := deconstruct_result1016 - p.pretty_reduce(unwrapped1017) + deconstruct_result1021 := _t1658 + if deconstruct_result1021 != nil { + unwrapped1022 := deconstruct_result1021 + p.pretty_reduce(unwrapped1022) } else { _dollar_dollar := msg - var _t1649 *pb.Conjunction + var _t1659 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1649 = _dollar_dollar.GetConjunction() + _t1659 = _dollar_dollar.GetConjunction() } - deconstruct_result1014 := _t1649 - if deconstruct_result1014 != nil { - unwrapped1015 := deconstruct_result1014 - p.pretty_conjunction(unwrapped1015) + deconstruct_result1019 := _t1659 + if deconstruct_result1019 != nil { + unwrapped1020 := deconstruct_result1019 + p.pretty_conjunction(unwrapped1020) } else { _dollar_dollar := msg - var _t1650 *pb.Disjunction + var _t1660 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1650 = _dollar_dollar.GetDisjunction() + _t1660 = _dollar_dollar.GetDisjunction() } - deconstruct_result1012 := _t1650 - if deconstruct_result1012 != nil { - unwrapped1013 := deconstruct_result1012 - p.pretty_disjunction(unwrapped1013) + deconstruct_result1017 := _t1660 + if deconstruct_result1017 != nil { + unwrapped1018 := deconstruct_result1017 + p.pretty_disjunction(unwrapped1018) } else { _dollar_dollar := msg - var _t1651 *pb.Not + var _t1661 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1651 = _dollar_dollar.GetNot() + _t1661 = _dollar_dollar.GetNot() } - deconstruct_result1010 := _t1651 - if deconstruct_result1010 != nil { - unwrapped1011 := deconstruct_result1010 - p.pretty_not(unwrapped1011) + deconstruct_result1015 := _t1661 + if deconstruct_result1015 != nil { + unwrapped1016 := deconstruct_result1015 + p.pretty_not(unwrapped1016) } else { _dollar_dollar := msg - var _t1652 *pb.FFI + var _t1662 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1652 = _dollar_dollar.GetFfi() + _t1662 = _dollar_dollar.GetFfi() } - deconstruct_result1008 := _t1652 - if deconstruct_result1008 != nil { - unwrapped1009 := deconstruct_result1008 - p.pretty_ffi(unwrapped1009) + deconstruct_result1013 := _t1662 + if deconstruct_result1013 != nil { + unwrapped1014 := deconstruct_result1013 + p.pretty_ffi(unwrapped1014) } else { _dollar_dollar := msg - var _t1653 *pb.Atom + var _t1663 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1653 = _dollar_dollar.GetAtom() + _t1663 = _dollar_dollar.GetAtom() } - deconstruct_result1006 := _t1653 - if deconstruct_result1006 != nil { - unwrapped1007 := deconstruct_result1006 - p.pretty_atom(unwrapped1007) + deconstruct_result1011 := _t1663 + if deconstruct_result1011 != nil { + unwrapped1012 := deconstruct_result1011 + p.pretty_atom(unwrapped1012) } else { _dollar_dollar := msg - var _t1654 *pb.Pragma + var _t1664 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1654 = _dollar_dollar.GetPragma() + _t1664 = _dollar_dollar.GetPragma() } - deconstruct_result1004 := _t1654 - if deconstruct_result1004 != nil { - unwrapped1005 := deconstruct_result1004 - p.pretty_pragma(unwrapped1005) + deconstruct_result1009 := _t1664 + if deconstruct_result1009 != nil { + unwrapped1010 := deconstruct_result1009 + p.pretty_pragma(unwrapped1010) } else { _dollar_dollar := msg - var _t1655 *pb.Primitive + var _t1665 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1655 = _dollar_dollar.GetPrimitive() + _t1665 = _dollar_dollar.GetPrimitive() } - deconstruct_result1002 := _t1655 - if deconstruct_result1002 != nil { - unwrapped1003 := deconstruct_result1002 - p.pretty_primitive(unwrapped1003) + deconstruct_result1007 := _t1665 + if deconstruct_result1007 != nil { + unwrapped1008 := deconstruct_result1007 + p.pretty_primitive(unwrapped1008) } else { _dollar_dollar := msg - var _t1656 *pb.RelAtom + var _t1666 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1656 = _dollar_dollar.GetRelAtom() + _t1666 = _dollar_dollar.GetRelAtom() } - deconstruct_result1000 := _t1656 - if deconstruct_result1000 != nil { - unwrapped1001 := deconstruct_result1000 - p.pretty_rel_atom(unwrapped1001) + deconstruct_result1005 := _t1666 + if deconstruct_result1005 != nil { + unwrapped1006 := deconstruct_result1005 + p.pretty_rel_atom(unwrapped1006) } else { _dollar_dollar := msg - var _t1657 *pb.Cast + var _t1667 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1657 = _dollar_dollar.GetCast() + _t1667 = _dollar_dollar.GetCast() } - deconstruct_result998 := _t1657 - if deconstruct_result998 != nil { - unwrapped999 := deconstruct_result998 - p.pretty_cast(unwrapped999) + deconstruct_result1003 := _t1667 + if deconstruct_result1003 != nil { + unwrapped1004 := deconstruct_result1003 + p.pretty_cast(unwrapped1004) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1841,8 +1845,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields1025 := msg - _ = fields1025 + fields1030 := msg + _ = fields1030 p.write("(") p.write("true") p.write(")") @@ -1850,8 +1854,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields1026 := msg - _ = fields1026 + fields1031 := msg + _ = fields1031 p.write("(") p.write("false") p.write(")") @@ -1859,24 +1863,24 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - flat1031 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat1031 != nil { - p.write(*flat1031) + flat1036 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat1036 != nil { + p.write(*flat1036) return nil } else { _dollar_dollar := msg - _t1658 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - fields1027 := []interface{}{_t1658, _dollar_dollar.GetBody().GetValue()} - unwrapped_fields1028 := fields1027 + _t1668 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + fields1032 := []interface{}{_t1668, _dollar_dollar.GetBody().GetValue()} + unwrapped_fields1033 := fields1032 p.write("(") p.write("exists") p.indentSexp() p.newline() - field1029 := unwrapped_fields1028[0].([]interface{}) - p.pretty_bindings(field1029) + field1034 := unwrapped_fields1033[0].([]interface{}) + p.pretty_bindings(field1034) p.newline() - field1030 := unwrapped_fields1028[1].(*pb.Formula) - p.pretty_formula(field1030) + field1035 := unwrapped_fields1033[1].(*pb.Formula) + p.pretty_formula(field1035) p.dedent() p.write(")") } @@ -1884,26 +1888,26 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat1037 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat1037 != nil { - p.write(*flat1037) + flat1042 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat1042 != nil { + p.write(*flat1042) return nil } else { _dollar_dollar := msg - fields1032 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} - unwrapped_fields1033 := fields1032 + fields1037 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} + unwrapped_fields1038 := fields1037 p.write("(") p.write("reduce") p.indentSexp() p.newline() - field1034 := unwrapped_fields1033[0].(*pb.Abstraction) - p.pretty_abstraction(field1034) + field1039 := unwrapped_fields1038[0].(*pb.Abstraction) + p.pretty_abstraction(field1039) p.newline() - field1035 := unwrapped_fields1033[1].(*pb.Abstraction) - p.pretty_abstraction(field1035) + field1040 := unwrapped_fields1038[1].(*pb.Abstraction) + p.pretty_abstraction(field1040) p.newline() - field1036 := unwrapped_fields1033[2].([]*pb.Term) - p.pretty_terms(field1036) + field1041 := unwrapped_fields1038[2].([]*pb.Term) + p.pretty_terms(field1041) p.dedent() p.write(")") } @@ -1911,22 +1915,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - flat1041 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat1041 != nil { - p.write(*flat1041) + flat1046 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat1046 != nil { + p.write(*flat1046) return nil } else { - fields1038 := msg + fields1043 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields1038) == 0) { + if !(len(fields1043) == 0) { p.newline() - for i1040, elem1039 := range fields1038 { - if (i1040 > 0) { + for i1045, elem1044 := range fields1043 { + if (i1045 > 0) { p.newline() } - p.pretty_term(elem1039) + p.pretty_term(elem1044) } } p.dedent() @@ -1936,30 +1940,30 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat1046 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat1046 != nil { - p.write(*flat1046) + flat1051 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat1051 != nil { + p.write(*flat1051) return nil } else { _dollar_dollar := msg - var _t1659 *pb.Var + var _t1669 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1659 = _dollar_dollar.GetVar() + _t1669 = _dollar_dollar.GetVar() } - deconstruct_result1044 := _t1659 - if deconstruct_result1044 != nil { - unwrapped1045 := deconstruct_result1044 - p.pretty_var(unwrapped1045) + deconstruct_result1049 := _t1669 + if deconstruct_result1049 != nil { + unwrapped1050 := deconstruct_result1049 + p.pretty_var(unwrapped1050) } else { _dollar_dollar := msg - var _t1660 *pb.Value + var _t1670 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1660 = _dollar_dollar.GetConstant() + _t1670 = _dollar_dollar.GetConstant() } - deconstruct_result1042 := _t1660 - if deconstruct_result1042 != nil { - unwrapped1043 := deconstruct_result1042 - p.pretty_value(unwrapped1043) + deconstruct_result1047 := _t1670 + if deconstruct_result1047 != nil { + unwrapped1048 := deconstruct_result1047 + p.pretty_value(unwrapped1048) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -1969,147 +1973,147 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - flat1049 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat1049 != nil { - p.write(*flat1049) + flat1054 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat1054 != nil { + p.write(*flat1054) return nil } else { _dollar_dollar := msg - fields1047 := _dollar_dollar.GetName() - unwrapped_fields1048 := fields1047 - p.write(unwrapped_fields1048) + fields1052 := _dollar_dollar.GetName() + unwrapped_fields1053 := fields1052 + p.write(unwrapped_fields1053) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat1075 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat1075 != nil { - p.write(*flat1075) + flat1080 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat1080 != nil { + p.write(*flat1080) return nil } else { _dollar_dollar := msg - var _t1661 *pb.DateValue + var _t1671 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1661 = _dollar_dollar.GetDateValue() + _t1671 = _dollar_dollar.GetDateValue() } - deconstruct_result1073 := _t1661 - if deconstruct_result1073 != nil { - unwrapped1074 := deconstruct_result1073 - p.pretty_date(unwrapped1074) + deconstruct_result1078 := _t1671 + if deconstruct_result1078 != nil { + unwrapped1079 := deconstruct_result1078 + p.pretty_date(unwrapped1079) } else { _dollar_dollar := msg - var _t1662 *pb.DateTimeValue + var _t1672 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1662 = _dollar_dollar.GetDatetimeValue() + _t1672 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result1071 := _t1662 - if deconstruct_result1071 != nil { - unwrapped1072 := deconstruct_result1071 - p.pretty_datetime(unwrapped1072) + deconstruct_result1076 := _t1672 + if deconstruct_result1076 != nil { + unwrapped1077 := deconstruct_result1076 + p.pretty_datetime(unwrapped1077) } else { _dollar_dollar := msg - var _t1663 *string + var _t1673 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1663 = ptr(_dollar_dollar.GetStringValue()) + _t1673 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result1069 := _t1663 - if deconstruct_result1069 != nil { - unwrapped1070 := *deconstruct_result1069 - p.write(p.formatStringValue(unwrapped1070)) + deconstruct_result1074 := _t1673 + if deconstruct_result1074 != nil { + unwrapped1075 := *deconstruct_result1074 + p.write(p.formatStringValue(unwrapped1075)) } else { _dollar_dollar := msg - var _t1664 *int32 + var _t1674 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1664 = ptr(_dollar_dollar.GetInt32Value()) + _t1674 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result1067 := _t1664 - if deconstruct_result1067 != nil { - unwrapped1068 := *deconstruct_result1067 - p.write(fmt.Sprintf("%di32", unwrapped1068)) + deconstruct_result1072 := _t1674 + if deconstruct_result1072 != nil { + unwrapped1073 := *deconstruct_result1072 + p.write(fmt.Sprintf("%di32", unwrapped1073)) } else { _dollar_dollar := msg - var _t1665 *int64 + var _t1675 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1665 = ptr(_dollar_dollar.GetIntValue()) + _t1675 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result1065 := _t1665 - if deconstruct_result1065 != nil { - unwrapped1066 := *deconstruct_result1065 - p.write(fmt.Sprintf("%d", unwrapped1066)) + deconstruct_result1070 := _t1675 + if deconstruct_result1070 != nil { + unwrapped1071 := *deconstruct_result1070 + p.write(fmt.Sprintf("%d", unwrapped1071)) } else { _dollar_dollar := msg - var _t1666 *float32 + var _t1676 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1666 = ptr(_dollar_dollar.GetFloat32Value()) + _t1676 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result1063 := _t1666 - if deconstruct_result1063 != nil { - unwrapped1064 := *deconstruct_result1063 - p.write(formatFloat32(unwrapped1064)) + deconstruct_result1068 := _t1676 + if deconstruct_result1068 != nil { + unwrapped1069 := *deconstruct_result1068 + p.write(formatFloat32(unwrapped1069)) } else { _dollar_dollar := msg - var _t1667 *float64 + var _t1677 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1667 = ptr(_dollar_dollar.GetFloatValue()) + _t1677 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result1061 := _t1667 - if deconstruct_result1061 != nil { - unwrapped1062 := *deconstruct_result1061 - p.write(formatFloat64(unwrapped1062)) + deconstruct_result1066 := _t1677 + if deconstruct_result1066 != nil { + unwrapped1067 := *deconstruct_result1066 + p.write(formatFloat64(unwrapped1067)) } else { _dollar_dollar := msg - var _t1668 *uint32 + var _t1678 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1668 = ptr(_dollar_dollar.GetUint32Value()) + _t1678 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result1059 := _t1668 - if deconstruct_result1059 != nil { - unwrapped1060 := *deconstruct_result1059 - p.write(fmt.Sprintf("%du32", unwrapped1060)) + deconstruct_result1064 := _t1678 + if deconstruct_result1064 != nil { + unwrapped1065 := *deconstruct_result1064 + p.write(fmt.Sprintf("%du32", unwrapped1065)) } else { _dollar_dollar := msg - var _t1669 *pb.UInt128Value + var _t1679 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1669 = _dollar_dollar.GetUint128Value() + _t1679 = _dollar_dollar.GetUint128Value() } - deconstruct_result1057 := _t1669 - if deconstruct_result1057 != nil { - unwrapped1058 := deconstruct_result1057 - p.write(p.formatUint128(unwrapped1058)) + deconstruct_result1062 := _t1679 + if deconstruct_result1062 != nil { + unwrapped1063 := deconstruct_result1062 + p.write(p.formatUint128(unwrapped1063)) } else { _dollar_dollar := msg - var _t1670 *pb.Int128Value + var _t1680 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1670 = _dollar_dollar.GetInt128Value() + _t1680 = _dollar_dollar.GetInt128Value() } - deconstruct_result1055 := _t1670 - if deconstruct_result1055 != nil { - unwrapped1056 := deconstruct_result1055 - p.write(p.formatInt128(unwrapped1056)) + deconstruct_result1060 := _t1680 + if deconstruct_result1060 != nil { + unwrapped1061 := deconstruct_result1060 + p.write(p.formatInt128(unwrapped1061)) } else { _dollar_dollar := msg - var _t1671 *pb.DecimalValue + var _t1681 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1671 = _dollar_dollar.GetDecimalValue() + _t1681 = _dollar_dollar.GetDecimalValue() } - deconstruct_result1053 := _t1671 - if deconstruct_result1053 != nil { - unwrapped1054 := deconstruct_result1053 - p.write(p.formatDecimal(unwrapped1054)) + deconstruct_result1058 := _t1681 + if deconstruct_result1058 != nil { + unwrapped1059 := deconstruct_result1058 + p.write(p.formatDecimal(unwrapped1059)) } else { _dollar_dollar := msg - var _t1672 *bool + var _t1682 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1672 = ptr(_dollar_dollar.GetBooleanValue()) + _t1682 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result1051 := _t1672 - if deconstruct_result1051 != nil { - unwrapped1052 := *deconstruct_result1051 - p.pretty_boolean_value(unwrapped1052) + deconstruct_result1056 := _t1682 + if deconstruct_result1056 != nil { + unwrapped1057 := *deconstruct_result1056 + p.pretty_boolean_value(unwrapped1057) } else { - fields1050 := msg - _ = fields1050 + fields1055 := msg + _ = fields1055 p.write("missing") } } @@ -2128,26 +2132,26 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - flat1081 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat1081 != nil { - p.write(*flat1081) + flat1086 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat1086 != nil { + p.write(*flat1086) return nil } else { _dollar_dollar := msg - fields1076 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields1077 := fields1076 + fields1081 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields1082 := fields1081 p.write("(") p.write("date") p.indentSexp() p.newline() - field1078 := unwrapped_fields1077[0].(int64) - p.write(fmt.Sprintf("%d", field1078)) + field1083 := unwrapped_fields1082[0].(int64) + p.write(fmt.Sprintf("%d", field1083)) p.newline() - field1079 := unwrapped_fields1077[1].(int64) - p.write(fmt.Sprintf("%d", field1079)) + field1084 := unwrapped_fields1082[1].(int64) + p.write(fmt.Sprintf("%d", field1084)) p.newline() - field1080 := unwrapped_fields1077[2].(int64) - p.write(fmt.Sprintf("%d", field1080)) + field1085 := unwrapped_fields1082[2].(int64) + p.write(fmt.Sprintf("%d", field1085)) p.dedent() p.write(")") } @@ -2155,40 +2159,40 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - flat1092 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat1092 != nil { - p.write(*flat1092) + flat1097 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat1097 != nil { + p.write(*flat1097) return nil } else { _dollar_dollar := msg - fields1082 := []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_fields1083 := fields1082 + fields1087 := []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_fields1088 := fields1087 p.write("(") p.write("datetime") p.indentSexp() p.newline() - field1084 := unwrapped_fields1083[0].(int64) - p.write(fmt.Sprintf("%d", field1084)) + field1089 := unwrapped_fields1088[0].(int64) + p.write(fmt.Sprintf("%d", field1089)) p.newline() - field1085 := unwrapped_fields1083[1].(int64) - p.write(fmt.Sprintf("%d", field1085)) + field1090 := unwrapped_fields1088[1].(int64) + p.write(fmt.Sprintf("%d", field1090)) p.newline() - field1086 := unwrapped_fields1083[2].(int64) - p.write(fmt.Sprintf("%d", field1086)) + field1091 := unwrapped_fields1088[2].(int64) + p.write(fmt.Sprintf("%d", field1091)) p.newline() - field1087 := unwrapped_fields1083[3].(int64) - p.write(fmt.Sprintf("%d", field1087)) + field1092 := unwrapped_fields1088[3].(int64) + p.write(fmt.Sprintf("%d", field1092)) p.newline() - field1088 := unwrapped_fields1083[4].(int64) - p.write(fmt.Sprintf("%d", field1088)) + field1093 := unwrapped_fields1088[4].(int64) + p.write(fmt.Sprintf("%d", field1093)) p.newline() - field1089 := unwrapped_fields1083[5].(int64) - p.write(fmt.Sprintf("%d", field1089)) - field1090 := unwrapped_fields1083[6].(*int64) - if field1090 != nil { + field1094 := unwrapped_fields1088[5].(int64) + p.write(fmt.Sprintf("%d", field1094)) + field1095 := unwrapped_fields1088[6].(*int64) + if field1095 != nil { p.newline() - opt_val1091 := *field1090 - p.write(fmt.Sprintf("%d", opt_val1091)) + opt_val1096 := *field1095 + p.write(fmt.Sprintf("%d", opt_val1096)) } p.dedent() p.write(")") @@ -2197,24 +2201,24 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat1097 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat1097 != nil { - p.write(*flat1097) + flat1102 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat1102 != nil { + p.write(*flat1102) return nil } else { _dollar_dollar := msg - fields1093 := _dollar_dollar.GetArgs() - unwrapped_fields1094 := fields1093 + fields1098 := _dollar_dollar.GetArgs() + unwrapped_fields1099 := fields1098 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields1094) == 0) { + if !(len(unwrapped_fields1099) == 0) { p.newline() - for i1096, elem1095 := range unwrapped_fields1094 { - if (i1096 > 0) { + for i1101, elem1100 := range unwrapped_fields1099 { + if (i1101 > 0) { p.newline() } - p.pretty_formula(elem1095) + p.pretty_formula(elem1100) } } p.dedent() @@ -2224,24 +2228,24 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat1102 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat1102 != nil { - p.write(*flat1102) + flat1107 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat1107 != nil { + p.write(*flat1107) return nil } else { _dollar_dollar := msg - fields1098 := _dollar_dollar.GetArgs() - unwrapped_fields1099 := fields1098 + fields1103 := _dollar_dollar.GetArgs() + unwrapped_fields1104 := fields1103 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields1099) == 0) { + if !(len(unwrapped_fields1104) == 0) { p.newline() - for i1101, elem1100 := range unwrapped_fields1099 { - if (i1101 > 0) { + for i1106, elem1105 := range unwrapped_fields1104 { + if (i1106 > 0) { p.newline() } - p.pretty_formula(elem1100) + p.pretty_formula(elem1105) } } p.dedent() @@ -2251,19 +2255,19 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat1105 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat1105 != nil { - p.write(*flat1105) + flat1110 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat1110 != nil { + p.write(*flat1110) return nil } else { _dollar_dollar := msg - fields1103 := _dollar_dollar.GetArg() - unwrapped_fields1104 := fields1103 + fields1108 := _dollar_dollar.GetArg() + unwrapped_fields1109 := fields1108 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields1104) + p.pretty_formula(unwrapped_fields1109) p.dedent() p.write(")") } @@ -2271,26 +2275,26 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat1111 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat1111 != nil { - p.write(*flat1111) + flat1116 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat1116 != nil { + p.write(*flat1116) return nil } else { _dollar_dollar := msg - fields1106 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} - unwrapped_fields1107 := fields1106 + fields1111 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} + unwrapped_fields1112 := fields1111 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field1108 := unwrapped_fields1107[0].(string) - p.pretty_name(field1108) + field1113 := unwrapped_fields1112[0].(string) + p.pretty_name(field1113) p.newline() - field1109 := unwrapped_fields1107[1].([]*pb.Abstraction) - p.pretty_ffi_args(field1109) + field1114 := unwrapped_fields1112[1].([]*pb.Abstraction) + p.pretty_ffi_args(field1114) p.newline() - field1110 := unwrapped_fields1107[2].([]*pb.Term) - p.pretty_terms(field1110) + field1115 := unwrapped_fields1112[2].([]*pb.Term) + p.pretty_terms(field1115) p.dedent() p.write(")") } @@ -2298,35 +2302,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - flat1113 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat1113 != nil { - p.write(*flat1113) + flat1118 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat1118 != nil { + p.write(*flat1118) return nil } else { - fields1112 := msg + fields1117 := msg p.write(":") - p.write(fields1112) + p.write(fields1117) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - flat1117 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat1117 != nil { - p.write(*flat1117) + flat1122 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat1122 != nil { + p.write(*flat1122) return nil } else { - fields1114 := msg + fields1119 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields1114) == 0) { + if !(len(fields1119) == 0) { p.newline() - for i1116, elem1115 := range fields1114 { - if (i1116 > 0) { + for i1121, elem1120 := range fields1119 { + if (i1121 > 0) { p.newline() } - p.pretty_abstraction(elem1115) + p.pretty_abstraction(elem1120) } } p.dedent() @@ -2336,28 +2340,28 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - flat1124 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat1124 != nil { - p.write(*flat1124) + flat1129 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat1129 != nil { + p.write(*flat1129) return nil } else { _dollar_dollar := msg - fields1118 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1119 := fields1118 + fields1123 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1124 := fields1123 p.write("(") p.write("atom") p.indentSexp() p.newline() - field1120 := unwrapped_fields1119[0].(*pb.RelationId) - p.pretty_relation_id(field1120) - field1121 := unwrapped_fields1119[1].([]*pb.Term) - if !(len(field1121) == 0) { + field1125 := unwrapped_fields1124[0].(*pb.RelationId) + p.pretty_relation_id(field1125) + field1126 := unwrapped_fields1124[1].([]*pb.Term) + if !(len(field1126) == 0) { p.newline() - for i1123, elem1122 := range field1121 { - if (i1123 > 0) { + for i1128, elem1127 := range field1126 { + if (i1128 > 0) { p.newline() } - p.pretty_term(elem1122) + p.pretty_term(elem1127) } } p.dedent() @@ -2367,28 +2371,28 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - flat1131 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat1131 != nil { - p.write(*flat1131) + flat1136 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat1136 != nil { + p.write(*flat1136) return nil } else { _dollar_dollar := msg - fields1125 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1126 := fields1125 + fields1130 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1131 := fields1130 p.write("(") p.write("pragma") p.indentSexp() p.newline() - field1127 := unwrapped_fields1126[0].(string) - p.pretty_name(field1127) - field1128 := unwrapped_fields1126[1].([]*pb.Term) - if !(len(field1128) == 0) { + field1132 := unwrapped_fields1131[0].(string) + p.pretty_name(field1132) + field1133 := unwrapped_fields1131[1].([]*pb.Term) + if !(len(field1133) == 0) { p.newline() - for i1130, elem1129 := range field1128 { - if (i1130 > 0) { + for i1135, elem1134 := range field1133 { + if (i1135 > 0) { p.newline() } - p.pretty_term(elem1129) + p.pretty_term(elem1134) } } p.dedent() @@ -2398,109 +2402,109 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - flat1147 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat1147 != nil { - p.write(*flat1147) + flat1152 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat1152 != nil { + p.write(*flat1152) return nil } else { _dollar_dollar := msg - var _t1673 []interface{} + var _t1683 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1673 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1683 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1146 := _t1673 - if guard_result1146 != nil { + guard_result1151 := _t1683 + if guard_result1151 != nil { p.pretty_eq(msg) } else { _dollar_dollar := msg - var _t1674 []interface{} + var _t1684 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1674 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1684 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1145 := _t1674 - if guard_result1145 != nil { + guard_result1150 := _t1684 + if guard_result1150 != nil { p.pretty_lt(msg) } else { _dollar_dollar := msg - var _t1675 []interface{} + var _t1685 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1675 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1685 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1144 := _t1675 - if guard_result1144 != nil { + guard_result1149 := _t1685 + if guard_result1149 != nil { p.pretty_lt_eq(msg) } else { _dollar_dollar := msg - var _t1676 []interface{} + var _t1686 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1676 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1686 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1143 := _t1676 - if guard_result1143 != nil { + guard_result1148 := _t1686 + if guard_result1148 != nil { p.pretty_gt(msg) } else { _dollar_dollar := msg - var _t1677 []interface{} + var _t1687 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1677 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1687 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1142 := _t1677 - if guard_result1142 != nil { + guard_result1147 := _t1687 + if guard_result1147 != nil { p.pretty_gt_eq(msg) } else { _dollar_dollar := msg - var _t1678 []interface{} + var _t1688 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1678 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1688 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1141 := _t1678 - if guard_result1141 != nil { + guard_result1146 := _t1688 + if guard_result1146 != nil { p.pretty_add(msg) } else { _dollar_dollar := msg - var _t1679 []interface{} + var _t1689 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1679 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1689 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1140 := _t1679 - if guard_result1140 != nil { + guard_result1145 := _t1689 + if guard_result1145 != nil { p.pretty_minus(msg) } else { _dollar_dollar := msg - var _t1680 []interface{} + var _t1690 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1680 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1690 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1139 := _t1680 - if guard_result1139 != nil { + guard_result1144 := _t1690 + if guard_result1144 != nil { p.pretty_multiply(msg) } else { _dollar_dollar := msg - var _t1681 []interface{} + var _t1691 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1681 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1691 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1138 := _t1681 - if guard_result1138 != nil { + guard_result1143 := _t1691 + if guard_result1143 != nil { p.pretty_divide(msg) } else { _dollar_dollar := msg - fields1132 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1133 := fields1132 + fields1137 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1138 := fields1137 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field1134 := unwrapped_fields1133[0].(string) - p.pretty_name(field1134) - field1135 := unwrapped_fields1133[1].([]*pb.RelTerm) - if !(len(field1135) == 0) { + field1139 := unwrapped_fields1138[0].(string) + p.pretty_name(field1139) + field1140 := unwrapped_fields1138[1].([]*pb.RelTerm) + if !(len(field1140) == 0) { p.newline() - for i1137, elem1136 := range field1135 { - if (i1137 > 0) { + for i1142, elem1141 := range field1140 { + if (i1142 > 0) { p.newline() } - p.pretty_rel_term(elem1136) + p.pretty_rel_term(elem1141) } } p.dedent() @@ -2519,48 +2523,20 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat1152 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat1152 != nil { - p.write(*flat1152) - return nil - } else { - _dollar_dollar := msg - var _t1682 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1682 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - fields1148 := _t1682 - unwrapped_fields1149 := fields1148 - p.write("(") - p.write("=") - p.indentSexp() - p.newline() - field1150 := unwrapped_fields1149[0].(*pb.Term) - p.pretty_term(field1150) - p.newline() - field1151 := unwrapped_fields1149[1].(*pb.Term) - p.pretty_term(field1151) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat1157 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + flat1157 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) if flat1157 != nil { p.write(*flat1157) return nil } else { _dollar_dollar := msg - var _t1683 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1683 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + var _t1692 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_eq" { + _t1692 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1153 := _t1683 + fields1153 := _t1692 unwrapped_fields1154 := fields1153 p.write("(") - p.write("<") + p.write("=") p.indentSexp() p.newline() field1155 := unwrapped_fields1154[0].(*pb.Term) @@ -2574,21 +2550,21 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat1162 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) +func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { + flat1162 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) if flat1162 != nil { p.write(*flat1162) return nil } else { _dollar_dollar := msg - var _t1684 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1684 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + var _t1693 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { + _t1693 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1158 := _t1684 + fields1158 := _t1693 unwrapped_fields1159 := fields1158 p.write("(") - p.write("<=") + p.write("<") p.indentSexp() p.newline() field1160 := unwrapped_fields1159[0].(*pb.Term) @@ -2602,21 +2578,21 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat1167 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) +func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { + flat1167 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) if flat1167 != nil { p.write(*flat1167) return nil } else { _dollar_dollar := msg - var _t1685 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1685 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + var _t1694 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { + _t1694 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1163 := _t1685 + fields1163 := _t1694 unwrapped_fields1164 := fields1163 p.write("(") - p.write(">") + p.write("<=") p.indentSexp() p.newline() field1165 := unwrapped_fields1164[0].(*pb.Term) @@ -2630,21 +2606,21 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat1172 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) +func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { + flat1172 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) if flat1172 != nil { p.write(*flat1172) return nil } else { _dollar_dollar := msg - var _t1686 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1686 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + var _t1695 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { + _t1695 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1168 := _t1686 + fields1168 := _t1695 unwrapped_fields1169 := fields1168 p.write("(") - p.write(">=") + p.write(">") p.indentSexp() p.newline() field1170 := unwrapped_fields1169[0].(*pb.Term) @@ -2658,21 +2634,21 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat1178 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat1178 != nil { - p.write(*flat1178) +func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { + flat1177 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) + if flat1177 != nil { + p.write(*flat1177) return nil } else { _dollar_dollar := msg - var _t1687 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1687 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + var _t1696 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { + _t1696 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1173 := _t1687 + fields1173 := _t1696 unwrapped_fields1174 := fields1173 p.write("(") - p.write("+") + p.write(">=") p.indentSexp() p.newline() field1175 := unwrapped_fields1174[0].(*pb.Term) @@ -2680,9 +2656,37 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { p.newline() field1176 := unwrapped_fields1174[1].(*pb.Term) p.pretty_term(field1176) + p.dedent() + p.write(")") + } + return nil +} + +func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { + flat1183 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat1183 != nil { + p.write(*flat1183) + return nil + } else { + _dollar_dollar := msg + var _t1697 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { + _t1697 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + } + fields1178 := _t1697 + unwrapped_fields1179 := fields1178 + p.write("(") + p.write("+") + p.indentSexp() + p.newline() + field1180 := unwrapped_fields1179[0].(*pb.Term) + p.pretty_term(field1180) + p.newline() + field1181 := unwrapped_fields1179[1].(*pb.Term) + p.pretty_term(field1181) p.newline() - field1177 := unwrapped_fields1174[2].(*pb.Term) - p.pretty_term(field1177) + field1182 := unwrapped_fields1179[2].(*pb.Term) + p.pretty_term(field1182) p.dedent() p.write(")") } @@ -2690,30 +2694,30 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat1184 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat1184 != nil { - p.write(*flat1184) + flat1189 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat1189 != nil { + p.write(*flat1189) return nil } else { _dollar_dollar := msg - var _t1688 []interface{} + var _t1698 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1688 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1698 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1179 := _t1688 - unwrapped_fields1180 := fields1179 + fields1184 := _t1698 + unwrapped_fields1185 := fields1184 p.write("(") p.write("-") p.indentSexp() p.newline() - field1181 := unwrapped_fields1180[0].(*pb.Term) - p.pretty_term(field1181) + field1186 := unwrapped_fields1185[0].(*pb.Term) + p.pretty_term(field1186) p.newline() - field1182 := unwrapped_fields1180[1].(*pb.Term) - p.pretty_term(field1182) + field1187 := unwrapped_fields1185[1].(*pb.Term) + p.pretty_term(field1187) p.newline() - field1183 := unwrapped_fields1180[2].(*pb.Term) - p.pretty_term(field1183) + field1188 := unwrapped_fields1185[2].(*pb.Term) + p.pretty_term(field1188) p.dedent() p.write(")") } @@ -2721,30 +2725,30 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat1190 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat1190 != nil { - p.write(*flat1190) + flat1195 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat1195 != nil { + p.write(*flat1195) return nil } else { _dollar_dollar := msg - var _t1689 []interface{} + var _t1699 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1689 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1699 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1185 := _t1689 - unwrapped_fields1186 := fields1185 + fields1190 := _t1699 + unwrapped_fields1191 := fields1190 p.write("(") p.write("*") p.indentSexp() p.newline() - field1187 := unwrapped_fields1186[0].(*pb.Term) - p.pretty_term(field1187) + field1192 := unwrapped_fields1191[0].(*pb.Term) + p.pretty_term(field1192) p.newline() - field1188 := unwrapped_fields1186[1].(*pb.Term) - p.pretty_term(field1188) + field1193 := unwrapped_fields1191[1].(*pb.Term) + p.pretty_term(field1193) p.newline() - field1189 := unwrapped_fields1186[2].(*pb.Term) - p.pretty_term(field1189) + field1194 := unwrapped_fields1191[2].(*pb.Term) + p.pretty_term(field1194) p.dedent() p.write(")") } @@ -2752,30 +2756,30 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat1196 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat1196 != nil { - p.write(*flat1196) + flat1201 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat1201 != nil { + p.write(*flat1201) return nil } else { _dollar_dollar := msg - var _t1690 []interface{} + var _t1700 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1690 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1700 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1191 := _t1690 - unwrapped_fields1192 := fields1191 + fields1196 := _t1700 + unwrapped_fields1197 := fields1196 p.write("(") p.write("/") p.indentSexp() p.newline() - field1193 := unwrapped_fields1192[0].(*pb.Term) - p.pretty_term(field1193) + field1198 := unwrapped_fields1197[0].(*pb.Term) + p.pretty_term(field1198) p.newline() - field1194 := unwrapped_fields1192[1].(*pb.Term) - p.pretty_term(field1194) + field1199 := unwrapped_fields1197[1].(*pb.Term) + p.pretty_term(field1199) p.newline() - field1195 := unwrapped_fields1192[2].(*pb.Term) - p.pretty_term(field1195) + field1200 := unwrapped_fields1197[2].(*pb.Term) + p.pretty_term(field1200) p.dedent() p.write(")") } @@ -2783,30 +2787,30 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat1201 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat1201 != nil { - p.write(*flat1201) + flat1206 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat1206 != nil { + p.write(*flat1206) return nil } else { _dollar_dollar := msg - var _t1691 *pb.Value + var _t1701 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1691 = _dollar_dollar.GetSpecializedValue() + _t1701 = _dollar_dollar.GetSpecializedValue() } - deconstruct_result1199 := _t1691 - if deconstruct_result1199 != nil { - unwrapped1200 := deconstruct_result1199 - p.pretty_specialized_value(unwrapped1200) + deconstruct_result1204 := _t1701 + if deconstruct_result1204 != nil { + unwrapped1205 := deconstruct_result1204 + p.pretty_specialized_value(unwrapped1205) } else { _dollar_dollar := msg - var _t1692 *pb.Term + var _t1702 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1692 = _dollar_dollar.GetTerm() + _t1702 = _dollar_dollar.GetTerm() } - deconstruct_result1197 := _t1692 - if deconstruct_result1197 != nil { - unwrapped1198 := deconstruct_result1197 - p.pretty_term(unwrapped1198) + deconstruct_result1202 := _t1702 + if deconstruct_result1202 != nil { + unwrapped1203 := deconstruct_result1202 + p.pretty_term(unwrapped1203) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -2816,41 +2820,41 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat1203 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat1203 != nil { - p.write(*flat1203) + flat1208 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat1208 != nil { + p.write(*flat1208) return nil } else { - fields1202 := msg + fields1207 := msg p.write("#") - p.pretty_raw_value(fields1202) + p.pretty_raw_value(fields1207) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat1210 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat1210 != nil { - p.write(*flat1210) + flat1215 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat1215 != nil { + p.write(*flat1215) return nil } else { _dollar_dollar := msg - fields1204 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1205 := fields1204 + fields1209 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1210 := fields1209 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field1206 := unwrapped_fields1205[0].(string) - p.pretty_name(field1206) - field1207 := unwrapped_fields1205[1].([]*pb.RelTerm) - if !(len(field1207) == 0) { + field1211 := unwrapped_fields1210[0].(string) + p.pretty_name(field1211) + field1212 := unwrapped_fields1210[1].([]*pb.RelTerm) + if !(len(field1212) == 0) { p.newline() - for i1209, elem1208 := range field1207 { - if (i1209 > 0) { + for i1214, elem1213 := range field1212 { + if (i1214 > 0) { p.newline() } - p.pretty_rel_term(elem1208) + p.pretty_rel_term(elem1213) } } p.dedent() @@ -2860,23 +2864,23 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat1215 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat1215 != nil { - p.write(*flat1215) + flat1220 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat1220 != nil { + p.write(*flat1220) return nil } else { _dollar_dollar := msg - fields1211 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} - unwrapped_fields1212 := fields1211 + fields1216 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} + unwrapped_fields1217 := fields1216 p.write("(") p.write("cast") p.indentSexp() p.newline() - field1213 := unwrapped_fields1212[0].(*pb.Term) - p.pretty_term(field1213) + field1218 := unwrapped_fields1217[0].(*pb.Term) + p.pretty_term(field1218) p.newline() - field1214 := unwrapped_fields1212[1].(*pb.Term) - p.pretty_term(field1214) + field1219 := unwrapped_fields1217[1].(*pb.Term) + p.pretty_term(field1219) p.dedent() p.write(")") } @@ -2884,22 +2888,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1219 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1219 != nil { - p.write(*flat1219) + flat1224 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1224 != nil { + p.write(*flat1224) return nil } else { - fields1216 := msg + fields1221 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields1216) == 0) { + if !(len(fields1221) == 0) { p.newline() - for i1218, elem1217 := range fields1216 { - if (i1218 > 0) { + for i1223, elem1222 := range fields1221 { + if (i1223 > 0) { p.newline() } - p.pretty_attribute(elem1217) + p.pretty_attribute(elem1222) } } p.dedent() @@ -2909,28 +2913,28 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1226 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1226 != nil { - p.write(*flat1226) + flat1231 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1231 != nil { + p.write(*flat1231) return nil } else { _dollar_dollar := msg - fields1220 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} - unwrapped_fields1221 := fields1220 + fields1225 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} + unwrapped_fields1226 := fields1225 p.write("(") p.write("attribute") p.indentSexp() p.newline() - field1222 := unwrapped_fields1221[0].(string) - p.pretty_name(field1222) - field1223 := unwrapped_fields1221[1].([]*pb.Value) - if !(len(field1223) == 0) { + field1227 := unwrapped_fields1226[0].(string) + p.pretty_name(field1227) + field1228 := unwrapped_fields1226[1].([]*pb.Value) + if !(len(field1228) == 0) { p.newline() - for i1225, elem1224 := range field1223 { - if (i1225 > 0) { + for i1230, elem1229 := range field1228 { + if (i1230 > 0) { p.newline() } - p.pretty_raw_value(elem1224) + p.pretty_raw_value(elem1229) } } p.dedent() @@ -2940,39 +2944,39 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - flat1235 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1235 != nil { - p.write(*flat1235) + flat1240 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1240 != nil { + p.write(*flat1240) return nil } else { _dollar_dollar := msg - var _t1693 []*pb.Attribute + var _t1703 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1693 = _dollar_dollar.GetAttrs() + _t1703 = _dollar_dollar.GetAttrs() } - fields1227 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1693} - unwrapped_fields1228 := fields1227 + fields1232 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1703} + unwrapped_fields1233 := fields1232 p.write("(") p.write("algorithm") p.indentSexp() - field1229 := unwrapped_fields1228[0].([]*pb.RelationId) - if !(len(field1229) == 0) { + field1234 := unwrapped_fields1233[0].([]*pb.RelationId) + if !(len(field1234) == 0) { p.newline() - for i1231, elem1230 := range field1229 { - if (i1231 > 0) { + for i1236, elem1235 := range field1234 { + if (i1236 > 0) { p.newline() } - p.pretty_relation_id(elem1230) + p.pretty_relation_id(elem1235) } } p.newline() - field1232 := unwrapped_fields1228[1].(*pb.Script) - p.pretty_script(field1232) - field1233 := unwrapped_fields1228[2].([]*pb.Attribute) - if field1233 != nil { + field1237 := unwrapped_fields1233[1].(*pb.Script) + p.pretty_script(field1237) + field1238 := unwrapped_fields1233[2].([]*pb.Attribute) + if field1238 != nil { p.newline() - opt_val1234 := field1233 - p.pretty_attrs(opt_val1234) + opt_val1239 := field1238 + p.pretty_attrs(opt_val1239) } p.dedent() p.write(")") @@ -2981,24 +2985,24 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - flat1240 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1240 != nil { - p.write(*flat1240) + flat1245 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1245 != nil { + p.write(*flat1245) return nil } else { _dollar_dollar := msg - fields1236 := _dollar_dollar.GetConstructs() - unwrapped_fields1237 := fields1236 + fields1241 := _dollar_dollar.GetConstructs() + unwrapped_fields1242 := fields1241 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1237) == 0) { + if !(len(unwrapped_fields1242) == 0) { p.newline() - for i1239, elem1238 := range unwrapped_fields1237 { - if (i1239 > 0) { + for i1244, elem1243 := range unwrapped_fields1242 { + if (i1244 > 0) { p.newline() } - p.pretty_construct(elem1238) + p.pretty_construct(elem1243) } } p.dedent() @@ -3008,30 +3012,30 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - flat1245 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1245 != nil { - p.write(*flat1245) + flat1250 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1250 != nil { + p.write(*flat1250) return nil } else { _dollar_dollar := msg - var _t1694 *pb.Loop + var _t1704 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1694 = _dollar_dollar.GetLoop() + _t1704 = _dollar_dollar.GetLoop() } - deconstruct_result1243 := _t1694 - if deconstruct_result1243 != nil { - unwrapped1244 := deconstruct_result1243 - p.pretty_loop(unwrapped1244) + deconstruct_result1248 := _t1704 + if deconstruct_result1248 != nil { + unwrapped1249 := deconstruct_result1248 + p.pretty_loop(unwrapped1249) } else { _dollar_dollar := msg - var _t1695 *pb.Instruction + var _t1705 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1695 = _dollar_dollar.GetInstruction() + _t1705 = _dollar_dollar.GetInstruction() } - deconstruct_result1241 := _t1695 - if deconstruct_result1241 != nil { - unwrapped1242 := deconstruct_result1241 - p.pretty_instruction(unwrapped1242) + deconstruct_result1246 := _t1705 + if deconstruct_result1246 != nil { + unwrapped1247 := deconstruct_result1246 + p.pretty_instruction(unwrapped1247) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -3041,32 +3045,32 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - flat1252 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1252 != nil { - p.write(*flat1252) + flat1257 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1257 != nil { + p.write(*flat1257) return nil } else { _dollar_dollar := msg - var _t1696 []*pb.Attribute + var _t1706 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1696 = _dollar_dollar.GetAttrs() + _t1706 = _dollar_dollar.GetAttrs() } - fields1246 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1696} - unwrapped_fields1247 := fields1246 + fields1251 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1706} + unwrapped_fields1252 := fields1251 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1248 := unwrapped_fields1247[0].([]*pb.Instruction) - p.pretty_init(field1248) + field1253 := unwrapped_fields1252[0].([]*pb.Instruction) + p.pretty_init(field1253) p.newline() - field1249 := unwrapped_fields1247[1].(*pb.Script) - p.pretty_script(field1249) - field1250 := unwrapped_fields1247[2].([]*pb.Attribute) - if field1250 != nil { + field1254 := unwrapped_fields1252[1].(*pb.Script) + p.pretty_script(field1254) + field1255 := unwrapped_fields1252[2].([]*pb.Attribute) + if field1255 != nil { p.newline() - opt_val1251 := field1250 - p.pretty_attrs(opt_val1251) + opt_val1256 := field1255 + p.pretty_attrs(opt_val1256) } p.dedent() p.write(")") @@ -3075,22 +3079,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - flat1256 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1256 != nil { - p.write(*flat1256) + flat1261 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1261 != nil { + p.write(*flat1261) return nil } else { - fields1253 := msg + fields1258 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1253) == 0) { + if !(len(fields1258) == 0) { p.newline() - for i1255, elem1254 := range fields1253 { - if (i1255 > 0) { + for i1260, elem1259 := range fields1258 { + if (i1260 > 0) { p.newline() } - p.pretty_instruction(elem1254) + p.pretty_instruction(elem1259) } } p.dedent() @@ -3100,60 +3104,60 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - flat1267 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1267 != nil { - p.write(*flat1267) + flat1272 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1272 != nil { + p.write(*flat1272) return nil } else { _dollar_dollar := msg - var _t1697 *pb.Assign + var _t1707 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1697 = _dollar_dollar.GetAssign() + _t1707 = _dollar_dollar.GetAssign() } - deconstruct_result1265 := _t1697 - if deconstruct_result1265 != nil { - unwrapped1266 := deconstruct_result1265 - p.pretty_assign(unwrapped1266) + deconstruct_result1270 := _t1707 + if deconstruct_result1270 != nil { + unwrapped1271 := deconstruct_result1270 + p.pretty_assign(unwrapped1271) } else { _dollar_dollar := msg - var _t1698 *pb.Upsert + var _t1708 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1698 = _dollar_dollar.GetUpsert() + _t1708 = _dollar_dollar.GetUpsert() } - deconstruct_result1263 := _t1698 - if deconstruct_result1263 != nil { - unwrapped1264 := deconstruct_result1263 - p.pretty_upsert(unwrapped1264) + deconstruct_result1268 := _t1708 + if deconstruct_result1268 != nil { + unwrapped1269 := deconstruct_result1268 + p.pretty_upsert(unwrapped1269) } else { _dollar_dollar := msg - var _t1699 *pb.Break + var _t1709 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1699 = _dollar_dollar.GetBreak() + _t1709 = _dollar_dollar.GetBreak() } - deconstruct_result1261 := _t1699 - if deconstruct_result1261 != nil { - unwrapped1262 := deconstruct_result1261 - p.pretty_break(unwrapped1262) + deconstruct_result1266 := _t1709 + if deconstruct_result1266 != nil { + unwrapped1267 := deconstruct_result1266 + p.pretty_break(unwrapped1267) } else { _dollar_dollar := msg - var _t1700 *pb.MonoidDef + var _t1710 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1700 = _dollar_dollar.GetMonoidDef() + _t1710 = _dollar_dollar.GetMonoidDef() } - deconstruct_result1259 := _t1700 - if deconstruct_result1259 != nil { - unwrapped1260 := deconstruct_result1259 - p.pretty_monoid_def(unwrapped1260) + deconstruct_result1264 := _t1710 + if deconstruct_result1264 != nil { + unwrapped1265 := deconstruct_result1264 + p.pretty_monoid_def(unwrapped1265) } else { _dollar_dollar := msg - var _t1701 *pb.MonusDef + var _t1711 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1701 = _dollar_dollar.GetMonusDef() + _t1711 = _dollar_dollar.GetMonusDef() } - deconstruct_result1257 := _t1701 - if deconstruct_result1257 != nil { - unwrapped1258 := deconstruct_result1257 - p.pretty_monus_def(unwrapped1258) + deconstruct_result1262 := _t1711 + if deconstruct_result1262 != nil { + unwrapped1263 := deconstruct_result1262 + p.pretty_monus_def(unwrapped1263) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3166,32 +3170,32 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - flat1274 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1274 != nil { - p.write(*flat1274) + flat1279 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1279 != nil { + p.write(*flat1279) return nil } else { _dollar_dollar := msg - var _t1702 []*pb.Attribute + var _t1712 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1702 = _dollar_dollar.GetAttrs() + _t1712 = _dollar_dollar.GetAttrs() } - fields1268 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1702} - unwrapped_fields1269 := fields1268 + fields1273 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1712} + unwrapped_fields1274 := fields1273 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1270 := unwrapped_fields1269[0].(*pb.RelationId) - p.pretty_relation_id(field1270) + field1275 := unwrapped_fields1274[0].(*pb.RelationId) + p.pretty_relation_id(field1275) p.newline() - field1271 := unwrapped_fields1269[1].(*pb.Abstraction) - p.pretty_abstraction(field1271) - field1272 := unwrapped_fields1269[2].([]*pb.Attribute) - if field1272 != nil { + field1276 := unwrapped_fields1274[1].(*pb.Abstraction) + p.pretty_abstraction(field1276) + field1277 := unwrapped_fields1274[2].([]*pb.Attribute) + if field1277 != nil { p.newline() - opt_val1273 := field1272 - p.pretty_attrs(opt_val1273) + opt_val1278 := field1277 + p.pretty_attrs(opt_val1278) } p.dedent() p.write(")") @@ -3200,32 +3204,32 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - flat1281 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1281 != nil { - p.write(*flat1281) + flat1286 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1286 != nil { + p.write(*flat1286) return nil } else { _dollar_dollar := msg - var _t1703 []*pb.Attribute + var _t1713 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1703 = _dollar_dollar.GetAttrs() + _t1713 = _dollar_dollar.GetAttrs() } - fields1275 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1703} - unwrapped_fields1276 := fields1275 + fields1280 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1713} + unwrapped_fields1281 := fields1280 p.write("(") p.write("upsert") p.indentSexp() p.newline() - field1277 := unwrapped_fields1276[0].(*pb.RelationId) - p.pretty_relation_id(field1277) + field1282 := unwrapped_fields1281[0].(*pb.RelationId) + p.pretty_relation_id(field1282) p.newline() - field1278 := unwrapped_fields1276[1].([]interface{}) - p.pretty_abstraction_with_arity(field1278) - field1279 := unwrapped_fields1276[2].([]*pb.Attribute) - if field1279 != nil { + field1283 := unwrapped_fields1281[1].([]interface{}) + p.pretty_abstraction_with_arity(field1283) + field1284 := unwrapped_fields1281[2].([]*pb.Attribute) + if field1284 != nil { p.newline() - opt_val1280 := field1279 - p.pretty_attrs(opt_val1280) + opt_val1285 := field1284 + p.pretty_attrs(opt_val1285) } p.dedent() p.write(")") @@ -3234,22 +3238,22 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - flat1286 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1286 != nil { - p.write(*flat1286) + flat1291 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1291 != nil { + p.write(*flat1291) return nil } else { _dollar_dollar := msg - _t1704 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - fields1282 := []interface{}{_t1704, _dollar_dollar[0].(*pb.Abstraction).GetValue()} - unwrapped_fields1283 := fields1282 + _t1714 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) + fields1287 := []interface{}{_t1714, _dollar_dollar[0].(*pb.Abstraction).GetValue()} + unwrapped_fields1288 := fields1287 p.write("(") p.indent() - field1284 := unwrapped_fields1283[0].([]interface{}) - p.pretty_bindings(field1284) + field1289 := unwrapped_fields1288[0].([]interface{}) + p.pretty_bindings(field1289) p.newline() - field1285 := unwrapped_fields1283[1].(*pb.Formula) - p.pretty_formula(field1285) + field1290 := unwrapped_fields1288[1].(*pb.Formula) + p.pretty_formula(field1290) p.dedent() p.write(")") } @@ -3257,32 +3261,32 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1293 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1293 != nil { - p.write(*flat1293) + flat1298 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1298 != nil { + p.write(*flat1298) return nil } else { _dollar_dollar := msg - var _t1705 []*pb.Attribute + var _t1715 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1705 = _dollar_dollar.GetAttrs() + _t1715 = _dollar_dollar.GetAttrs() } - fields1287 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1705} - unwrapped_fields1288 := fields1287 + fields1292 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1715} + unwrapped_fields1293 := fields1292 p.write("(") p.write("break") p.indentSexp() p.newline() - field1289 := unwrapped_fields1288[0].(*pb.RelationId) - p.pretty_relation_id(field1289) + field1294 := unwrapped_fields1293[0].(*pb.RelationId) + p.pretty_relation_id(field1294) p.newline() - field1290 := unwrapped_fields1288[1].(*pb.Abstraction) - p.pretty_abstraction(field1290) - field1291 := unwrapped_fields1288[2].([]*pb.Attribute) - if field1291 != nil { + field1295 := unwrapped_fields1293[1].(*pb.Abstraction) + p.pretty_abstraction(field1295) + field1296 := unwrapped_fields1293[2].([]*pb.Attribute) + if field1296 != nil { p.newline() - opt_val1292 := field1291 - p.pretty_attrs(opt_val1292) + opt_val1297 := field1296 + p.pretty_attrs(opt_val1297) } p.dedent() p.write(")") @@ -3291,35 +3295,35 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - flat1301 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1301 != nil { - p.write(*flat1301) + flat1306 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1306 != nil { + p.write(*flat1306) return nil } else { _dollar_dollar := msg - var _t1706 []*pb.Attribute + var _t1716 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1706 = _dollar_dollar.GetAttrs() + _t1716 = _dollar_dollar.GetAttrs() } - fields1294 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1706} - unwrapped_fields1295 := fields1294 + fields1299 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1716} + unwrapped_fields1300 := fields1299 p.write("(") p.write("monoid") p.indentSexp() p.newline() - field1296 := unwrapped_fields1295[0].(*pb.Monoid) - p.pretty_monoid(field1296) + field1301 := unwrapped_fields1300[0].(*pb.Monoid) + p.pretty_monoid(field1301) p.newline() - field1297 := unwrapped_fields1295[1].(*pb.RelationId) - p.pretty_relation_id(field1297) + field1302 := unwrapped_fields1300[1].(*pb.RelationId) + p.pretty_relation_id(field1302) p.newline() - field1298 := unwrapped_fields1295[2].([]interface{}) - p.pretty_abstraction_with_arity(field1298) - field1299 := unwrapped_fields1295[3].([]*pb.Attribute) - if field1299 != nil { + field1303 := unwrapped_fields1300[2].([]interface{}) + p.pretty_abstraction_with_arity(field1303) + field1304 := unwrapped_fields1300[3].([]*pb.Attribute) + if field1304 != nil { p.newline() - opt_val1300 := field1299 - p.pretty_attrs(opt_val1300) + opt_val1305 := field1304 + p.pretty_attrs(opt_val1305) } p.dedent() p.write(")") @@ -3328,50 +3332,50 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - flat1310 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1310 != nil { - p.write(*flat1310) + flat1315 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1315 != nil { + p.write(*flat1315) return nil } else { _dollar_dollar := msg - var _t1707 *pb.OrMonoid + var _t1717 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1707 = _dollar_dollar.GetOrMonoid() + _t1717 = _dollar_dollar.GetOrMonoid() } - deconstruct_result1308 := _t1707 - if deconstruct_result1308 != nil { - unwrapped1309 := deconstruct_result1308 - p.pretty_or_monoid(unwrapped1309) + deconstruct_result1313 := _t1717 + if deconstruct_result1313 != nil { + unwrapped1314 := deconstruct_result1313 + p.pretty_or_monoid(unwrapped1314) } else { _dollar_dollar := msg - var _t1708 *pb.MinMonoid + var _t1718 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1708 = _dollar_dollar.GetMinMonoid() + _t1718 = _dollar_dollar.GetMinMonoid() } - deconstruct_result1306 := _t1708 - if deconstruct_result1306 != nil { - unwrapped1307 := deconstruct_result1306 - p.pretty_min_monoid(unwrapped1307) + deconstruct_result1311 := _t1718 + if deconstruct_result1311 != nil { + unwrapped1312 := deconstruct_result1311 + p.pretty_min_monoid(unwrapped1312) } else { _dollar_dollar := msg - var _t1709 *pb.MaxMonoid + var _t1719 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1709 = _dollar_dollar.GetMaxMonoid() + _t1719 = _dollar_dollar.GetMaxMonoid() } - deconstruct_result1304 := _t1709 - if deconstruct_result1304 != nil { - unwrapped1305 := deconstruct_result1304 - p.pretty_max_monoid(unwrapped1305) + deconstruct_result1309 := _t1719 + if deconstruct_result1309 != nil { + unwrapped1310 := deconstruct_result1309 + p.pretty_max_monoid(unwrapped1310) } else { _dollar_dollar := msg - var _t1710 *pb.SumMonoid + var _t1720 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1710 = _dollar_dollar.GetSumMonoid() + _t1720 = _dollar_dollar.GetSumMonoid() } - deconstruct_result1302 := _t1710 - if deconstruct_result1302 != nil { - unwrapped1303 := deconstruct_result1302 - p.pretty_sum_monoid(unwrapped1303) + deconstruct_result1307 := _t1720 + if deconstruct_result1307 != nil { + unwrapped1308 := deconstruct_result1307 + p.pretty_sum_monoid(unwrapped1308) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3383,8 +3387,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1311 := msg - _ = fields1311 + fields1316 := msg + _ = fields1316 p.write("(") p.write("or") p.write(")") @@ -3392,19 +3396,19 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1314 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1314 != nil { - p.write(*flat1314) + flat1319 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1319 != nil { + p.write(*flat1319) return nil } else { _dollar_dollar := msg - fields1312 := _dollar_dollar.GetType() - unwrapped_fields1313 := fields1312 + fields1317 := _dollar_dollar.GetType() + unwrapped_fields1318 := fields1317 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1313) + p.pretty_type(unwrapped_fields1318) p.dedent() p.write(")") } @@ -3412,19 +3416,19 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - flat1317 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1317 != nil { - p.write(*flat1317) + flat1322 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1322 != nil { + p.write(*flat1322) return nil } else { _dollar_dollar := msg - fields1315 := _dollar_dollar.GetType() - unwrapped_fields1316 := fields1315 + fields1320 := _dollar_dollar.GetType() + unwrapped_fields1321 := fields1320 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1316) + p.pretty_type(unwrapped_fields1321) p.dedent() p.write(")") } @@ -3432,19 +3436,19 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1320 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1320 != nil { - p.write(*flat1320) + flat1325 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1325 != nil { + p.write(*flat1325) return nil } else { _dollar_dollar := msg - fields1318 := _dollar_dollar.GetType() - unwrapped_fields1319 := fields1318 + fields1323 := _dollar_dollar.GetType() + unwrapped_fields1324 := fields1323 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1319) + p.pretty_type(unwrapped_fields1324) p.dedent() p.write(")") } @@ -3452,35 +3456,35 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - flat1328 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1328 != nil { - p.write(*flat1328) + flat1333 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1333 != nil { + p.write(*flat1333) return nil } else { _dollar_dollar := msg - var _t1711 []*pb.Attribute + var _t1721 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1711 = _dollar_dollar.GetAttrs() + _t1721 = _dollar_dollar.GetAttrs() } - fields1321 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1711} - unwrapped_fields1322 := fields1321 + fields1326 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1721} + unwrapped_fields1327 := fields1326 p.write("(") p.write("monus") p.indentSexp() p.newline() - field1323 := unwrapped_fields1322[0].(*pb.Monoid) - p.pretty_monoid(field1323) + field1328 := unwrapped_fields1327[0].(*pb.Monoid) + p.pretty_monoid(field1328) p.newline() - field1324 := unwrapped_fields1322[1].(*pb.RelationId) - p.pretty_relation_id(field1324) + field1329 := unwrapped_fields1327[1].(*pb.RelationId) + p.pretty_relation_id(field1329) p.newline() - field1325 := unwrapped_fields1322[2].([]interface{}) - p.pretty_abstraction_with_arity(field1325) - field1326 := unwrapped_fields1322[3].([]*pb.Attribute) - if field1326 != nil { + field1330 := unwrapped_fields1327[2].([]interface{}) + p.pretty_abstraction_with_arity(field1330) + field1331 := unwrapped_fields1327[3].([]*pb.Attribute) + if field1331 != nil { p.newline() - opt_val1327 := field1326 - p.pretty_attrs(opt_val1327) + opt_val1332 := field1331 + p.pretty_attrs(opt_val1332) } p.dedent() p.write(")") @@ -3489,29 +3493,29 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - flat1335 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1335 != nil { - p.write(*flat1335) + flat1340 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1340 != nil { + p.write(*flat1340) return nil } else { _dollar_dollar := msg - fields1329 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} - unwrapped_fields1330 := fields1329 + fields1334 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} + unwrapped_fields1335 := fields1334 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() - field1331 := unwrapped_fields1330[0].(*pb.RelationId) - p.pretty_relation_id(field1331) + field1336 := unwrapped_fields1335[0].(*pb.RelationId) + p.pretty_relation_id(field1336) p.newline() - field1332 := unwrapped_fields1330[1].(*pb.Abstraction) - p.pretty_abstraction(field1332) + field1337 := unwrapped_fields1335[1].(*pb.Abstraction) + p.pretty_abstraction(field1337) p.newline() - field1333 := unwrapped_fields1330[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1333) + field1338 := unwrapped_fields1335[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1338) p.newline() - field1334 := unwrapped_fields1330[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1334) + field1339 := unwrapped_fields1335[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1339) p.dedent() p.write(")") } @@ -3519,22 +3523,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - flat1339 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1339 != nil { - p.write(*flat1339) + flat1344 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1344 != nil { + p.write(*flat1344) return nil } else { - fields1336 := msg + fields1341 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1336) == 0) { + if !(len(fields1341) == 0) { p.newline() - for i1338, elem1337 := range fields1336 { - if (i1338 > 0) { + for i1343, elem1342 := range fields1341 { + if (i1343 > 0) { p.newline() } - p.pretty_var(elem1337) + p.pretty_var(elem1342) } } p.dedent() @@ -3544,22 +3548,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - flat1343 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1343 != nil { - p.write(*flat1343) + flat1348 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1348 != nil { + p.write(*flat1348) return nil } else { - fields1340 := msg + fields1345 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1340) == 0) { + if !(len(fields1345) == 0) { p.newline() - for i1342, elem1341 := range fields1340 { - if (i1342 > 0) { + for i1347, elem1346 := range fields1345 { + if (i1347 > 0) { p.newline() } - p.pretty_var(elem1341) + p.pretty_var(elem1346) } } p.dedent() @@ -3569,50 +3573,50 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - flat1352 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1352 != nil { - p.write(*flat1352) + flat1357 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1357 != nil { + p.write(*flat1357) return nil } else { _dollar_dollar := msg - var _t1712 *pb.EDB + var _t1722 *pb.EDB if hasProtoField(_dollar_dollar, "edb") { - _t1712 = _dollar_dollar.GetEdb() + _t1722 = _dollar_dollar.GetEdb() } - deconstruct_result1350 := _t1712 - if deconstruct_result1350 != nil { - unwrapped1351 := deconstruct_result1350 - p.pretty_edb(unwrapped1351) + deconstruct_result1355 := _t1722 + if deconstruct_result1355 != nil { + unwrapped1356 := deconstruct_result1355 + p.pretty_edb(unwrapped1356) } else { _dollar_dollar := msg - var _t1713 *pb.BeTreeRelation + var _t1723 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1713 = _dollar_dollar.GetBetreeRelation() + _t1723 = _dollar_dollar.GetBetreeRelation() } - deconstruct_result1348 := _t1713 - if deconstruct_result1348 != nil { - unwrapped1349 := deconstruct_result1348 - p.pretty_betree_relation(unwrapped1349) + deconstruct_result1353 := _t1723 + if deconstruct_result1353 != nil { + unwrapped1354 := deconstruct_result1353 + p.pretty_betree_relation(unwrapped1354) } else { _dollar_dollar := msg - var _t1714 *pb.CSVData + var _t1724 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1714 = _dollar_dollar.GetCsvData() + _t1724 = _dollar_dollar.GetCsvData() } - deconstruct_result1346 := _t1714 - if deconstruct_result1346 != nil { - unwrapped1347 := deconstruct_result1346 - p.pretty_csv_data(unwrapped1347) + deconstruct_result1351 := _t1724 + if deconstruct_result1351 != nil { + unwrapped1352 := deconstruct_result1351 + p.pretty_csv_data(unwrapped1352) } else { _dollar_dollar := msg - var _t1715 *pb.IcebergData + var _t1725 *pb.IcebergData if hasProtoField(_dollar_dollar, "iceberg_data") { - _t1715 = _dollar_dollar.GetIcebergData() + _t1725 = _dollar_dollar.GetIcebergData() } - deconstruct_result1344 := _t1715 - if deconstruct_result1344 != nil { - unwrapped1345 := deconstruct_result1344 - p.pretty_iceberg_data(unwrapped1345) + deconstruct_result1349 := _t1725 + if deconstruct_result1349 != nil { + unwrapped1350 := deconstruct_result1349 + p.pretty_iceberg_data(unwrapped1350) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3624,26 +3628,26 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { - flat1358 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) - if flat1358 != nil { - p.write(*flat1358) + flat1363 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) + if flat1363 != nil { + p.write(*flat1363) return nil } else { _dollar_dollar := msg - fields1353 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} - unwrapped_fields1354 := fields1353 + fields1358 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} + unwrapped_fields1359 := fields1358 p.write("(") p.write("edb") p.indentSexp() p.newline() - field1355 := unwrapped_fields1354[0].(*pb.RelationId) - p.pretty_relation_id(field1355) + field1360 := unwrapped_fields1359[0].(*pb.RelationId) + p.pretty_relation_id(field1360) p.newline() - field1356 := unwrapped_fields1354[1].([]string) - p.pretty_edb_path(field1356) + field1361 := unwrapped_fields1359[1].([]string) + p.pretty_edb_path(field1361) p.newline() - field1357 := unwrapped_fields1354[2].([]*pb.Type) - p.pretty_edb_types(field1357) + field1362 := unwrapped_fields1359[2].([]*pb.Type) + p.pretty_edb_types(field1362) p.dedent() p.write(")") } @@ -3651,19 +3655,19 @@ func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { } func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { - flat1362 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) - if flat1362 != nil { - p.write(*flat1362) + flat1367 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) + if flat1367 != nil { + p.write(*flat1367) return nil } else { - fields1359 := msg + fields1364 := msg p.write("[") p.indent() - for i1361, elem1360 := range fields1359 { - if (i1361 > 0) { + for i1366, elem1365 := range fields1364 { + if (i1366 > 0) { p.newline() } - p.write(p.formatStringValue(elem1360)) + p.write(p.formatStringValue(elem1365)) } p.dedent() p.write("]") @@ -3672,19 +3676,19 @@ func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { - flat1366 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) - if flat1366 != nil { - p.write(*flat1366) + flat1371 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) + if flat1371 != nil { + p.write(*flat1371) return nil } else { - fields1363 := msg + fields1368 := msg p.write("[") p.indent() - for i1365, elem1364 := range fields1363 { - if (i1365 > 0) { + for i1370, elem1369 := range fields1368 { + if (i1370 > 0) { p.newline() } - p.pretty_type(elem1364) + p.pretty_type(elem1369) } p.dedent() p.write("]") @@ -3693,23 +3697,23 @@ func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - flat1371 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1371 != nil { - p.write(*flat1371) + flat1376 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1376 != nil { + p.write(*flat1376) return nil } else { _dollar_dollar := msg - fields1367 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} - unwrapped_fields1368 := fields1367 + fields1372 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} + unwrapped_fields1373 := fields1372 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - field1369 := unwrapped_fields1368[0].(*pb.RelationId) - p.pretty_relation_id(field1369) + field1374 := unwrapped_fields1373[0].(*pb.RelationId) + p.pretty_relation_id(field1374) p.newline() - field1370 := unwrapped_fields1368[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1370) + field1375 := unwrapped_fields1373[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1375) p.dedent() p.write(")") } @@ -3717,27 +3721,27 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - flat1377 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1377 != nil { - p.write(*flat1377) + flat1382 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1382 != nil { + p.write(*flat1382) return nil } else { _dollar_dollar := msg - _t1716 := p.deconstruct_betree_info_config(_dollar_dollar) - fields1372 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1716} - unwrapped_fields1373 := fields1372 + _t1726 := p.deconstruct_betree_info_config(_dollar_dollar) + fields1377 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1726} + unwrapped_fields1378 := fields1377 p.write("(") p.write("betree_info") p.indentSexp() p.newline() - field1374 := unwrapped_fields1373[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1374) + field1379 := unwrapped_fields1378[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1379) p.newline() - field1375 := unwrapped_fields1373[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1375) + field1380 := unwrapped_fields1378[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1380) p.newline() - field1376 := unwrapped_fields1373[2].([][]interface{}) - p.pretty_config_dict(field1376) + field1381 := unwrapped_fields1378[2].([][]interface{}) + p.pretty_config_dict(field1381) p.dedent() p.write(")") } @@ -3745,22 +3749,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - flat1381 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1381 != nil { - p.write(*flat1381) + flat1386 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1386 != nil { + p.write(*flat1386) return nil } else { - fields1378 := msg + fields1383 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1378) == 0) { + if !(len(fields1383) == 0) { p.newline() - for i1380, elem1379 := range fields1378 { - if (i1380 > 0) { + for i1385, elem1384 := range fields1383 { + if (i1385 > 0) { p.newline() } - p.pretty_type(elem1379) + p.pretty_type(elem1384) } } p.dedent() @@ -3770,22 +3774,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{} { - flat1385 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1385 != nil { - p.write(*flat1385) + flat1390 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1390 != nil { + p.write(*flat1390) return nil } else { - fields1382 := msg + fields1387 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1382) == 0) { + if !(len(fields1387) == 0) { p.newline() - for i1384, elem1383 := range fields1382 { - if (i1384 > 0) { + for i1389, elem1388 := range fields1387 { + if (i1389 > 0) { p.newline() } - p.pretty_type(elem1383) + p.pretty_type(elem1388) } } p.dedent() @@ -3795,29 +3799,29 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - flat1392 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1392 != nil { - p.write(*flat1392) + flat1397 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1397 != nil { + p.write(*flat1397) return nil } else { _dollar_dollar := msg - fields1386 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} - unwrapped_fields1387 := fields1386 + fields1391 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} + unwrapped_fields1392 := fields1391 p.write("(") p.write("csv_data") p.indentSexp() p.newline() - field1388 := unwrapped_fields1387[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1388) + field1393 := unwrapped_fields1392[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1393) p.newline() - field1389 := unwrapped_fields1387[1].(*pb.CSVConfig) - p.pretty_csv_config(field1389) + field1394 := unwrapped_fields1392[1].(*pb.CSVConfig) + p.pretty_csv_config(field1394) p.newline() - field1390 := unwrapped_fields1387[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1390) + field1395 := unwrapped_fields1392[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1395) p.newline() - field1391 := unwrapped_fields1387[3].(string) - p.pretty_csv_asof(field1391) + field1396 := unwrapped_fields1392[3].(string) + p.pretty_csv_asof(field1396) p.dedent() p.write(")") } @@ -3825,36 +3829,36 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - flat1399 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1399 != nil { - p.write(*flat1399) + flat1404 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1404 != nil { + p.write(*flat1404) return nil } else { _dollar_dollar := msg - var _t1717 []string + var _t1727 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1717 = _dollar_dollar.GetPaths() + _t1727 = _dollar_dollar.GetPaths() } - var _t1718 *string + var _t1728 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1718 = ptr(string(_dollar_dollar.GetInlineData())) + _t1728 = ptr(string(_dollar_dollar.GetInlineData())) } - fields1393 := []interface{}{_t1717, _t1718} - unwrapped_fields1394 := fields1393 + fields1398 := []interface{}{_t1727, _t1728} + unwrapped_fields1399 := fields1398 p.write("(") p.write("csv_locator") p.indentSexp() - field1395 := unwrapped_fields1394[0].([]string) - if field1395 != nil { + field1400 := unwrapped_fields1399[0].([]string) + if field1400 != nil { p.newline() - opt_val1396 := field1395 - p.pretty_csv_locator_paths(opt_val1396) + opt_val1401 := field1400 + p.pretty_csv_locator_paths(opt_val1401) } - field1397 := unwrapped_fields1394[1].(*string) - if field1397 != nil { + field1402 := unwrapped_fields1399[1].(*string) + if field1402 != nil { p.newline() - opt_val1398 := *field1397 - p.pretty_csv_locator_inline_data(opt_val1398) + opt_val1403 := *field1402 + p.pretty_csv_locator_inline_data(opt_val1403) } p.dedent() p.write(")") @@ -3863,22 +3867,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - flat1403 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1403 != nil { - p.write(*flat1403) + flat1408 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1408 != nil { + p.write(*flat1408) return nil } else { - fields1400 := msg + fields1405 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1400) == 0) { + if !(len(fields1405) == 0) { p.newline() - for i1402, elem1401 := range fields1400 { - if (i1402 > 0) { + for i1407, elem1406 := range fields1405 { + if (i1407 > 0) { p.newline() } - p.write(p.formatStringValue(elem1401)) + p.write(p.formatStringValue(elem1406)) } } p.dedent() @@ -3888,17 +3892,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - flat1405 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1405 != nil { - p.write(*flat1405) + flat1410 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1410 != nil { + p.write(*flat1410) return nil } else { - fields1404 := msg + fields1409 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1404)) + p.write(p.formatStringValue(fields1409)) p.dedent() p.write(")") } @@ -3906,27 +3910,27 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - flat1411 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1411 != nil { - p.write(*flat1411) + flat1416 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1416 != nil { + p.write(*flat1416) return nil } else { _dollar_dollar := msg - _t1719 := p.deconstruct_csv_config(_dollar_dollar) - _t1720 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1406 := []interface{}{_t1719, _t1720} - unwrapped_fields1407 := fields1406 + _t1729 := p.deconstruct_csv_config(_dollar_dollar) + _t1730 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1411 := []interface{}{_t1729, _t1730} + unwrapped_fields1412 := fields1411 p.write("(") p.write("csv_config") p.indentSexp() p.newline() - field1408 := unwrapped_fields1407[0].([][]interface{}) - p.pretty_config_dict(field1408) - field1409 := unwrapped_fields1407[1].([][]interface{}) - if field1409 != nil { + field1413 := unwrapped_fields1412[0].([][]interface{}) + p.pretty_config_dict(field1413) + field1414 := unwrapped_fields1412[1].([][]interface{}) + if field1414 != nil { p.newline() - opt_val1410 := field1409 - p.pretty__storage_integration(opt_val1410) + opt_val1415 := field1414 + p.pretty__storage_integration(opt_val1415) } p.dedent() p.write(")") @@ -3935,17 +3939,17 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interface{} { - flat1413 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) - if flat1413 != nil { - p.write(*flat1413) + flat1418 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) + if flat1418 != nil { + p.write(*flat1418) return nil } else { - fields1412 := msg + fields1417 := msg p.write("(") p.write("storage_integration") p.indentSexp() p.newline() - p.pretty_config_dict(fields1412) + p.pretty_config_dict(fields1417) p.dedent() p.write(")") } @@ -3953,22 +3957,22 @@ func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interfa } func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { - flat1417 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) - if flat1417 != nil { - p.write(*flat1417) + flat1422 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) + if flat1422 != nil { + p.write(*flat1422) return nil } else { - fields1414 := msg + fields1419 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1414) == 0) { + if !(len(fields1419) == 0) { p.newline() - for i1416, elem1415 := range fields1414 { - if (i1416 > 0) { + for i1421, elem1420 := range fields1419 { + if (i1421 > 0) { p.newline() } - p.pretty_gnf_column(elem1415) + p.pretty_gnf_column(elem1420) } } p.dedent() @@ -3978,38 +3982,38 @@ func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { - flat1426 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) - if flat1426 != nil { - p.write(*flat1426) + flat1431 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) + if flat1431 != nil { + p.write(*flat1431) return nil } else { _dollar_dollar := msg - var _t1721 *pb.RelationId + var _t1731 *pb.RelationId if hasProtoField(_dollar_dollar, "target_id") { - _t1721 = _dollar_dollar.GetTargetId() + _t1731 = _dollar_dollar.GetTargetId() } - fields1418 := []interface{}{_dollar_dollar.GetColumnPath(), _t1721, _dollar_dollar.GetTypes()} - unwrapped_fields1419 := fields1418 + fields1423 := []interface{}{_dollar_dollar.GetColumnPath(), _t1731, _dollar_dollar.GetTypes()} + unwrapped_fields1424 := fields1423 p.write("(") p.write("column") p.indentSexp() p.newline() - field1420 := unwrapped_fields1419[0].([]string) - p.pretty_gnf_column_path(field1420) - field1421 := unwrapped_fields1419[1].(*pb.RelationId) - if field1421 != nil { + field1425 := unwrapped_fields1424[0].([]string) + p.pretty_gnf_column_path(field1425) + field1426 := unwrapped_fields1424[1].(*pb.RelationId) + if field1426 != nil { p.newline() - opt_val1422 := field1421 - p.pretty_relation_id(opt_val1422) + opt_val1427 := field1426 + p.pretty_relation_id(opt_val1427) } p.newline() p.write("[") - field1423 := unwrapped_fields1419[2].([]*pb.Type) - for i1425, elem1424 := range field1423 { - if (i1425 > 0) { + field1428 := unwrapped_fields1424[2].([]*pb.Type) + for i1430, elem1429 := range field1428 { + if (i1430 > 0) { p.newline() } - p.pretty_type(elem1424) + p.pretty_type(elem1429) } p.write("]") p.dedent() @@ -4019,36 +4023,36 @@ func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { - flat1433 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) - if flat1433 != nil { - p.write(*flat1433) + flat1438 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) + if flat1438 != nil { + p.write(*flat1438) return nil } else { _dollar_dollar := msg - var _t1722 *string + var _t1732 *string if int64(len(_dollar_dollar)) == 1 { - _t1722 = ptr(_dollar_dollar[0]) + _t1732 = ptr(_dollar_dollar[0]) } - deconstruct_result1431 := _t1722 - if deconstruct_result1431 != nil { - unwrapped1432 := *deconstruct_result1431 - p.write(p.formatStringValue(unwrapped1432)) + deconstruct_result1436 := _t1732 + if deconstruct_result1436 != nil { + unwrapped1437 := *deconstruct_result1436 + p.write(p.formatStringValue(unwrapped1437)) } else { _dollar_dollar := msg - var _t1723 []string + var _t1733 []string if int64(len(_dollar_dollar)) != 1 { - _t1723 = _dollar_dollar + _t1733 = _dollar_dollar } - deconstruct_result1427 := _t1723 - if deconstruct_result1427 != nil { - unwrapped1428 := deconstruct_result1427 + deconstruct_result1432 := _t1733 + if deconstruct_result1432 != nil { + unwrapped1433 := deconstruct_result1432 p.write("[") p.indent() - for i1430, elem1429 := range unwrapped1428 { - if (i1430 > 0) { + for i1435, elem1434 := range unwrapped1433 { + if (i1435 > 0) { p.newline() } - p.write(p.formatStringValue(elem1429)) + p.write(p.formatStringValue(elem1434)) } p.dedent() p.write("]") @@ -4061,17 +4065,17 @@ func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1435 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1435 != nil { - p.write(*flat1435) + flat1440 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1440 != nil { + p.write(*flat1440) return nil } else { - fields1434 := msg + fields1439 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1434)) + p.write(p.formatStringValue(fields1439)) p.dedent() p.write(")") } @@ -4079,43 +4083,43 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { - flat1446 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) - if flat1446 != nil { - p.write(*flat1446) + flat1451 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) + if flat1451 != nil { + p.write(*flat1451) return nil } else { _dollar_dollar := msg - _t1724 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1725 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1436 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1724, _t1725, _dollar_dollar.GetReturnsDelta()} - unwrapped_fields1437 := fields1436 + _t1734 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1735 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1441 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1734, _t1735, _dollar_dollar.GetReturnsDelta()} + unwrapped_fields1442 := fields1441 p.write("(") p.write("iceberg_data") p.indentSexp() p.newline() - field1438 := unwrapped_fields1437[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1438) + field1443 := unwrapped_fields1442[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1443) p.newline() - field1439 := unwrapped_fields1437[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1439) + field1444 := unwrapped_fields1442[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1444) p.newline() - field1440 := unwrapped_fields1437[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1440) - field1441 := unwrapped_fields1437[3].(*string) - if field1441 != nil { + field1445 := unwrapped_fields1442[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1445) + field1446 := unwrapped_fields1442[3].(*string) + if field1446 != nil { p.newline() - opt_val1442 := *field1441 - p.pretty_iceberg_from_snapshot(opt_val1442) + opt_val1447 := *field1446 + p.pretty_iceberg_from_snapshot(opt_val1447) } - field1443 := unwrapped_fields1437[4].(*string) - if field1443 != nil { + field1448 := unwrapped_fields1442[4].(*string) + if field1448 != nil { p.newline() - opt_val1444 := *field1443 - p.pretty_iceberg_to_snapshot(opt_val1444) + opt_val1449 := *field1448 + p.pretty_iceberg_to_snapshot(opt_val1449) } p.newline() - field1445 := unwrapped_fields1437[5].(bool) - p.pretty_boolean_value(field1445) + field1450 := unwrapped_fields1442[5].(bool) + p.pretty_boolean_value(field1450) p.dedent() p.write(")") } @@ -4123,26 +4127,26 @@ func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { } func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface{} { - flat1452 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) - if flat1452 != nil { - p.write(*flat1452) + flat1457 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) + if flat1457 != nil { + p.write(*flat1457) return nil } else { _dollar_dollar := msg - fields1447 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} - unwrapped_fields1448 := fields1447 + fields1452 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} + unwrapped_fields1453 := fields1452 p.write("(") p.write("iceberg_locator") p.indentSexp() p.newline() - field1449 := unwrapped_fields1448[0].(string) - p.pretty_iceberg_locator_table_name(field1449) + field1454 := unwrapped_fields1453[0].(string) + p.pretty_iceberg_locator_table_name(field1454) p.newline() - field1450 := unwrapped_fields1448[1].([]string) - p.pretty_iceberg_locator_namespace(field1450) + field1455 := unwrapped_fields1453[1].([]string) + p.pretty_iceberg_locator_namespace(field1455) p.newline() - field1451 := unwrapped_fields1448[2].(string) - p.pretty_iceberg_locator_warehouse(field1451) + field1456 := unwrapped_fields1453[2].(string) + p.pretty_iceberg_locator_warehouse(field1456) p.dedent() p.write(")") } @@ -4150,17 +4154,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface } func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{} { - flat1454 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) - if flat1454 != nil { - p.write(*flat1454) + flat1459 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) + if flat1459 != nil { + p.write(*flat1459) return nil } else { - fields1453 := msg + fields1458 := msg p.write("(") p.write("table_name") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1453)) + p.write(p.formatStringValue(fields1458)) p.dedent() p.write(")") } @@ -4168,22 +4172,22 @@ func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{ } func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface{} { - flat1458 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) - if flat1458 != nil { - p.write(*flat1458) + flat1463 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) + if flat1463 != nil { + p.write(*flat1463) return nil } else { - fields1455 := msg + fields1460 := msg p.write("(") p.write("namespace") p.indentSexp() - if !(len(fields1455) == 0) { + if !(len(fields1460) == 0) { p.newline() - for i1457, elem1456 := range fields1455 { - if (i1457 > 0) { + for i1462, elem1461 := range fields1460 { + if (i1462 > 0) { p.newline() } - p.write(p.formatStringValue(elem1456)) + p.write(p.formatStringValue(elem1461)) } } p.dedent() @@ -4193,17 +4197,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface } func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} { - flat1460 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) - if flat1460 != nil { - p.write(*flat1460) + flat1465 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) + if flat1465 != nil { + p.write(*flat1465) return nil } else { - fields1459 := msg + fields1464 := msg p.write("(") p.write("warehouse") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1459)) + p.write(p.formatStringValue(fields1464)) p.dedent() p.write(")") } @@ -4211,33 +4215,33 @@ func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} } func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConfig) interface{} { - flat1468 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) - if flat1468 != nil { - p.write(*flat1468) + flat1473 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) + if flat1473 != nil { + p.write(*flat1473) return nil } else { _dollar_dollar := msg - _t1726 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1461 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1726, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} - unwrapped_fields1462 := fields1461 + _t1736 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1466 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1736, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} + unwrapped_fields1467 := fields1466 p.write("(") p.write("iceberg_catalog_config") p.indentSexp() p.newline() - field1463 := unwrapped_fields1462[0].(string) - p.pretty_iceberg_catalog_uri(field1463) - field1464 := unwrapped_fields1462[1].(*string) - if field1464 != nil { + field1468 := unwrapped_fields1467[0].(string) + p.pretty_iceberg_catalog_uri(field1468) + field1469 := unwrapped_fields1467[1].(*string) + if field1469 != nil { p.newline() - opt_val1465 := *field1464 - p.pretty_iceberg_catalog_config_scope(opt_val1465) + opt_val1470 := *field1469 + p.pretty_iceberg_catalog_config_scope(opt_val1470) } p.newline() - field1466 := unwrapped_fields1462[2].([][]interface{}) - p.pretty_iceberg_properties(field1466) + field1471 := unwrapped_fields1467[2].([][]interface{}) + p.pretty_iceberg_properties(field1471) p.newline() - field1467 := unwrapped_fields1462[3].([][]interface{}) - p.pretty_iceberg_auth_properties(field1467) + field1472 := unwrapped_fields1467[3].([][]interface{}) + p.pretty_iceberg_auth_properties(field1472) p.dedent() p.write(")") } @@ -4245,17 +4249,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConf } func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { - flat1470 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) - if flat1470 != nil { - p.write(*flat1470) + flat1475 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) + if flat1475 != nil { + p.write(*flat1475) return nil } else { - fields1469 := msg + fields1474 := msg p.write("(") p.write("catalog_uri") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1469)) + p.write(p.formatStringValue(fields1474)) p.dedent() p.write(")") } @@ -4263,17 +4267,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interface{} { - flat1472 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) - if flat1472 != nil { - p.write(*flat1472) + flat1477 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) + if flat1477 != nil { + p.write(*flat1477) return nil } else { - fields1471 := msg + fields1476 := msg p.write("(") p.write("scope") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1471)) + p.write(p.formatStringValue(fields1476)) p.dedent() p.write(")") } @@ -4281,22 +4285,22 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interfac } func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface{} { - flat1476 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) - if flat1476 != nil { - p.write(*flat1476) + flat1481 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) + if flat1481 != nil { + p.write(*flat1481) return nil } else { - fields1473 := msg + fields1478 := msg p.write("(") p.write("properties") p.indentSexp() - if !(len(fields1473) == 0) { + if !(len(fields1478) == 0) { p.newline() - for i1475, elem1474 := range fields1473 { - if (i1475 > 0) { + for i1480, elem1479 := range fields1478 { + if (i1480 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1474) + p.pretty_iceberg_property_entry(elem1479) } } p.dedent() @@ -4306,23 +4310,23 @@ func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface } func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interface{} { - flat1481 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) - if flat1481 != nil { - p.write(*flat1481) + flat1486 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) + if flat1486 != nil { + p.write(*flat1486) return nil } else { _dollar_dollar := msg - fields1477 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} - unwrapped_fields1478 := fields1477 + fields1482 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} + unwrapped_fields1483 := fields1482 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1479 := unwrapped_fields1478[0].(string) - p.write(p.formatStringValue(field1479)) + field1484 := unwrapped_fields1483[0].(string) + p.write(p.formatStringValue(field1484)) p.newline() - field1480 := unwrapped_fields1478[1].(string) - p.write(p.formatStringValue(field1480)) + field1485 := unwrapped_fields1483[1].(string) + p.write(p.formatStringValue(field1485)) p.dedent() p.write(")") } @@ -4330,22 +4334,22 @@ func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) interface{} { - flat1485 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) - if flat1485 != nil { - p.write(*flat1485) + flat1490 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) + if flat1490 != nil { + p.write(*flat1490) return nil } else { - fields1482 := msg + fields1487 := msg p.write("(") p.write("auth_properties") p.indentSexp() - if !(len(fields1482) == 0) { + if !(len(fields1487) == 0) { p.newline() - for i1484, elem1483 := range fields1482 { - if (i1484 > 0) { + for i1489, elem1488 := range fields1487 { + if (i1489 > 0) { p.newline() } - p.pretty_iceberg_masked_property_entry(elem1483) + p.pretty_iceberg_masked_property_entry(elem1488) } } p.dedent() @@ -4355,24 +4359,24 @@ func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) inte } func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) interface{} { - flat1490 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) - if flat1490 != nil { - p.write(*flat1490) + flat1495 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) + if flat1495 != nil { + p.write(*flat1495) return nil } else { _dollar_dollar := msg - _t1727 := p.mask_secret_value(_dollar_dollar) - fields1486 := []interface{}{_dollar_dollar[0].(string), _t1727} - unwrapped_fields1487 := fields1486 + _t1737 := p.mask_secret_value(_dollar_dollar) + fields1491 := []interface{}{_dollar_dollar[0].(string), _t1737} + unwrapped_fields1492 := fields1491 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1488 := unwrapped_fields1487[0].(string) - p.write(p.formatStringValue(field1488)) + field1493 := unwrapped_fields1492[0].(string) + p.write(p.formatStringValue(field1493)) p.newline() - field1489 := unwrapped_fields1487[1].(string) - p.write(p.formatStringValue(field1489)) + field1494 := unwrapped_fields1492[1].(string) + p.write(p.formatStringValue(field1494)) p.dedent() p.write(")") } @@ -4380,17 +4384,17 @@ func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) } func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { - flat1492 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) - if flat1492 != nil { - p.write(*flat1492) + flat1497 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) + if flat1497 != nil { + p.write(*flat1497) return nil } else { - fields1491 := msg + fields1496 := msg p.write("(") p.write("from_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1491)) + p.write(p.formatStringValue(fields1496)) p.dedent() p.write(")") } @@ -4398,17 +4402,17 @@ func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { - flat1494 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) - if flat1494 != nil { - p.write(*flat1494) + flat1499 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) + if flat1499 != nil { + p.write(*flat1499) return nil } else { - fields1493 := msg + fields1498 := msg p.write("(") p.write("to_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1493)) + p.write(p.formatStringValue(fields1498)) p.dedent() p.write(")") } @@ -4416,19 +4420,19 @@ func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - flat1497 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1497 != nil { - p.write(*flat1497) + flat1502 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1502 != nil { + p.write(*flat1502) return nil } else { _dollar_dollar := msg - fields1495 := _dollar_dollar.GetFragmentId() - unwrapped_fields1496 := fields1495 + fields1500 := _dollar_dollar.GetFragmentId() + unwrapped_fields1501 := fields1500 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1496) + p.pretty_fragment_id(unwrapped_fields1501) p.dedent() p.write(")") } @@ -4436,24 +4440,24 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1502 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1502 != nil { - p.write(*flat1502) + flat1507 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1507 != nil { + p.write(*flat1507) return nil } else { _dollar_dollar := msg - fields1498 := _dollar_dollar.GetRelations() - unwrapped_fields1499 := fields1498 + fields1503 := _dollar_dollar.GetRelations() + unwrapped_fields1504 := fields1503 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1499) == 0) { + if !(len(unwrapped_fields1504) == 0) { p.newline() - for i1501, elem1500 := range unwrapped_fields1499 { - if (i1501 > 0) { + for i1506, elem1505 := range unwrapped_fields1504 { + if (i1506 > 0) { p.newline() } - p.pretty_relation_id(elem1500) + p.pretty_relation_id(elem1505) } } p.dedent() @@ -4463,28 +4467,28 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - flat1509 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1509 != nil { - p.write(*flat1509) + flat1514 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1514 != nil { + p.write(*flat1514) return nil } else { _dollar_dollar := msg - fields1503 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} - unwrapped_fields1504 := fields1503 + fields1508 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} + unwrapped_fields1509 := fields1508 p.write("(") p.write("snapshot") p.indentSexp() p.newline() - field1505 := unwrapped_fields1504[0].([]string) - p.pretty_edb_path(field1505) - field1506 := unwrapped_fields1504[1].([]*pb.SnapshotMapping) - if !(len(field1506) == 0) { + field1510 := unwrapped_fields1509[0].([]string) + p.pretty_edb_path(field1510) + field1511 := unwrapped_fields1509[1].([]*pb.SnapshotMapping) + if !(len(field1511) == 0) { p.newline() - for i1508, elem1507 := range field1506 { - if (i1508 > 0) { + for i1513, elem1512 := range field1511 { + if (i1513 > 0) { p.newline() } - p.pretty_snapshot_mapping(elem1507) + p.pretty_snapshot_mapping(elem1512) } } p.dedent() @@ -4494,40 +4498,40 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} { - flat1514 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) - if flat1514 != nil { - p.write(*flat1514) + flat1519 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) + if flat1519 != nil { + p.write(*flat1519) return nil } else { _dollar_dollar := msg - fields1510 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} - unwrapped_fields1511 := fields1510 - field1512 := unwrapped_fields1511[0].([]string) - p.pretty_edb_path(field1512) + fields1515 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} + unwrapped_fields1516 := fields1515 + field1517 := unwrapped_fields1516[0].([]string) + p.pretty_edb_path(field1517) p.write(" ") - field1513 := unwrapped_fields1511[1].(*pb.RelationId) - p.pretty_relation_id(field1513) + field1518 := unwrapped_fields1516[1].(*pb.RelationId) + p.pretty_relation_id(field1518) } return nil } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - flat1518 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1518 != nil { - p.write(*flat1518) + flat1523 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1523 != nil { + p.write(*flat1523) return nil } else { - fields1515 := msg + fields1520 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1515) == 0) { + if !(len(fields1520) == 0) { p.newline() - for i1517, elem1516 := range fields1515 { - if (i1517 > 0) { + for i1522, elem1521 := range fields1520 { + if (i1522 > 0) { p.newline() } - p.pretty_read(elem1516) + p.pretty_read(elem1521) } } p.dedent() @@ -4537,60 +4541,60 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - flat1529 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1529 != nil { - p.write(*flat1529) + flat1534 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1534 != nil { + p.write(*flat1534) return nil } else { _dollar_dollar := msg - var _t1728 *pb.Demand + var _t1738 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1728 = _dollar_dollar.GetDemand() + _t1738 = _dollar_dollar.GetDemand() } - deconstruct_result1527 := _t1728 - if deconstruct_result1527 != nil { - unwrapped1528 := deconstruct_result1527 - p.pretty_demand(unwrapped1528) + deconstruct_result1532 := _t1738 + if deconstruct_result1532 != nil { + unwrapped1533 := deconstruct_result1532 + p.pretty_demand(unwrapped1533) } else { _dollar_dollar := msg - var _t1729 *pb.Output + var _t1739 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1729 = _dollar_dollar.GetOutput() + _t1739 = _dollar_dollar.GetOutput() } - deconstruct_result1525 := _t1729 - if deconstruct_result1525 != nil { - unwrapped1526 := deconstruct_result1525 - p.pretty_output(unwrapped1526) + deconstruct_result1530 := _t1739 + if deconstruct_result1530 != nil { + unwrapped1531 := deconstruct_result1530 + p.pretty_output(unwrapped1531) } else { _dollar_dollar := msg - var _t1730 *pb.WhatIf + var _t1740 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1730 = _dollar_dollar.GetWhatIf() + _t1740 = _dollar_dollar.GetWhatIf() } - deconstruct_result1523 := _t1730 - if deconstruct_result1523 != nil { - unwrapped1524 := deconstruct_result1523 - p.pretty_what_if(unwrapped1524) + deconstruct_result1528 := _t1740 + if deconstruct_result1528 != nil { + unwrapped1529 := deconstruct_result1528 + p.pretty_what_if(unwrapped1529) } else { _dollar_dollar := msg - var _t1731 *pb.Abort + var _t1741 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1731 = _dollar_dollar.GetAbort() + _t1741 = _dollar_dollar.GetAbort() } - deconstruct_result1521 := _t1731 - if deconstruct_result1521 != nil { - unwrapped1522 := deconstruct_result1521 - p.pretty_abort(unwrapped1522) + deconstruct_result1526 := _t1741 + if deconstruct_result1526 != nil { + unwrapped1527 := deconstruct_result1526 + p.pretty_abort(unwrapped1527) } else { _dollar_dollar := msg - var _t1732 *pb.Export + var _t1742 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1732 = _dollar_dollar.GetExport() + _t1742 = _dollar_dollar.GetExport() } - deconstruct_result1519 := _t1732 - if deconstruct_result1519 != nil { - unwrapped1520 := deconstruct_result1519 - p.pretty_export(unwrapped1520) + deconstruct_result1524 := _t1742 + if deconstruct_result1524 != nil { + unwrapped1525 := deconstruct_result1524 + p.pretty_export(unwrapped1525) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -4603,19 +4607,19 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - flat1532 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1532 != nil { - p.write(*flat1532) + flat1537 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1537 != nil { + p.write(*flat1537) return nil } else { _dollar_dollar := msg - fields1530 := _dollar_dollar.GetRelationId() - unwrapped_fields1531 := fields1530 + fields1535 := _dollar_dollar.GetRelationId() + unwrapped_fields1536 := fields1535 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1531) + p.pretty_relation_id(unwrapped_fields1536) p.dedent() p.write(")") } @@ -4623,23 +4627,23 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - flat1537 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1537 != nil { - p.write(*flat1537) + flat1542 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1542 != nil { + p.write(*flat1542) return nil } else { _dollar_dollar := msg - fields1533 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} - unwrapped_fields1534 := fields1533 + fields1538 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} + unwrapped_fields1539 := fields1538 p.write("(") p.write("output") p.indentSexp() p.newline() - field1535 := unwrapped_fields1534[0].(string) - p.pretty_name(field1535) + field1540 := unwrapped_fields1539[0].(string) + p.pretty_name(field1540) p.newline() - field1536 := unwrapped_fields1534[1].(*pb.RelationId) - p.pretty_relation_id(field1536) + field1541 := unwrapped_fields1539[1].(*pb.RelationId) + p.pretty_relation_id(field1541) p.dedent() p.write(")") } @@ -4647,23 +4651,23 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - flat1542 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1542 != nil { - p.write(*flat1542) + flat1547 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1547 != nil { + p.write(*flat1547) return nil } else { _dollar_dollar := msg - fields1538 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} - unwrapped_fields1539 := fields1538 + fields1543 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} + unwrapped_fields1544 := fields1543 p.write("(") p.write("what_if") p.indentSexp() p.newline() - field1540 := unwrapped_fields1539[0].(string) - p.pretty_name(field1540) + field1545 := unwrapped_fields1544[0].(string) + p.pretty_name(field1545) p.newline() - field1541 := unwrapped_fields1539[1].(*pb.Epoch) - p.pretty_epoch(field1541) + field1546 := unwrapped_fields1544[1].(*pb.Epoch) + p.pretty_epoch(field1546) p.dedent() p.write(")") } @@ -4671,30 +4675,30 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - flat1548 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1548 != nil { - p.write(*flat1548) + flat1553 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1553 != nil { + p.write(*flat1553) return nil } else { _dollar_dollar := msg - var _t1733 *string + var _t1743 *string if _dollar_dollar.GetName() != "abort" { - _t1733 = ptr(_dollar_dollar.GetName()) + _t1743 = ptr(_dollar_dollar.GetName()) } - fields1543 := []interface{}{_t1733, _dollar_dollar.GetRelationId()} - unwrapped_fields1544 := fields1543 + fields1548 := []interface{}{_t1743, _dollar_dollar.GetRelationId()} + unwrapped_fields1549 := fields1548 p.write("(") p.write("abort") p.indentSexp() - field1545 := unwrapped_fields1544[0].(*string) - if field1545 != nil { + field1550 := unwrapped_fields1549[0].(*string) + if field1550 != nil { p.newline() - opt_val1546 := *field1545 - p.pretty_name(opt_val1546) + opt_val1551 := *field1550 + p.pretty_name(opt_val1551) } p.newline() - field1547 := unwrapped_fields1544[1].(*pb.RelationId) - p.pretty_relation_id(field1547) + field1552 := unwrapped_fields1549[1].(*pb.RelationId) + p.pretty_relation_id(field1552) p.dedent() p.write(")") } @@ -4702,40 +4706,40 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - flat1553 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1553 != nil { - p.write(*flat1553) + flat1558 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1558 != nil { + p.write(*flat1558) return nil } else { _dollar_dollar := msg - var _t1734 *pb.ExportCSVConfig + var _t1744 *pb.ExportCSVConfig if hasProtoField(_dollar_dollar, "csv_config") { - _t1734 = _dollar_dollar.GetCsvConfig() + _t1744 = _dollar_dollar.GetCsvConfig() } - deconstruct_result1551 := _t1734 - if deconstruct_result1551 != nil { - unwrapped1552 := deconstruct_result1551 + deconstruct_result1556 := _t1744 + if deconstruct_result1556 != nil { + unwrapped1557 := deconstruct_result1556 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped1552) + p.pretty_export_csv_config(unwrapped1557) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1735 *pb.ExportIcebergConfig + var _t1745 *pb.ExportIcebergConfig if hasProtoField(_dollar_dollar, "iceberg_config") { - _t1735 = _dollar_dollar.GetIcebergConfig() + _t1745 = _dollar_dollar.GetIcebergConfig() } - deconstruct_result1549 := _t1735 - if deconstruct_result1549 != nil { - unwrapped1550 := deconstruct_result1549 + deconstruct_result1554 := _t1745 + if deconstruct_result1554 != nil { + unwrapped1555 := deconstruct_result1554 p.write("(") p.write("export_iceberg") p.indentSexp() p.newline() - p.pretty_export_iceberg_config(unwrapped1550) + p.pretty_export_iceberg_config(unwrapped1555) p.dedent() p.write(")") } else { @@ -4747,55 +4751,56 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - flat1564 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1564 != nil { - p.write(*flat1564) + flat1569 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1569 != nil { + p.write(*flat1569) return nil } else { _dollar_dollar := msg - var _t1736 []interface{} + var _t1746 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) == 0 { - _t1736 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} + _t1747 := p.deconstruct_export_csv_output_location(_dollar_dollar) + _t1746 = []interface{}{_t1747, _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} } - deconstruct_result1559 := _t1736 - if deconstruct_result1559 != nil { - unwrapped1560 := deconstruct_result1559 + deconstruct_result1564 := _t1746 + if deconstruct_result1564 != nil { + unwrapped1565 := deconstruct_result1564 p.write("(") p.write("export_csv_config_v2") p.indentSexp() p.newline() - field1561 := unwrapped1560[0].(string) - p.pretty_export_csv_path(field1561) + field1566 := unwrapped1565[0].([]interface{}) + p.pretty_export_csv_output_location(field1566) p.newline() - field1562 := unwrapped1560[1].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1562) + field1567 := unwrapped1565[1].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1567) p.newline() - field1563 := unwrapped1560[2].(*pb.CSVConfig) - p.pretty_csv_config(field1563) + field1568 := unwrapped1565[2].(*pb.CSVConfig) + p.pretty_csv_config(field1568) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1737 []interface{} + var _t1748 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) != 0 { - _t1738 := p.deconstruct_export_csv_config(_dollar_dollar) - _t1737 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1738} + _t1749 := p.deconstruct_export_csv_config(_dollar_dollar) + _t1748 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1749} } - deconstruct_result1554 := _t1737 - if deconstruct_result1554 != nil { - unwrapped1555 := deconstruct_result1554 + deconstruct_result1559 := _t1748 + if deconstruct_result1559 != nil { + unwrapped1560 := deconstruct_result1559 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - field1556 := unwrapped1555[0].(string) - p.pretty_export_csv_path(field1556) + field1561 := unwrapped1560[0].(string) + p.pretty_export_csv_path(field1561) p.newline() - field1557 := unwrapped1555[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns_list(field1557) + field1562 := unwrapped1560[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns_list(field1562) p.newline() - field1558 := unwrapped1555[2].([][]interface{}) - p.pretty_config_dict(field1558) + field1563 := unwrapped1560[2].([][]interface{}) + p.pretty_config_dict(field1563) p.dedent() p.write(")") } else { @@ -4806,66 +4811,93 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf return nil } -func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1566 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1566 != nil { - p.write(*flat1566) +func (p *PrettyPrinter) pretty_export_csv_output_location(msg []interface{}) interface{} { + flat1574 := p.tryFlat(msg, func() { p.pretty_export_csv_output_location(msg) }) + if flat1574 != nil { + p.write(*flat1574) return nil } else { - fields1565 := msg - p.write("(") - p.write("path") - p.indentSexp() - p.newline() - p.write(p.formatStringValue(fields1565)) - p.dedent() - p.write(")") + _dollar_dollar := msg + var _t1750 *string + if _dollar_dollar[0].(string) != "" { + _t1750 = ptr(_dollar_dollar[0].(string)) + } + deconstruct_result1572 := _t1750 + if deconstruct_result1572 != nil { + unwrapped1573 := *deconstruct_result1572 + p.write("(") + p.write("path") + p.indentSexp() + p.newline() + p.write(p.formatStringValue(unwrapped1573)) + p.dedent() + p.write(")") + } else { + _dollar_dollar := msg + var _t1751 *string + if _dollar_dollar[1].(string) != "" { + _t1751 = ptr(_dollar_dollar[1].(string)) + } + deconstruct_result1570 := _t1751 + if deconstruct_result1570 != nil { + unwrapped1571 := *deconstruct_result1570 + p.write("(") + p.write("transaction_output_name") + p.indentSexp() + p.newline() + p.pretty_name(unwrapped1571) + p.dedent() + p.write(")") + } else { + panic(ParseError{msg: "No matching rule for export_csv_output_location"}) + } + } } return nil } func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interface{} { - flat1573 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) - if flat1573 != nil { - p.write(*flat1573) + flat1581 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) + if flat1581 != nil { + p.write(*flat1581) return nil } else { _dollar_dollar := msg - var _t1739 []*pb.ExportCSVColumn + var _t1752 []*pb.ExportCSVColumn if hasProtoField(_dollar_dollar, "gnf_columns") { - _t1739 = _dollar_dollar.GetGnfColumns().GetColumns() + _t1752 = _dollar_dollar.GetGnfColumns().GetColumns() } - deconstruct_result1569 := _t1739 - if deconstruct_result1569 != nil { - unwrapped1570 := deconstruct_result1569 + deconstruct_result1577 := _t1752 + if deconstruct_result1577 != nil { + unwrapped1578 := deconstruct_result1577 p.write("(") p.write("gnf_columns") p.indentSexp() - if !(len(unwrapped1570) == 0) { + if !(len(unwrapped1578) == 0) { p.newline() - for i1572, elem1571 := range unwrapped1570 { - if (i1572 > 0) { + for i1580, elem1579 := range unwrapped1578 { + if (i1580 > 0) { p.newline() } - p.pretty_export_csv_column(elem1571) + p.pretty_export_csv_column(elem1579) } } p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1740 *pb.RelationId + var _t1753 *pb.RelationId if hasProtoField(_dollar_dollar, "table_def") { - _t1740 = _dollar_dollar.GetTableDef() + _t1753 = _dollar_dollar.GetTableDef() } - deconstruct_result1567 := _t1740 - if deconstruct_result1567 != nil { - unwrapped1568 := deconstruct_result1567 + deconstruct_result1575 := _t1753 + if deconstruct_result1575 != nil { + unwrapped1576 := deconstruct_result1575 p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped1568) + p.pretty_relation_id(unwrapped1576) p.dedent() p.write(")") } else { @@ -4877,23 +4909,41 @@ func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interf } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1578 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1578 != nil { - p.write(*flat1578) + flat1586 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1586 != nil { + p.write(*flat1586) return nil } else { _dollar_dollar := msg - fields1574 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} - unwrapped_fields1575 := fields1574 + fields1582 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} + unwrapped_fields1583 := fields1582 p.write("(") p.write("column") p.indentSexp() p.newline() - field1576 := unwrapped_fields1575[0].(string) - p.write(p.formatStringValue(field1576)) + field1584 := unwrapped_fields1583[0].(string) + p.write(p.formatStringValue(field1584)) + p.newline() + field1585 := unwrapped_fields1583[1].(*pb.RelationId) + p.pretty_relation_id(field1585) + p.dedent() + p.write(")") + } + return nil +} + +func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { + flat1588 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1588 != nil { + p.write(*flat1588) + return nil + } else { + fields1587 := msg + p.write("(") + p.write("path") + p.indentSexp() p.newline() - field1577 := unwrapped_fields1575[1].(*pb.RelationId) - p.pretty_relation_id(field1577) + p.write(p.formatStringValue(fields1587)) p.dedent() p.write(")") } @@ -4901,22 +4951,22 @@ func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interf } func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn) interface{} { - flat1582 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) - if flat1582 != nil { - p.write(*flat1582) + flat1592 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) + if flat1592 != nil { + p.write(*flat1592) return nil } else { - fields1579 := msg + fields1589 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1579) == 0) { + if !(len(fields1589) == 0) { p.newline() - for i1581, elem1580 := range fields1579 { - if (i1581 > 0) { + for i1591, elem1590 := range fields1589 { + if (i1591 > 0) { p.newline() } - p.pretty_export_csv_column(elem1580) + p.pretty_export_csv_column(elem1590) } } p.dedent() @@ -4926,35 +4976,35 @@ func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn } func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig) interface{} { - flat1591 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) - if flat1591 != nil { - p.write(*flat1591) + flat1601 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) + if flat1601 != nil { + p.write(*flat1601) return nil } else { _dollar_dollar := msg - _t1741 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1583 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1741} - unwrapped_fields1584 := fields1583 + _t1754 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1593 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1754} + unwrapped_fields1594 := fields1593 p.write("(") p.write("export_iceberg_config") p.indentSexp() p.newline() - field1585 := unwrapped_fields1584[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1585) + field1595 := unwrapped_fields1594[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1595) p.newline() - field1586 := unwrapped_fields1584[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1586) + field1596 := unwrapped_fields1594[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1596) p.newline() - field1587 := unwrapped_fields1584[2].(*pb.RelationId) - p.pretty_export_iceberg_table_def(field1587) + field1597 := unwrapped_fields1594[2].(*pb.RelationId) + p.pretty_export_iceberg_table_def(field1597) p.newline() - field1588 := unwrapped_fields1584[3].([][]interface{}) - p.pretty_iceberg_table_properties(field1588) - field1589 := unwrapped_fields1584[4].([][]interface{}) - if field1589 != nil { + field1598 := unwrapped_fields1594[3].([][]interface{}) + p.pretty_iceberg_table_properties(field1598) + field1599 := unwrapped_fields1594[4].([][]interface{}) + if field1599 != nil { p.newline() - opt_val1590 := field1589 - p.pretty_config_dict(opt_val1590) + opt_val1600 := field1599 + p.pretty_config_dict(opt_val1600) } p.dedent() p.write(")") @@ -4963,17 +5013,17 @@ func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig } func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) interface{} { - flat1593 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) - if flat1593 != nil { - p.write(*flat1593) + flat1603 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) + if flat1603 != nil { + p.write(*flat1603) return nil } else { - fields1592 := msg + fields1602 := msg p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(fields1592) + p.pretty_relation_id(fields1602) p.dedent() p.write(")") } @@ -4981,22 +5031,22 @@ func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) inte } func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) interface{} { - flat1597 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) - if flat1597 != nil { - p.write(*flat1597) + flat1607 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) + if flat1607 != nil { + p.write(*flat1607) return nil } else { - fields1594 := msg + fields1604 := msg p.write("(") p.write("table_properties") p.indentSexp() - if !(len(fields1594) == 0) { + if !(len(fields1604) == 0) { p.newline() - for i1596, elem1595 := range fields1594 { - if (i1596 > 0) { + for i1606, elem1605 := range fields1604 { + if (i1606 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1595) + p.pretty_iceberg_property_entry(elem1605) } } p.dedent() @@ -5014,8 +5064,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1793 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1793) + _t1806 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1806) p.write(" ") p.write(p.formatStringValue(msg.GetOrigNames()[_idx])) p.write(")") diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl index 6e1bfc88..58e7521b 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/gen/relationalai/lqp/v1/transactions_pb.jl @@ -631,6 +631,7 @@ end struct ExportCSVConfig path::String + transaction_output_name::String csv_source::Union{Nothing,ExportCSVSource} csv_config::Union{Nothing,CSVConfig} data_columns::Vector{ExportCSVColumn} @@ -642,12 +643,13 @@ struct ExportCSVConfig syntax_quotechar::String syntax_escapechar::String end -ExportCSVConfig(;path = "", csv_source = nothing, csv_config = nothing, data_columns = Vector{ExportCSVColumn}(), partition_size = zero(Int64), compression = "", syntax_header_row = false, syntax_missing_string = "", syntax_delim = "", syntax_quotechar = "", syntax_escapechar = "") = ExportCSVConfig(path, csv_source, csv_config, data_columns, partition_size, compression, syntax_header_row, syntax_missing_string, syntax_delim, syntax_quotechar, syntax_escapechar) -PB.default_values(::Type{ExportCSVConfig}) = (;path = "", csv_source = nothing, csv_config = nothing, data_columns = Vector{ExportCSVColumn}(), partition_size = zero(Int64), compression = "", syntax_header_row = false, syntax_missing_string = "", syntax_delim = "", syntax_quotechar = "", syntax_escapechar = "") -PB.field_numbers(::Type{ExportCSVConfig}) = (;path = 1, csv_source = 10, csv_config = 11, data_columns = 2, partition_size = 3, compression = 4, syntax_header_row = 5, syntax_missing_string = 6, syntax_delim = 7, syntax_quotechar = 8, syntax_escapechar = 9) +ExportCSVConfig(;path = "", transaction_output_name = "", csv_source = nothing, csv_config = nothing, data_columns = Vector{ExportCSVColumn}(), partition_size = zero(Int64), compression = "", syntax_header_row = false, syntax_missing_string = "", syntax_delim = "", syntax_quotechar = "", syntax_escapechar = "") = ExportCSVConfig(path, transaction_output_name, csv_source, csv_config, data_columns, partition_size, compression, syntax_header_row, syntax_missing_string, syntax_delim, syntax_quotechar, syntax_escapechar) +PB.default_values(::Type{ExportCSVConfig}) = (;path = "", transaction_output_name = "", csv_source = nothing, csv_config = nothing, data_columns = Vector{ExportCSVColumn}(), partition_size = zero(Int64), compression = "", syntax_header_row = false, syntax_missing_string = "", syntax_delim = "", syntax_quotechar = "", syntax_escapechar = "") +PB.field_numbers(::Type{ExportCSVConfig}) = (;path = 1, transaction_output_name = 12, csv_source = 10, csv_config = 11, data_columns = 2, partition_size = 3, compression = 4, syntax_header_row = 5, syntax_missing_string = 6, syntax_delim = 7, syntax_quotechar = 8, syntax_escapechar = 9) function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:ExportCSVConfig}, _endpos::Int=0, _group::Bool=false) path = "" + transaction_output_name = "" csv_source = Ref{Union{Nothing,ExportCSVSource}}(nothing) csv_config = Ref{Union{Nothing,CSVConfig}}(nothing) data_columns = PB.BufferedVector{ExportCSVColumn}() @@ -662,6 +664,8 @@ function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:ExportCSVConfig}, _endpo field_number, wire_type = PB.decode_tag(d) if field_number == 1 path = PB.decode(d, String) + elseif field_number == 12 + transaction_output_name = PB.decode(d, String) elseif field_number == 10 PB.decode!(d, csv_source) elseif field_number == 11 @@ -686,12 +690,13 @@ function PB.decode(d::PB.AbstractProtoDecoder, ::Type{<:ExportCSVConfig}, _endpo Base.skip(d, wire_type) end end - return ExportCSVConfig(path, csv_source[], csv_config[], data_columns[], partition_size, compression, syntax_header_row, syntax_missing_string, syntax_delim, syntax_quotechar, syntax_escapechar) + return ExportCSVConfig(path, transaction_output_name, csv_source[], csv_config[], data_columns[], partition_size, compression, syntax_header_row, syntax_missing_string, syntax_delim, syntax_quotechar, syntax_escapechar) end function PB.encode(e::PB.AbstractProtoEncoder, x::ExportCSVConfig) initpos = position(e.io) !isempty(x.path) && PB.encode(e, 1, x.path) + !isempty(x.transaction_output_name) && PB.encode(e, 12, x.transaction_output_name) !isnothing(x.csv_source) && PB.encode(e, 10, x.csv_source) !isnothing(x.csv_config) && PB.encode(e, 11, x.csv_config) !isempty(x.data_columns) && PB.encode(e, 2, x.data_columns) @@ -707,6 +712,7 @@ end function PB._encoded_size(x::ExportCSVConfig) encoded_size = 0 !isempty(x.path) && (encoded_size += PB._encoded_size(x.path, 1)) + !isempty(x.transaction_output_name) && (encoded_size += PB._encoded_size(x.transaction_output_name, 12)) !isnothing(x.csv_source) && (encoded_size += PB._encoded_size(x.csv_source, 10)) !isnothing(x.csv_config) && (encoded_size += PB._encoded_size(x.csv_config, 11)) !isempty(x.data_columns) && (encoded_size += PB._encoded_size(x.data_columns, 2)) diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl index 3a05e7c1..7c271196 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/parser.jl @@ -372,7 +372,7 @@ function _extract_value_int32(parser::ParserState, value::Union{Nothing, Proto.V if (!isnothing(value) && _has_proto_field(value, Symbol("int32_value"))) return _get_oneof_field(value, :int32_value) else - _t2088 = nothing + _t2100 = nothing end return Int32(default) end @@ -381,7 +381,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 - _t2089 = nothing + _t2101 = nothing end return default end @@ -390,7 +390,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 - _t2090 = nothing + _t2102 = nothing end return default end @@ -399,7 +399,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 - _t2091 = nothing + _t2103 = nothing end return default end @@ -408,7 +408,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 - _t2092 = nothing + _t2104 = nothing end return default end @@ -417,7 +417,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 - _t2093 = nothing + _t2105 = nothing end return nothing end @@ -426,7 +426,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 - _t2094 = nothing + _t2106 = nothing end return nothing end @@ -435,7 +435,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 - _t2095 = nothing + _t2107 = nothing end return nothing end @@ -444,90 +444,90 @@ 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 - _t2096 = nothing + _t2108 = nothing end return nothing 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) - _t2097 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t2097 - _t2098 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t2098 - _t2099 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t2099 - _t2100 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t2100 - _t2101 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t2101 - _t2102 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t2102 - _t2103 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t2103 - _t2104 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t2104 - _t2105 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t2105 - _t2106 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t2106 - _t2107 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") - compression = _t2107 - _t2108 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) - partition_size_mb = _t2108 - _t2109 = construct_csv_storage_integration(parser, storage_integration_opt) - storage_integration = _t2109 - _t2110 = 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 _t2110 + _t2109 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t2109 + _t2110 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t2110 + _t2111 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t2111 + _t2112 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t2112 + _t2113 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t2113 + _t2114 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t2114 + _t2115 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t2115 + _t2116 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t2116 + _t2117 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t2117 + _t2118 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t2118 + _t2119 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") + compression = _t2119 + _t2120 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) + partition_size_mb = _t2120 + _t2121 = construct_csv_storage_integration(parser, storage_integration_opt) + storage_integration = _t2121 + _t2122 = 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 _t2122 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 - _t2111 = nothing + _t2123 = nothing end config = Dict(storage_integration_opt) - _t2112 = _extract_value_string(parser, get(config, "provider", nothing), "") - _t2113 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") - _t2114 = _extract_value_string(parser, get(config, "s3_region", nothing), "") - _t2115 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") - _t2116 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") - _t2117 = Proto.StorageIntegration(provider=_t2112, azure_sas_token=_t2113, s3_region=_t2114, s3_access_key_id=_t2115, s3_secret_access_key=_t2116) - return _t2117 + _t2124 = _extract_value_string(parser, get(config, "provider", nothing), "") + _t2125 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") + _t2126 = _extract_value_string(parser, get(config, "s3_region", nothing), "") + _t2127 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") + _t2128 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") + _t2129 = Proto.StorageIntegration(provider=_t2124, azure_sas_token=_t2125, s3_region=_t2126, s3_access_key_id=_t2127, s3_secret_access_key=_t2128) + return _t2129 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) - _t2118 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t2118 - _t2119 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t2119 - _t2120 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t2120 - _t2121 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t2121 - _t2122 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2122 - _t2123 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t2123 - _t2124 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t2124 - _t2125 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t2125 - _t2126 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t2126 - _t2127 = 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 = _t2127 - _t2128 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2128 + _t2130 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t2130 + _t2131 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t2131 + _t2132 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t2132 + _t2133 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t2133 + _t2134 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2134 + _t2135 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t2135 + _t2136 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t2136 + _t2137 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t2137 + _t2138 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t2138 + _t2139 = 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 = _t2139 + _t2140 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2140 end function default_configure(parser::ParserState)::Proto.Configure - _t2129 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2129 - _t2130 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2130 + _t2141 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2141 + _t2142 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2142 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -549,3856 +549,3895 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t2131 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t2131 - _t2132 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t2132 - _t2133 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2133 + _t2143 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t2143 + _t2144 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t2144 + _t2145 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2145 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) - _t2134 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t2134 - _t2135 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t2135 - _t2136 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t2136 - _t2137 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t2137 - _t2138 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t2138 - _t2139 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t2139 - _t2140 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t2140 - _t2141 = 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 _t2141 -end - -function construct_export_csv_config_with_source(parser::ParserState, path::String, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig - _t2142 = Proto.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2142 + _t2146 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t2146 + _t2147 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t2147 + _t2148 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t2148 + _t2149 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t2149 + _t2150 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t2150 + _t2151 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t2151 + _t2152 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t2152 + _t2153 = 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 _t2153 +end + +function construct_export_csv_config_with_location(parser::ParserState, location::Tuple{String, String}, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig + _t2154 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) + return _t2154 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) - _t2143 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) - return _t2143 + _t2155 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) + return _t2155 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 - _t2144 = 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 _t2144 + _t2156 = 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 _t2156 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}[])) - _t2145 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") - prefix = _t2145 - _t2146 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) - target_file_size_bytes = _t2146 - _t2147 = _extract_value_string(parser, get(cfg, "compression", nothing), "") - compression = _t2147 + _t2157 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") + prefix = _t2157 + _t2158 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) + target_file_size_bytes = _t2158 + _t2159 = _extract_value_string(parser, get(cfg, "compression", nothing), "") + compression = _t2159 table_props = Dict(table_property_pairs) - _t2148 = 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 _t2148 + _t2160 = 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 _t2160 end # --- Parse functions --- function parse_transaction(parser::ParserState)::Proto.Transaction - span_start673 = span_start(parser) + span_start676 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t1335 = parse_configure(parser) - _t1334 = _t1335 + _t1341 = parse_configure(parser) + _t1340 = _t1341 else - _t1334 = nothing + _t1340 = nothing end - configure667 = _t1334 + configure670 = _t1340 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t1337 = parse_sync(parser) - _t1336 = _t1337 + _t1343 = parse_sync(parser) + _t1342 = _t1343 else - _t1336 = nothing - end - sync668 = _t1336 - xs669 = Proto.Epoch[] - cond670 = match_lookahead_literal(parser, "(", 0) - while cond670 - _t1338 = parse_epoch(parser) - item671 = _t1338 - push!(xs669, item671) - cond670 = match_lookahead_literal(parser, "(", 0) - end - epochs672 = xs669 + _t1342 = nothing + end + sync671 = _t1342 + xs672 = Proto.Epoch[] + cond673 = match_lookahead_literal(parser, "(", 0) + while cond673 + _t1344 = parse_epoch(parser) + item674 = _t1344 + push!(xs672, item674) + cond673 = match_lookahead_literal(parser, "(", 0) + end + epochs675 = xs672 consume_literal!(parser, ")") - _t1339 = default_configure(parser) - _t1340 = Proto.Transaction(epochs=epochs672, configure=(!isnothing(configure667) ? configure667 : _t1339), sync=sync668) - result674 = _t1340 - record_span!(parser, span_start673, "Transaction") - return result674 + _t1345 = default_configure(parser) + _t1346 = Proto.Transaction(epochs=epochs675, configure=(!isnothing(configure670) ? configure670 : _t1345), sync=sync671) + result677 = _t1346 + record_span!(parser, span_start676, "Transaction") + return result677 end function parse_configure(parser::ParserState)::Proto.Configure - span_start676 = span_start(parser) + span_start679 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t1341 = parse_config_dict(parser) - config_dict675 = _t1341 + _t1347 = parse_config_dict(parser) + config_dict678 = _t1347 consume_literal!(parser, ")") - _t1342 = construct_configure(parser, config_dict675) - result677 = _t1342 - record_span!(parser, span_start676, "Configure") - return result677 + _t1348 = construct_configure(parser, config_dict678) + result680 = _t1348 + record_span!(parser, span_start679, "Configure") + return result680 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs678 = Tuple{String, Proto.Value}[] - cond679 = match_lookahead_literal(parser, ":", 0) - while cond679 - _t1343 = parse_config_key_value(parser) - item680 = _t1343 - push!(xs678, item680) - cond679 = match_lookahead_literal(parser, ":", 0) - end - config_key_values681 = xs678 + xs681 = Tuple{String, Proto.Value}[] + cond682 = match_lookahead_literal(parser, ":", 0) + while cond682 + _t1349 = parse_config_key_value(parser) + item683 = _t1349 + push!(xs681, item683) + cond682 = match_lookahead_literal(parser, ":", 0) + end + config_key_values684 = xs681 consume_literal!(parser, "}") - return config_key_values681 + return config_key_values684 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol682 = consume_terminal!(parser, "SYMBOL") - _t1344 = parse_raw_value(parser) - raw_value683 = _t1344 - return (symbol682, raw_value683,) + symbol685 = consume_terminal!(parser, "SYMBOL") + _t1350 = parse_raw_value(parser) + raw_value686 = _t1350 + return (symbol685, raw_value686,) end function parse_raw_value(parser::ParserState)::Proto.Value - span_start697 = span_start(parser) + span_start700 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1345 = 12 + _t1351 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1346 = 11 + _t1352 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1347 = 12 + _t1353 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1349 = 1 + _t1355 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1350 = 0 + _t1356 = 0 else - _t1350 = -1 + _t1356 = -1 end - _t1349 = _t1350 + _t1355 = _t1356 end - _t1348 = _t1349 + _t1354 = _t1355 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1351 = 7 + _t1357 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1352 = 8 + _t1358 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1353 = 2 + _t1359 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1354 = 3 + _t1360 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1355 = 9 + _t1361 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1356 = 4 + _t1362 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1357 = 5 + _t1363 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1358 = 6 + _t1364 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1359 = 10 + _t1365 = 10 else - _t1359 = -1 + _t1365 = -1 end - _t1358 = _t1359 + _t1364 = _t1365 end - _t1357 = _t1358 + _t1363 = _t1364 end - _t1356 = _t1357 + _t1362 = _t1363 end - _t1355 = _t1356 + _t1361 = _t1362 end - _t1354 = _t1355 + _t1360 = _t1361 end - _t1353 = _t1354 + _t1359 = _t1360 end - _t1352 = _t1353 + _t1358 = _t1359 end - _t1351 = _t1352 + _t1357 = _t1358 end - _t1348 = _t1351 + _t1354 = _t1357 end - _t1347 = _t1348 + _t1353 = _t1354 end - _t1346 = _t1347 + _t1352 = _t1353 end - _t1345 = _t1346 - end - prediction684 = _t1345 - if prediction684 == 12 - _t1361 = parse_boolean_value(parser) - boolean_value696 = _t1361 - _t1362 = Proto.Value(value=OneOf(:boolean_value, boolean_value696)) - _t1360 = _t1362 + _t1351 = _t1352 + end + prediction687 = _t1351 + if prediction687 == 12 + _t1367 = parse_boolean_value(parser) + boolean_value699 = _t1367 + _t1368 = Proto.Value(value=OneOf(:boolean_value, boolean_value699)) + _t1366 = _t1368 else - if prediction684 == 11 + if prediction687 == 11 consume_literal!(parser, "missing") - _t1364 = Proto.MissingValue() - _t1365 = Proto.Value(value=OneOf(:missing_value, _t1364)) - _t1363 = _t1365 + _t1370 = Proto.MissingValue() + _t1371 = Proto.Value(value=OneOf(:missing_value, _t1370)) + _t1369 = _t1371 else - if prediction684 == 10 - decimal695 = consume_terminal!(parser, "DECIMAL") - _t1367 = Proto.Value(value=OneOf(:decimal_value, decimal695)) - _t1366 = _t1367 + if prediction687 == 10 + decimal698 = consume_terminal!(parser, "DECIMAL") + _t1373 = Proto.Value(value=OneOf(:decimal_value, decimal698)) + _t1372 = _t1373 else - if prediction684 == 9 - int128694 = consume_terminal!(parser, "INT128") - _t1369 = Proto.Value(value=OneOf(:int128_value, int128694)) - _t1368 = _t1369 + if prediction687 == 9 + int128697 = consume_terminal!(parser, "INT128") + _t1375 = Proto.Value(value=OneOf(:int128_value, int128697)) + _t1374 = _t1375 else - if prediction684 == 8 - uint128693 = consume_terminal!(parser, "UINT128") - _t1371 = Proto.Value(value=OneOf(:uint128_value, uint128693)) - _t1370 = _t1371 + if prediction687 == 8 + uint128696 = consume_terminal!(parser, "UINT128") + _t1377 = Proto.Value(value=OneOf(:uint128_value, uint128696)) + _t1376 = _t1377 else - if prediction684 == 7 - uint32692 = consume_terminal!(parser, "UINT32") - _t1373 = Proto.Value(value=OneOf(:uint32_value, uint32692)) - _t1372 = _t1373 + if prediction687 == 7 + uint32695 = consume_terminal!(parser, "UINT32") + _t1379 = Proto.Value(value=OneOf(:uint32_value, uint32695)) + _t1378 = _t1379 else - if prediction684 == 6 - float691 = consume_terminal!(parser, "FLOAT") - _t1375 = Proto.Value(value=OneOf(:float_value, float691)) - _t1374 = _t1375 + if prediction687 == 6 + float694 = consume_terminal!(parser, "FLOAT") + _t1381 = Proto.Value(value=OneOf(:float_value, float694)) + _t1380 = _t1381 else - if prediction684 == 5 - float32690 = consume_terminal!(parser, "FLOAT32") - _t1377 = Proto.Value(value=OneOf(:float32_value, float32690)) - _t1376 = _t1377 + if prediction687 == 5 + float32693 = consume_terminal!(parser, "FLOAT32") + _t1383 = Proto.Value(value=OneOf(:float32_value, float32693)) + _t1382 = _t1383 else - if prediction684 == 4 - int689 = consume_terminal!(parser, "INT") - _t1379 = Proto.Value(value=OneOf(:int_value, int689)) - _t1378 = _t1379 + if prediction687 == 4 + int692 = consume_terminal!(parser, "INT") + _t1385 = Proto.Value(value=OneOf(:int_value, int692)) + _t1384 = _t1385 else - if prediction684 == 3 - int32688 = consume_terminal!(parser, "INT32") - _t1381 = Proto.Value(value=OneOf(:int32_value, int32688)) - _t1380 = _t1381 + if prediction687 == 3 + int32691 = consume_terminal!(parser, "INT32") + _t1387 = Proto.Value(value=OneOf(:int32_value, int32691)) + _t1386 = _t1387 else - if prediction684 == 2 - string687 = consume_terminal!(parser, "STRING") - _t1383 = Proto.Value(value=OneOf(:string_value, string687)) - _t1382 = _t1383 + if prediction687 == 2 + string690 = consume_terminal!(parser, "STRING") + _t1389 = Proto.Value(value=OneOf(:string_value, string690)) + _t1388 = _t1389 else - if prediction684 == 1 - _t1385 = parse_raw_datetime(parser) - raw_datetime686 = _t1385 - _t1386 = Proto.Value(value=OneOf(:datetime_value, raw_datetime686)) - _t1384 = _t1386 + if prediction687 == 1 + _t1391 = parse_raw_datetime(parser) + raw_datetime689 = _t1391 + _t1392 = Proto.Value(value=OneOf(:datetime_value, raw_datetime689)) + _t1390 = _t1392 else - if prediction684 == 0 - _t1388 = parse_raw_date(parser) - raw_date685 = _t1388 - _t1389 = Proto.Value(value=OneOf(:date_value, raw_date685)) - _t1387 = _t1389 + if prediction687 == 0 + _t1394 = parse_raw_date(parser) + raw_date688 = _t1394 + _t1395 = Proto.Value(value=OneOf(:date_value, raw_date688)) + _t1393 = _t1395 else throw(ParseError("Unexpected token in raw_value" * ": " * string(lookahead(parser, 0)))) end - _t1384 = _t1387 + _t1390 = _t1393 end - _t1382 = _t1384 + _t1388 = _t1390 end - _t1380 = _t1382 + _t1386 = _t1388 end - _t1378 = _t1380 + _t1384 = _t1386 end - _t1376 = _t1378 + _t1382 = _t1384 end - _t1374 = _t1376 + _t1380 = _t1382 end - _t1372 = _t1374 + _t1378 = _t1380 end - _t1370 = _t1372 + _t1376 = _t1378 end - _t1368 = _t1370 + _t1374 = _t1376 end - _t1366 = _t1368 + _t1372 = _t1374 end - _t1363 = _t1366 + _t1369 = _t1372 end - _t1360 = _t1363 + _t1366 = _t1369 end - result698 = _t1360 - record_span!(parser, span_start697, "Value") - return result698 + result701 = _t1366 + record_span!(parser, span_start700, "Value") + return result701 end function parse_raw_date(parser::ParserState)::Proto.DateValue - span_start702 = span_start(parser) + span_start705 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - int699 = consume_terminal!(parser, "INT") - int_3700 = consume_terminal!(parser, "INT") - int_4701 = consume_terminal!(parser, "INT") + int702 = consume_terminal!(parser, "INT") + int_3703 = consume_terminal!(parser, "INT") + int_4704 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1390 = Proto.DateValue(year=Int32(int699), month=Int32(int_3700), day=Int32(int_4701)) - result703 = _t1390 - record_span!(parser, span_start702, "DateValue") - return result703 + _t1396 = Proto.DateValue(year=Int32(int702), month=Int32(int_3703), day=Int32(int_4704)) + result706 = _t1396 + record_span!(parser, span_start705, "DateValue") + return result706 end function parse_raw_datetime(parser::ParserState)::Proto.DateTimeValue - span_start711 = span_start(parser) + span_start714 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int704 = consume_terminal!(parser, "INT") - int_3705 = consume_terminal!(parser, "INT") - int_4706 = consume_terminal!(parser, "INT") - int_5707 = consume_terminal!(parser, "INT") - int_6708 = consume_terminal!(parser, "INT") - int_7709 = consume_terminal!(parser, "INT") + int707 = consume_terminal!(parser, "INT") + int_3708 = consume_terminal!(parser, "INT") + int_4709 = consume_terminal!(parser, "INT") + int_5710 = consume_terminal!(parser, "INT") + int_6711 = consume_terminal!(parser, "INT") + int_7712 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1391 = consume_terminal!(parser, "INT") + _t1397 = consume_terminal!(parser, "INT") else - _t1391 = nothing + _t1397 = nothing end - int_8710 = _t1391 + int_8713 = _t1397 consume_literal!(parser, ")") - _t1392 = Proto.DateTimeValue(year=Int32(int704), month=Int32(int_3705), day=Int32(int_4706), hour=Int32(int_5707), minute=Int32(int_6708), second=Int32(int_7709), microsecond=Int32((!isnothing(int_8710) ? int_8710 : 0))) - result712 = _t1392 - record_span!(parser, span_start711, "DateTimeValue") - return result712 + _t1398 = Proto.DateTimeValue(year=Int32(int707), month=Int32(int_3708), day=Int32(int_4709), hour=Int32(int_5710), minute=Int32(int_6711), second=Int32(int_7712), microsecond=Int32((!isnothing(int_8713) ? int_8713 : 0))) + result715 = _t1398 + record_span!(parser, span_start714, "DateTimeValue") + return result715 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t1393 = 0 + _t1399 = 0 else if match_lookahead_literal(parser, "false", 0) - _t1394 = 1 + _t1400 = 1 else - _t1394 = -1 + _t1400 = -1 end - _t1393 = _t1394 + _t1399 = _t1400 end - prediction713 = _t1393 - if prediction713 == 1 + prediction716 = _t1399 + if prediction716 == 1 consume_literal!(parser, "false") - _t1395 = false + _t1401 = false else - if prediction713 == 0 + if prediction716 == 0 consume_literal!(parser, "true") - _t1396 = true + _t1402 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t1395 = _t1396 + _t1401 = _t1402 end - return _t1395 + return _t1401 end function parse_sync(parser::ParserState)::Proto.Sync - span_start718 = span_start(parser) + span_start721 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs714 = Proto.FragmentId[] - cond715 = match_lookahead_literal(parser, ":", 0) - while cond715 - _t1397 = parse_fragment_id(parser) - item716 = _t1397 - push!(xs714, item716) - cond715 = match_lookahead_literal(parser, ":", 0) - end - fragment_ids717 = xs714 + xs717 = Proto.FragmentId[] + cond718 = match_lookahead_literal(parser, ":", 0) + while cond718 + _t1403 = parse_fragment_id(parser) + item719 = _t1403 + push!(xs717, item719) + cond718 = match_lookahead_literal(parser, ":", 0) + end + fragment_ids720 = xs717 consume_literal!(parser, ")") - _t1398 = Proto.Sync(fragments=fragment_ids717) - result719 = _t1398 - record_span!(parser, span_start718, "Sync") - return result719 + _t1404 = Proto.Sync(fragments=fragment_ids720) + result722 = _t1404 + record_span!(parser, span_start721, "Sync") + return result722 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId - span_start721 = span_start(parser) + span_start724 = span_start(parser) consume_literal!(parser, ":") - symbol720 = consume_terminal!(parser, "SYMBOL") - result722 = Proto.FragmentId(Vector{UInt8}(symbol720)) - record_span!(parser, span_start721, "FragmentId") - return result722 + symbol723 = consume_terminal!(parser, "SYMBOL") + result725 = Proto.FragmentId(Vector{UInt8}(symbol723)) + record_span!(parser, span_start724, "FragmentId") + return result725 end function parse_epoch(parser::ParserState)::Proto.Epoch - span_start725 = span_start(parser) + span_start728 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t1400 = parse_epoch_writes(parser) - _t1399 = _t1400 + _t1406 = parse_epoch_writes(parser) + _t1405 = _t1406 else - _t1399 = nothing + _t1405 = nothing end - epoch_writes723 = _t1399 + epoch_writes726 = _t1405 if match_lookahead_literal(parser, "(", 0) - _t1402 = parse_epoch_reads(parser) - _t1401 = _t1402 + _t1408 = parse_epoch_reads(parser) + _t1407 = _t1408 else - _t1401 = nothing + _t1407 = nothing end - epoch_reads724 = _t1401 + epoch_reads727 = _t1407 consume_literal!(parser, ")") - _t1403 = Proto.Epoch(writes=(!isnothing(epoch_writes723) ? epoch_writes723 : Proto.Write[]), reads=(!isnothing(epoch_reads724) ? epoch_reads724 : Proto.Read[])) - result726 = _t1403 - record_span!(parser, span_start725, "Epoch") - return result726 + _t1409 = Proto.Epoch(writes=(!isnothing(epoch_writes726) ? epoch_writes726 : Proto.Write[]), reads=(!isnothing(epoch_reads727) ? epoch_reads727 : Proto.Read[])) + result729 = _t1409 + record_span!(parser, span_start728, "Epoch") + return result729 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs727 = Proto.Write[] - cond728 = match_lookahead_literal(parser, "(", 0) - while cond728 - _t1404 = parse_write(parser) - item729 = _t1404 - push!(xs727, item729) - cond728 = match_lookahead_literal(parser, "(", 0) - end - writes730 = xs727 + xs730 = Proto.Write[] + cond731 = match_lookahead_literal(parser, "(", 0) + while cond731 + _t1410 = parse_write(parser) + item732 = _t1410 + push!(xs730, item732) + cond731 = match_lookahead_literal(parser, "(", 0) + end + writes733 = xs730 consume_literal!(parser, ")") - return writes730 + return writes733 end function parse_write(parser::ParserState)::Proto.Write - span_start736 = span_start(parser) + span_start739 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t1406 = 1 + _t1412 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t1407 = 3 + _t1413 = 3 else if match_lookahead_literal(parser, "define", 1) - _t1408 = 0 + _t1414 = 0 else if match_lookahead_literal(parser, "context", 1) - _t1409 = 2 + _t1415 = 2 else - _t1409 = -1 + _t1415 = -1 end - _t1408 = _t1409 + _t1414 = _t1415 end - _t1407 = _t1408 + _t1413 = _t1414 end - _t1406 = _t1407 + _t1412 = _t1413 end - _t1405 = _t1406 + _t1411 = _t1412 else - _t1405 = -1 - end - prediction731 = _t1405 - if prediction731 == 3 - _t1411 = parse_snapshot(parser) - snapshot735 = _t1411 - _t1412 = Proto.Write(write_type=OneOf(:snapshot, snapshot735)) - _t1410 = _t1412 + _t1411 = -1 + end + prediction734 = _t1411 + if prediction734 == 3 + _t1417 = parse_snapshot(parser) + snapshot738 = _t1417 + _t1418 = Proto.Write(write_type=OneOf(:snapshot, snapshot738)) + _t1416 = _t1418 else - if prediction731 == 2 - _t1414 = parse_context(parser) - context734 = _t1414 - _t1415 = Proto.Write(write_type=OneOf(:context, context734)) - _t1413 = _t1415 + if prediction734 == 2 + _t1420 = parse_context(parser) + context737 = _t1420 + _t1421 = Proto.Write(write_type=OneOf(:context, context737)) + _t1419 = _t1421 else - if prediction731 == 1 - _t1417 = parse_undefine(parser) - undefine733 = _t1417 - _t1418 = Proto.Write(write_type=OneOf(:undefine, undefine733)) - _t1416 = _t1418 + if prediction734 == 1 + _t1423 = parse_undefine(parser) + undefine736 = _t1423 + _t1424 = Proto.Write(write_type=OneOf(:undefine, undefine736)) + _t1422 = _t1424 else - if prediction731 == 0 - _t1420 = parse_define(parser) - define732 = _t1420 - _t1421 = Proto.Write(write_type=OneOf(:define, define732)) - _t1419 = _t1421 + if prediction734 == 0 + _t1426 = parse_define(parser) + define735 = _t1426 + _t1427 = Proto.Write(write_type=OneOf(:define, define735)) + _t1425 = _t1427 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t1416 = _t1419 + _t1422 = _t1425 end - _t1413 = _t1416 + _t1419 = _t1422 end - _t1410 = _t1413 + _t1416 = _t1419 end - result737 = _t1410 - record_span!(parser, span_start736, "Write") - return result737 + result740 = _t1416 + record_span!(parser, span_start739, "Write") + return result740 end function parse_define(parser::ParserState)::Proto.Define - span_start739 = span_start(parser) + span_start742 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "define") - _t1422 = parse_fragment(parser) - fragment738 = _t1422 + _t1428 = parse_fragment(parser) + fragment741 = _t1428 consume_literal!(parser, ")") - _t1423 = Proto.Define(fragment=fragment738) - result740 = _t1423 - record_span!(parser, span_start739, "Define") - return result740 + _t1429 = Proto.Define(fragment=fragment741) + result743 = _t1429 + record_span!(parser, span_start742, "Define") + return result743 end function parse_fragment(parser::ParserState)::Proto.Fragment - span_start746 = span_start(parser) + span_start749 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t1424 = parse_new_fragment_id(parser) - new_fragment_id741 = _t1424 - xs742 = Proto.Declaration[] - cond743 = match_lookahead_literal(parser, "(", 0) - while cond743 - _t1425 = parse_declaration(parser) - item744 = _t1425 - push!(xs742, item744) - cond743 = match_lookahead_literal(parser, "(", 0) - end - declarations745 = xs742 + _t1430 = parse_new_fragment_id(parser) + new_fragment_id744 = _t1430 + xs745 = Proto.Declaration[] + cond746 = match_lookahead_literal(parser, "(", 0) + while cond746 + _t1431 = parse_declaration(parser) + item747 = _t1431 + push!(xs745, item747) + cond746 = match_lookahead_literal(parser, "(", 0) + end + declarations748 = xs745 consume_literal!(parser, ")") - result747 = construct_fragment(parser, new_fragment_id741, declarations745) - record_span!(parser, span_start746, "Fragment") - return result747 + result750 = construct_fragment(parser, new_fragment_id744, declarations748) + record_span!(parser, span_start749, "Fragment") + return result750 end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - span_start749 = span_start(parser) - _t1426 = parse_fragment_id(parser) - fragment_id748 = _t1426 - start_fragment!(parser, fragment_id748) - result750 = fragment_id748 - record_span!(parser, span_start749, "FragmentId") - return result750 + span_start752 = span_start(parser) + _t1432 = parse_fragment_id(parser) + fragment_id751 = _t1432 + start_fragment!(parser, fragment_id751) + result753 = fragment_id751 + record_span!(parser, span_start752, "FragmentId") + return result753 end function parse_declaration(parser::ParserState)::Proto.Declaration - span_start756 = span_start(parser) + span_start759 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1428 = 3 + _t1434 = 3 else if match_lookahead_literal(parser, "functional_dependency", 1) - _t1429 = 2 + _t1435 = 2 else if match_lookahead_literal(parser, "edb", 1) - _t1430 = 3 + _t1436 = 3 else if match_lookahead_literal(parser, "def", 1) - _t1431 = 0 + _t1437 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1432 = 3 + _t1438 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1433 = 3 + _t1439 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t1434 = 1 + _t1440 = 1 else - _t1434 = -1 + _t1440 = -1 end - _t1433 = _t1434 + _t1439 = _t1440 end - _t1432 = _t1433 + _t1438 = _t1439 end - _t1431 = _t1432 + _t1437 = _t1438 end - _t1430 = _t1431 + _t1436 = _t1437 end - _t1429 = _t1430 + _t1435 = _t1436 end - _t1428 = _t1429 + _t1434 = _t1435 end - _t1427 = _t1428 + _t1433 = _t1434 else - _t1427 = -1 - end - prediction751 = _t1427 - if prediction751 == 3 - _t1436 = parse_data(parser) - data755 = _t1436 - _t1437 = Proto.Declaration(declaration_type=OneOf(:data, data755)) - _t1435 = _t1437 + _t1433 = -1 + end + prediction754 = _t1433 + if prediction754 == 3 + _t1442 = parse_data(parser) + data758 = _t1442 + _t1443 = Proto.Declaration(declaration_type=OneOf(:data, data758)) + _t1441 = _t1443 else - if prediction751 == 2 - _t1439 = parse_constraint(parser) - constraint754 = _t1439 - _t1440 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint754)) - _t1438 = _t1440 + if prediction754 == 2 + _t1445 = parse_constraint(parser) + constraint757 = _t1445 + _t1446 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint757)) + _t1444 = _t1446 else - if prediction751 == 1 - _t1442 = parse_algorithm(parser) - algorithm753 = _t1442 - _t1443 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm753)) - _t1441 = _t1443 + if prediction754 == 1 + _t1448 = parse_algorithm(parser) + algorithm756 = _t1448 + _t1449 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm756)) + _t1447 = _t1449 else - if prediction751 == 0 - _t1445 = parse_def(parser) - def752 = _t1445 - _t1446 = Proto.Declaration(declaration_type=OneOf(:def, def752)) - _t1444 = _t1446 + if prediction754 == 0 + _t1451 = parse_def(parser) + def755 = _t1451 + _t1452 = Proto.Declaration(declaration_type=OneOf(:def, def755)) + _t1450 = _t1452 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t1441 = _t1444 + _t1447 = _t1450 end - _t1438 = _t1441 + _t1444 = _t1447 end - _t1435 = _t1438 + _t1441 = _t1444 end - result757 = _t1435 - record_span!(parser, span_start756, "Declaration") - return result757 + result760 = _t1441 + record_span!(parser, span_start759, "Declaration") + return result760 end function parse_def(parser::ParserState)::Proto.Def - span_start761 = span_start(parser) + span_start764 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "def") - _t1447 = parse_relation_id(parser) - relation_id758 = _t1447 - _t1448 = parse_abstraction(parser) - abstraction759 = _t1448 + _t1453 = parse_relation_id(parser) + relation_id761 = _t1453 + _t1454 = parse_abstraction(parser) + abstraction762 = _t1454 if match_lookahead_literal(parser, "(", 0) - _t1450 = parse_attrs(parser) - _t1449 = _t1450 + _t1456 = parse_attrs(parser) + _t1455 = _t1456 else - _t1449 = nothing + _t1455 = nothing end - attrs760 = _t1449 + attrs763 = _t1455 consume_literal!(parser, ")") - _t1451 = Proto.Def(name=relation_id758, body=abstraction759, attrs=(!isnothing(attrs760) ? attrs760 : Proto.Attribute[])) - result762 = _t1451 - record_span!(parser, span_start761, "Def") - return result762 + _t1457 = Proto.Def(name=relation_id761, body=abstraction762, attrs=(!isnothing(attrs763) ? attrs763 : Proto.Attribute[])) + result765 = _t1457 + record_span!(parser, span_start764, "Def") + return result765 end function parse_relation_id(parser::ParserState)::Proto.RelationId - span_start766 = span_start(parser) + span_start769 = span_start(parser) if match_lookahead_literal(parser, ":", 0) - _t1452 = 0 + _t1458 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1453 = 1 + _t1459 = 1 else - _t1453 = -1 + _t1459 = -1 end - _t1452 = _t1453 + _t1458 = _t1459 end - prediction763 = _t1452 - if prediction763 == 1 - uint128765 = consume_terminal!(parser, "UINT128") - _t1454 = Proto.RelationId(uint128765.low, uint128765.high) + prediction766 = _t1458 + if prediction766 == 1 + uint128768 = consume_terminal!(parser, "UINT128") + _t1460 = Proto.RelationId(uint128768.low, uint128768.high) else - if prediction763 == 0 + if prediction766 == 0 consume_literal!(parser, ":") - symbol764 = consume_terminal!(parser, "SYMBOL") - _t1455 = relation_id_from_string(parser, symbol764) + symbol767 = consume_terminal!(parser, "SYMBOL") + _t1461 = relation_id_from_string(parser, symbol767) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t1454 = _t1455 + _t1460 = _t1461 end - result767 = _t1454 - record_span!(parser, span_start766, "RelationId") - return result767 + result770 = _t1460 + record_span!(parser, span_start769, "RelationId") + return result770 end function parse_abstraction(parser::ParserState)::Proto.Abstraction - span_start770 = span_start(parser) + span_start773 = span_start(parser) consume_literal!(parser, "(") - _t1456 = parse_bindings(parser) - bindings768 = _t1456 - _t1457 = parse_formula(parser) - formula769 = _t1457 + _t1462 = parse_bindings(parser) + bindings771 = _t1462 + _t1463 = parse_formula(parser) + formula772 = _t1463 consume_literal!(parser, ")") - _t1458 = Proto.Abstraction(vars=vcat(bindings768[1], !isnothing(bindings768[2]) ? bindings768[2] : []), value=formula769) - result771 = _t1458 - record_span!(parser, span_start770, "Abstraction") - return result771 + _t1464 = Proto.Abstraction(vars=vcat(bindings771[1], !isnothing(bindings771[2]) ? bindings771[2] : []), value=formula772) + result774 = _t1464 + record_span!(parser, span_start773, "Abstraction") + return result774 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs772 = Proto.Binding[] - cond773 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond773 - _t1459 = parse_binding(parser) - item774 = _t1459 - push!(xs772, item774) - cond773 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - bindings775 = xs772 + xs775 = Proto.Binding[] + cond776 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond776 + _t1465 = parse_binding(parser) + item777 = _t1465 + push!(xs775, item777) + cond776 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + bindings778 = xs775 if match_lookahead_literal(parser, "|", 0) - _t1461 = parse_value_bindings(parser) - _t1460 = _t1461 + _t1467 = parse_value_bindings(parser) + _t1466 = _t1467 else - _t1460 = nothing + _t1466 = nothing end - value_bindings776 = _t1460 + value_bindings779 = _t1466 consume_literal!(parser, "]") - return (bindings775, (!isnothing(value_bindings776) ? value_bindings776 : Proto.Binding[]),) + return (bindings778, (!isnothing(value_bindings779) ? value_bindings779 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - span_start779 = span_start(parser) - symbol777 = consume_terminal!(parser, "SYMBOL") + span_start782 = span_start(parser) + symbol780 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t1462 = parse_type(parser) - type778 = _t1462 - _t1463 = Proto.Var(name=symbol777) - _t1464 = Proto.Binding(var=_t1463, var"#type"=type778) - result780 = _t1464 - record_span!(parser, span_start779, "Binding") - return result780 + _t1468 = parse_type(parser) + type781 = _t1468 + _t1469 = Proto.Var(name=symbol780) + _t1470 = Proto.Binding(var=_t1469, var"#type"=type781) + result783 = _t1470 + record_span!(parser, span_start782, "Binding") + return result783 end function parse_type(parser::ParserState)::Proto.var"#Type" - span_start796 = span_start(parser) + span_start799 = span_start(parser) if match_lookahead_literal(parser, "UNKNOWN", 0) - _t1465 = 0 + _t1471 = 0 else if match_lookahead_literal(parser, "UINT32", 0) - _t1466 = 13 + _t1472 = 13 else if match_lookahead_literal(parser, "UINT128", 0) - _t1467 = 4 + _t1473 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t1468 = 1 + _t1474 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t1469 = 8 + _t1475 = 8 else if match_lookahead_literal(parser, "INT32", 0) - _t1470 = 11 + _t1476 = 11 else if match_lookahead_literal(parser, "INT128", 0) - _t1471 = 5 + _t1477 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t1472 = 2 + _t1478 = 2 else if match_lookahead_literal(parser, "FLOAT32", 0) - _t1473 = 12 + _t1479 = 12 else if match_lookahead_literal(parser, "FLOAT", 0) - _t1474 = 3 + _t1480 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t1475 = 7 + _t1481 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t1476 = 6 + _t1482 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t1477 = 10 + _t1483 = 10 else if match_lookahead_literal(parser, "(", 0) - _t1478 = 9 + _t1484 = 9 else - _t1478 = -1 + _t1484 = -1 end - _t1477 = _t1478 + _t1483 = _t1484 end - _t1476 = _t1477 + _t1482 = _t1483 end - _t1475 = _t1476 + _t1481 = _t1482 end - _t1474 = _t1475 + _t1480 = _t1481 end - _t1473 = _t1474 + _t1479 = _t1480 end - _t1472 = _t1473 + _t1478 = _t1479 end - _t1471 = _t1472 + _t1477 = _t1478 end - _t1470 = _t1471 + _t1476 = _t1477 end - _t1469 = _t1470 + _t1475 = _t1476 end - _t1468 = _t1469 + _t1474 = _t1475 end - _t1467 = _t1468 + _t1473 = _t1474 end - _t1466 = _t1467 + _t1472 = _t1473 end - _t1465 = _t1466 - end - prediction781 = _t1465 - if prediction781 == 13 - _t1480 = parse_uint32_type(parser) - uint32_type795 = _t1480 - _t1481 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type795)) - _t1479 = _t1481 + _t1471 = _t1472 + end + prediction784 = _t1471 + if prediction784 == 13 + _t1486 = parse_uint32_type(parser) + uint32_type798 = _t1486 + _t1487 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type798)) + _t1485 = _t1487 else - if prediction781 == 12 - _t1483 = parse_float32_type(parser) - float32_type794 = _t1483 - _t1484 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type794)) - _t1482 = _t1484 + if prediction784 == 12 + _t1489 = parse_float32_type(parser) + float32_type797 = _t1489 + _t1490 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type797)) + _t1488 = _t1490 else - if prediction781 == 11 - _t1486 = parse_int32_type(parser) - int32_type793 = _t1486 - _t1487 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type793)) - _t1485 = _t1487 + if prediction784 == 11 + _t1492 = parse_int32_type(parser) + int32_type796 = _t1492 + _t1493 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type796)) + _t1491 = _t1493 else - if prediction781 == 10 - _t1489 = parse_boolean_type(parser) - boolean_type792 = _t1489 - _t1490 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type792)) - _t1488 = _t1490 + if prediction784 == 10 + _t1495 = parse_boolean_type(parser) + boolean_type795 = _t1495 + _t1496 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type795)) + _t1494 = _t1496 else - if prediction781 == 9 - _t1492 = parse_decimal_type(parser) - decimal_type791 = _t1492 - _t1493 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type791)) - _t1491 = _t1493 + if prediction784 == 9 + _t1498 = parse_decimal_type(parser) + decimal_type794 = _t1498 + _t1499 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type794)) + _t1497 = _t1499 else - if prediction781 == 8 - _t1495 = parse_missing_type(parser) - missing_type790 = _t1495 - _t1496 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type790)) - _t1494 = _t1496 + if prediction784 == 8 + _t1501 = parse_missing_type(parser) + missing_type793 = _t1501 + _t1502 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type793)) + _t1500 = _t1502 else - if prediction781 == 7 - _t1498 = parse_datetime_type(parser) - datetime_type789 = _t1498 - _t1499 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type789)) - _t1497 = _t1499 + if prediction784 == 7 + _t1504 = parse_datetime_type(parser) + datetime_type792 = _t1504 + _t1505 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type792)) + _t1503 = _t1505 else - if prediction781 == 6 - _t1501 = parse_date_type(parser) - date_type788 = _t1501 - _t1502 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type788)) - _t1500 = _t1502 + if prediction784 == 6 + _t1507 = parse_date_type(parser) + date_type791 = _t1507 + _t1508 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type791)) + _t1506 = _t1508 else - if prediction781 == 5 - _t1504 = parse_int128_type(parser) - int128_type787 = _t1504 - _t1505 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type787)) - _t1503 = _t1505 + if prediction784 == 5 + _t1510 = parse_int128_type(parser) + int128_type790 = _t1510 + _t1511 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type790)) + _t1509 = _t1511 else - if prediction781 == 4 - _t1507 = parse_uint128_type(parser) - uint128_type786 = _t1507 - _t1508 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type786)) - _t1506 = _t1508 + if prediction784 == 4 + _t1513 = parse_uint128_type(parser) + uint128_type789 = _t1513 + _t1514 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type789)) + _t1512 = _t1514 else - if prediction781 == 3 - _t1510 = parse_float_type(parser) - float_type785 = _t1510 - _t1511 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type785)) - _t1509 = _t1511 + if prediction784 == 3 + _t1516 = parse_float_type(parser) + float_type788 = _t1516 + _t1517 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type788)) + _t1515 = _t1517 else - if prediction781 == 2 - _t1513 = parse_int_type(parser) - int_type784 = _t1513 - _t1514 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type784)) - _t1512 = _t1514 + if prediction784 == 2 + _t1519 = parse_int_type(parser) + int_type787 = _t1519 + _t1520 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type787)) + _t1518 = _t1520 else - if prediction781 == 1 - _t1516 = parse_string_type(parser) - string_type783 = _t1516 - _t1517 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type783)) - _t1515 = _t1517 + if prediction784 == 1 + _t1522 = parse_string_type(parser) + string_type786 = _t1522 + _t1523 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type786)) + _t1521 = _t1523 else - if prediction781 == 0 - _t1519 = parse_unspecified_type(parser) - unspecified_type782 = _t1519 - _t1520 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type782)) - _t1518 = _t1520 + if prediction784 == 0 + _t1525 = parse_unspecified_type(parser) + unspecified_type785 = _t1525 + _t1526 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type785)) + _t1524 = _t1526 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) end - _t1515 = _t1518 + _t1521 = _t1524 end - _t1512 = _t1515 + _t1518 = _t1521 end - _t1509 = _t1512 + _t1515 = _t1518 end - _t1506 = _t1509 + _t1512 = _t1515 end - _t1503 = _t1506 + _t1509 = _t1512 end - _t1500 = _t1503 + _t1506 = _t1509 end - _t1497 = _t1500 + _t1503 = _t1506 end - _t1494 = _t1497 + _t1500 = _t1503 end - _t1491 = _t1494 + _t1497 = _t1500 end - _t1488 = _t1491 + _t1494 = _t1497 end - _t1485 = _t1488 + _t1491 = _t1494 end - _t1482 = _t1485 + _t1488 = _t1491 end - _t1479 = _t1482 + _t1485 = _t1488 end - result797 = _t1479 - record_span!(parser, span_start796, "Type") - return result797 + result800 = _t1485 + record_span!(parser, span_start799, "Type") + return result800 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType - span_start798 = span_start(parser) + span_start801 = span_start(parser) consume_literal!(parser, "UNKNOWN") - _t1521 = Proto.UnspecifiedType() - result799 = _t1521 - record_span!(parser, span_start798, "UnspecifiedType") - return result799 + _t1527 = Proto.UnspecifiedType() + result802 = _t1527 + record_span!(parser, span_start801, "UnspecifiedType") + return result802 end function parse_string_type(parser::ParserState)::Proto.StringType - span_start800 = span_start(parser) + span_start803 = span_start(parser) consume_literal!(parser, "STRING") - _t1522 = Proto.StringType() - result801 = _t1522 - record_span!(parser, span_start800, "StringType") - return result801 + _t1528 = Proto.StringType() + result804 = _t1528 + record_span!(parser, span_start803, "StringType") + return result804 end function parse_int_type(parser::ParserState)::Proto.IntType - span_start802 = span_start(parser) + span_start805 = span_start(parser) consume_literal!(parser, "INT") - _t1523 = Proto.IntType() - result803 = _t1523 - record_span!(parser, span_start802, "IntType") - return result803 + _t1529 = Proto.IntType() + result806 = _t1529 + record_span!(parser, span_start805, "IntType") + return result806 end function parse_float_type(parser::ParserState)::Proto.FloatType - span_start804 = span_start(parser) + span_start807 = span_start(parser) consume_literal!(parser, "FLOAT") - _t1524 = Proto.FloatType() - result805 = _t1524 - record_span!(parser, span_start804, "FloatType") - return result805 + _t1530 = Proto.FloatType() + result808 = _t1530 + record_span!(parser, span_start807, "FloatType") + return result808 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type - span_start806 = span_start(parser) + span_start809 = span_start(parser) consume_literal!(parser, "UINT128") - _t1525 = Proto.UInt128Type() - result807 = _t1525 - record_span!(parser, span_start806, "UInt128Type") - return result807 + _t1531 = Proto.UInt128Type() + result810 = _t1531 + record_span!(parser, span_start809, "UInt128Type") + return result810 end function parse_int128_type(parser::ParserState)::Proto.Int128Type - span_start808 = span_start(parser) + span_start811 = span_start(parser) consume_literal!(parser, "INT128") - _t1526 = Proto.Int128Type() - result809 = _t1526 - record_span!(parser, span_start808, "Int128Type") - return result809 + _t1532 = Proto.Int128Type() + result812 = _t1532 + record_span!(parser, span_start811, "Int128Type") + return result812 end function parse_date_type(parser::ParserState)::Proto.DateType - span_start810 = span_start(parser) + span_start813 = span_start(parser) consume_literal!(parser, "DATE") - _t1527 = Proto.DateType() - result811 = _t1527 - record_span!(parser, span_start810, "DateType") - return result811 + _t1533 = Proto.DateType() + result814 = _t1533 + record_span!(parser, span_start813, "DateType") + return result814 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType - span_start812 = span_start(parser) + span_start815 = span_start(parser) consume_literal!(parser, "DATETIME") - _t1528 = Proto.DateTimeType() - result813 = _t1528 - record_span!(parser, span_start812, "DateTimeType") - return result813 + _t1534 = Proto.DateTimeType() + result816 = _t1534 + record_span!(parser, span_start815, "DateTimeType") + return result816 end function parse_missing_type(parser::ParserState)::Proto.MissingType - span_start814 = span_start(parser) + span_start817 = span_start(parser) consume_literal!(parser, "MISSING") - _t1529 = Proto.MissingType() - result815 = _t1529 - record_span!(parser, span_start814, "MissingType") - return result815 + _t1535 = Proto.MissingType() + result818 = _t1535 + record_span!(parser, span_start817, "MissingType") + return result818 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType - span_start818 = span_start(parser) + span_start821 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int816 = consume_terminal!(parser, "INT") - int_3817 = consume_terminal!(parser, "INT") + int819 = consume_terminal!(parser, "INT") + int_3820 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1530 = Proto.DecimalType(precision=Int32(int816), scale=Int32(int_3817)) - result819 = _t1530 - record_span!(parser, span_start818, "DecimalType") - return result819 + _t1536 = Proto.DecimalType(precision=Int32(int819), scale=Int32(int_3820)) + result822 = _t1536 + record_span!(parser, span_start821, "DecimalType") + return result822 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType - span_start820 = span_start(parser) + span_start823 = span_start(parser) consume_literal!(parser, "BOOLEAN") - _t1531 = Proto.BooleanType() - result821 = _t1531 - record_span!(parser, span_start820, "BooleanType") - return result821 + _t1537 = Proto.BooleanType() + result824 = _t1537 + record_span!(parser, span_start823, "BooleanType") + return result824 end function parse_int32_type(parser::ParserState)::Proto.Int32Type - span_start822 = span_start(parser) + span_start825 = span_start(parser) consume_literal!(parser, "INT32") - _t1532 = Proto.Int32Type() - result823 = _t1532 - record_span!(parser, span_start822, "Int32Type") - return result823 + _t1538 = Proto.Int32Type() + result826 = _t1538 + record_span!(parser, span_start825, "Int32Type") + return result826 end function parse_float32_type(parser::ParserState)::Proto.Float32Type - span_start824 = span_start(parser) + span_start827 = span_start(parser) consume_literal!(parser, "FLOAT32") - _t1533 = Proto.Float32Type() - result825 = _t1533 - record_span!(parser, span_start824, "Float32Type") - return result825 + _t1539 = Proto.Float32Type() + result828 = _t1539 + record_span!(parser, span_start827, "Float32Type") + return result828 end function parse_uint32_type(parser::ParserState)::Proto.UInt32Type - span_start826 = span_start(parser) + span_start829 = span_start(parser) consume_literal!(parser, "UINT32") - _t1534 = Proto.UInt32Type() - result827 = _t1534 - record_span!(parser, span_start826, "UInt32Type") - return result827 + _t1540 = Proto.UInt32Type() + result830 = _t1540 + record_span!(parser, span_start829, "UInt32Type") + return result830 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs828 = Proto.Binding[] - cond829 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond829 - _t1535 = parse_binding(parser) - item830 = _t1535 - push!(xs828, item830) - cond829 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs831 = Proto.Binding[] + cond832 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond832 + _t1541 = parse_binding(parser) + item833 = _t1541 + push!(xs831, item833) + cond832 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings831 = xs828 - return bindings831 + bindings834 = xs831 + return bindings834 end function parse_formula(parser::ParserState)::Proto.Formula - span_start846 = span_start(parser) + span_start849 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t1537 = 0 + _t1543 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t1538 = 11 + _t1544 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t1539 = 3 + _t1545 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t1540 = 10 + _t1546 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t1541 = 9 + _t1547 = 9 else if match_lookahead_literal(parser, "or", 1) - _t1542 = 5 + _t1548 = 5 else if match_lookahead_literal(parser, "not", 1) - _t1543 = 6 + _t1549 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t1544 = 7 + _t1550 = 7 else if match_lookahead_literal(parser, "false", 1) - _t1545 = 1 + _t1551 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t1546 = 2 + _t1552 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t1547 = 12 + _t1553 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t1548 = 8 + _t1554 = 8 else if match_lookahead_literal(parser, "and", 1) - _t1549 = 4 + _t1555 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t1550 = 10 + _t1556 = 10 else if match_lookahead_literal(parser, ">", 1) - _t1551 = 10 + _t1557 = 10 else if match_lookahead_literal(parser, "=", 1) - _t1552 = 10 + _t1558 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t1553 = 10 + _t1559 = 10 else if match_lookahead_literal(parser, "<", 1) - _t1554 = 10 + _t1560 = 10 else if match_lookahead_literal(parser, "/", 1) - _t1555 = 10 + _t1561 = 10 else if match_lookahead_literal(parser, "-", 1) - _t1556 = 10 + _t1562 = 10 else if match_lookahead_literal(parser, "+", 1) - _t1557 = 10 + _t1563 = 10 else if match_lookahead_literal(parser, "*", 1) - _t1558 = 10 + _t1564 = 10 else - _t1558 = -1 + _t1564 = -1 end - _t1557 = _t1558 + _t1563 = _t1564 end - _t1556 = _t1557 + _t1562 = _t1563 end - _t1555 = _t1556 + _t1561 = _t1562 end - _t1554 = _t1555 + _t1560 = _t1561 end - _t1553 = _t1554 + _t1559 = _t1560 end - _t1552 = _t1553 + _t1558 = _t1559 end - _t1551 = _t1552 + _t1557 = _t1558 end - _t1550 = _t1551 + _t1556 = _t1557 end - _t1549 = _t1550 + _t1555 = _t1556 end - _t1548 = _t1549 + _t1554 = _t1555 end - _t1547 = _t1548 + _t1553 = _t1554 end - _t1546 = _t1547 + _t1552 = _t1553 end - _t1545 = _t1546 + _t1551 = _t1552 end - _t1544 = _t1545 + _t1550 = _t1551 end - _t1543 = _t1544 + _t1549 = _t1550 end - _t1542 = _t1543 + _t1548 = _t1549 end - _t1541 = _t1542 + _t1547 = _t1548 end - _t1540 = _t1541 + _t1546 = _t1547 end - _t1539 = _t1540 + _t1545 = _t1546 end - _t1538 = _t1539 + _t1544 = _t1545 end - _t1537 = _t1538 + _t1543 = _t1544 end - _t1536 = _t1537 + _t1542 = _t1543 else - _t1536 = -1 - end - prediction832 = _t1536 - if prediction832 == 12 - _t1560 = parse_cast(parser) - cast845 = _t1560 - _t1561 = Proto.Formula(formula_type=OneOf(:cast, cast845)) - _t1559 = _t1561 + _t1542 = -1 + end + prediction835 = _t1542 + if prediction835 == 12 + _t1566 = parse_cast(parser) + cast848 = _t1566 + _t1567 = Proto.Formula(formula_type=OneOf(:cast, cast848)) + _t1565 = _t1567 else - if prediction832 == 11 - _t1563 = parse_rel_atom(parser) - rel_atom844 = _t1563 - _t1564 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom844)) - _t1562 = _t1564 + if prediction835 == 11 + _t1569 = parse_rel_atom(parser) + rel_atom847 = _t1569 + _t1570 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom847)) + _t1568 = _t1570 else - if prediction832 == 10 - _t1566 = parse_primitive(parser) - primitive843 = _t1566 - _t1567 = Proto.Formula(formula_type=OneOf(:primitive, primitive843)) - _t1565 = _t1567 + if prediction835 == 10 + _t1572 = parse_primitive(parser) + primitive846 = _t1572 + _t1573 = Proto.Formula(formula_type=OneOf(:primitive, primitive846)) + _t1571 = _t1573 else - if prediction832 == 9 - _t1569 = parse_pragma(parser) - pragma842 = _t1569 - _t1570 = Proto.Formula(formula_type=OneOf(:pragma, pragma842)) - _t1568 = _t1570 + if prediction835 == 9 + _t1575 = parse_pragma(parser) + pragma845 = _t1575 + _t1576 = Proto.Formula(formula_type=OneOf(:pragma, pragma845)) + _t1574 = _t1576 else - if prediction832 == 8 - _t1572 = parse_atom(parser) - atom841 = _t1572 - _t1573 = Proto.Formula(formula_type=OneOf(:atom, atom841)) - _t1571 = _t1573 + if prediction835 == 8 + _t1578 = parse_atom(parser) + atom844 = _t1578 + _t1579 = Proto.Formula(formula_type=OneOf(:atom, atom844)) + _t1577 = _t1579 else - if prediction832 == 7 - _t1575 = parse_ffi(parser) - ffi840 = _t1575 - _t1576 = Proto.Formula(formula_type=OneOf(:ffi, ffi840)) - _t1574 = _t1576 + if prediction835 == 7 + _t1581 = parse_ffi(parser) + ffi843 = _t1581 + _t1582 = Proto.Formula(formula_type=OneOf(:ffi, ffi843)) + _t1580 = _t1582 else - if prediction832 == 6 - _t1578 = parse_not(parser) - not839 = _t1578 - _t1579 = Proto.Formula(formula_type=OneOf(:not, not839)) - _t1577 = _t1579 + if prediction835 == 6 + _t1584 = parse_not(parser) + not842 = _t1584 + _t1585 = Proto.Formula(formula_type=OneOf(:not, not842)) + _t1583 = _t1585 else - if prediction832 == 5 - _t1581 = parse_disjunction(parser) - disjunction838 = _t1581 - _t1582 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction838)) - _t1580 = _t1582 + if prediction835 == 5 + _t1587 = parse_disjunction(parser) + disjunction841 = _t1587 + _t1588 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction841)) + _t1586 = _t1588 else - if prediction832 == 4 - _t1584 = parse_conjunction(parser) - conjunction837 = _t1584 - _t1585 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction837)) - _t1583 = _t1585 + if prediction835 == 4 + _t1590 = parse_conjunction(parser) + conjunction840 = _t1590 + _t1591 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction840)) + _t1589 = _t1591 else - if prediction832 == 3 - _t1587 = parse_reduce(parser) - reduce836 = _t1587 - _t1588 = Proto.Formula(formula_type=OneOf(:reduce, reduce836)) - _t1586 = _t1588 + if prediction835 == 3 + _t1593 = parse_reduce(parser) + reduce839 = _t1593 + _t1594 = Proto.Formula(formula_type=OneOf(:reduce, reduce839)) + _t1592 = _t1594 else - if prediction832 == 2 - _t1590 = parse_exists(parser) - exists835 = _t1590 - _t1591 = Proto.Formula(formula_type=OneOf(:exists, exists835)) - _t1589 = _t1591 + if prediction835 == 2 + _t1596 = parse_exists(parser) + exists838 = _t1596 + _t1597 = Proto.Formula(formula_type=OneOf(:exists, exists838)) + _t1595 = _t1597 else - if prediction832 == 1 - _t1593 = parse_false(parser) - false834 = _t1593 - _t1594 = Proto.Formula(formula_type=OneOf(:disjunction, false834)) - _t1592 = _t1594 + if prediction835 == 1 + _t1599 = parse_false(parser) + false837 = _t1599 + _t1600 = Proto.Formula(formula_type=OneOf(:disjunction, false837)) + _t1598 = _t1600 else - if prediction832 == 0 - _t1596 = parse_true(parser) - true833 = _t1596 - _t1597 = Proto.Formula(formula_type=OneOf(:conjunction, true833)) - _t1595 = _t1597 + if prediction835 == 0 + _t1602 = parse_true(parser) + true836 = _t1602 + _t1603 = Proto.Formula(formula_type=OneOf(:conjunction, true836)) + _t1601 = _t1603 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t1592 = _t1595 + _t1598 = _t1601 end - _t1589 = _t1592 + _t1595 = _t1598 end - _t1586 = _t1589 + _t1592 = _t1595 end - _t1583 = _t1586 + _t1589 = _t1592 end - _t1580 = _t1583 + _t1586 = _t1589 end - _t1577 = _t1580 + _t1583 = _t1586 end - _t1574 = _t1577 + _t1580 = _t1583 end - _t1571 = _t1574 + _t1577 = _t1580 end - _t1568 = _t1571 + _t1574 = _t1577 end - _t1565 = _t1568 + _t1571 = _t1574 end - _t1562 = _t1565 + _t1568 = _t1571 end - _t1559 = _t1562 + _t1565 = _t1568 end - result847 = _t1559 - record_span!(parser, span_start846, "Formula") - return result847 + result850 = _t1565 + record_span!(parser, span_start849, "Formula") + return result850 end function parse_true(parser::ParserState)::Proto.Conjunction - span_start848 = span_start(parser) + span_start851 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t1598 = Proto.Conjunction(args=Proto.Formula[]) - result849 = _t1598 - record_span!(parser, span_start848, "Conjunction") - return result849 + _t1604 = Proto.Conjunction(args=Proto.Formula[]) + result852 = _t1604 + record_span!(parser, span_start851, "Conjunction") + return result852 end function parse_false(parser::ParserState)::Proto.Disjunction - span_start850 = span_start(parser) + span_start853 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t1599 = Proto.Disjunction(args=Proto.Formula[]) - result851 = _t1599 - record_span!(parser, span_start850, "Disjunction") - return result851 + _t1605 = Proto.Disjunction(args=Proto.Formula[]) + result854 = _t1605 + record_span!(parser, span_start853, "Disjunction") + return result854 end function parse_exists(parser::ParserState)::Proto.Exists - span_start854 = span_start(parser) + span_start857 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t1600 = parse_bindings(parser) - bindings852 = _t1600 - _t1601 = parse_formula(parser) - formula853 = _t1601 + _t1606 = parse_bindings(parser) + bindings855 = _t1606 + _t1607 = parse_formula(parser) + formula856 = _t1607 consume_literal!(parser, ")") - _t1602 = Proto.Abstraction(vars=vcat(bindings852[1], !isnothing(bindings852[2]) ? bindings852[2] : []), value=formula853) - _t1603 = Proto.Exists(body=_t1602) - result855 = _t1603 - record_span!(parser, span_start854, "Exists") - return result855 + _t1608 = Proto.Abstraction(vars=vcat(bindings855[1], !isnothing(bindings855[2]) ? bindings855[2] : []), value=formula856) + _t1609 = Proto.Exists(body=_t1608) + result858 = _t1609 + record_span!(parser, span_start857, "Exists") + return result858 end function parse_reduce(parser::ParserState)::Proto.Reduce - span_start859 = span_start(parser) + span_start862 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t1604 = parse_abstraction(parser) - abstraction856 = _t1604 - _t1605 = parse_abstraction(parser) - abstraction_3857 = _t1605 - _t1606 = parse_terms(parser) - terms858 = _t1606 + _t1610 = parse_abstraction(parser) + abstraction859 = _t1610 + _t1611 = parse_abstraction(parser) + abstraction_3860 = _t1611 + _t1612 = parse_terms(parser) + terms861 = _t1612 consume_literal!(parser, ")") - _t1607 = Proto.Reduce(op=abstraction856, body=abstraction_3857, terms=terms858) - result860 = _t1607 - record_span!(parser, span_start859, "Reduce") - return result860 + _t1613 = Proto.Reduce(op=abstraction859, body=abstraction_3860, terms=terms861) + result863 = _t1613 + record_span!(parser, span_start862, "Reduce") + return result863 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs861 = Proto.Term[] - cond862 = (((((((((((((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 cond862 - _t1608 = parse_term(parser) - item863 = _t1608 - push!(xs861, item863) - cond862 = (((((((((((((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 - terms864 = xs861 + xs864 = Proto.Term[] + cond865 = (((((((((((((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 cond865 + _t1614 = parse_term(parser) + item866 = _t1614 + push!(xs864, item866) + cond865 = (((((((((((((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 + terms867 = xs864 consume_literal!(parser, ")") - return terms864 + return terms867 end function parse_term(parser::ParserState)::Proto.Term - span_start868 = span_start(parser) + span_start871 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1609 = 1 + _t1615 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1610 = 1 + _t1616 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1611 = 1 + _t1617 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1612 = 1 + _t1618 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1613 = 0 + _t1619 = 0 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1614 = 1 + _t1620 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1615 = 1 + _t1621 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1616 = 1 + _t1622 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1617 = 1 + _t1623 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1618 = 1 + _t1624 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1619 = 1 + _t1625 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1620 = 1 + _t1626 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1621 = 1 + _t1627 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1622 = 1 + _t1628 = 1 else - _t1622 = -1 + _t1628 = -1 end - _t1621 = _t1622 + _t1627 = _t1628 end - _t1620 = _t1621 + _t1626 = _t1627 end - _t1619 = _t1620 + _t1625 = _t1626 end - _t1618 = _t1619 + _t1624 = _t1625 end - _t1617 = _t1618 + _t1623 = _t1624 end - _t1616 = _t1617 + _t1622 = _t1623 end - _t1615 = _t1616 + _t1621 = _t1622 end - _t1614 = _t1615 + _t1620 = _t1621 end - _t1613 = _t1614 + _t1619 = _t1620 end - _t1612 = _t1613 + _t1618 = _t1619 end - _t1611 = _t1612 + _t1617 = _t1618 end - _t1610 = _t1611 + _t1616 = _t1617 end - _t1609 = _t1610 - end - prediction865 = _t1609 - if prediction865 == 1 - _t1624 = parse_value(parser) - value867 = _t1624 - _t1625 = Proto.Term(term_type=OneOf(:constant, value867)) - _t1623 = _t1625 + _t1615 = _t1616 + end + prediction868 = _t1615 + if prediction868 == 1 + _t1630 = parse_value(parser) + value870 = _t1630 + _t1631 = Proto.Term(term_type=OneOf(:constant, value870)) + _t1629 = _t1631 else - if prediction865 == 0 - _t1627 = parse_var(parser) - var866 = _t1627 - _t1628 = Proto.Term(term_type=OneOf(:var, var866)) - _t1626 = _t1628 + if prediction868 == 0 + _t1633 = parse_var(parser) + var869 = _t1633 + _t1634 = Proto.Term(term_type=OneOf(:var, var869)) + _t1632 = _t1634 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t1623 = _t1626 + _t1629 = _t1632 end - result869 = _t1623 - record_span!(parser, span_start868, "Term") - return result869 + result872 = _t1629 + record_span!(parser, span_start871, "Term") + return result872 end function parse_var(parser::ParserState)::Proto.Var - span_start871 = span_start(parser) - symbol870 = consume_terminal!(parser, "SYMBOL") - _t1629 = Proto.Var(name=symbol870) - result872 = _t1629 - record_span!(parser, span_start871, "Var") - return result872 + span_start874 = span_start(parser) + symbol873 = consume_terminal!(parser, "SYMBOL") + _t1635 = Proto.Var(name=symbol873) + result875 = _t1635 + record_span!(parser, span_start874, "Var") + return result875 end function parse_value(parser::ParserState)::Proto.Value - span_start886 = span_start(parser) + span_start889 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1630 = 12 + _t1636 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1631 = 11 + _t1637 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1632 = 12 + _t1638 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1634 = 1 + _t1640 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1635 = 0 + _t1641 = 0 else - _t1635 = -1 + _t1641 = -1 end - _t1634 = _t1635 + _t1640 = _t1641 end - _t1633 = _t1634 + _t1639 = _t1640 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1636 = 7 + _t1642 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1637 = 8 + _t1643 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1638 = 2 + _t1644 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1639 = 3 + _t1645 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1640 = 9 + _t1646 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1641 = 4 + _t1647 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1642 = 5 + _t1648 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1643 = 6 + _t1649 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1644 = 10 + _t1650 = 10 else - _t1644 = -1 + _t1650 = -1 end - _t1643 = _t1644 + _t1649 = _t1650 end - _t1642 = _t1643 + _t1648 = _t1649 end - _t1641 = _t1642 + _t1647 = _t1648 end - _t1640 = _t1641 + _t1646 = _t1647 end - _t1639 = _t1640 + _t1645 = _t1646 end - _t1638 = _t1639 + _t1644 = _t1645 end - _t1637 = _t1638 + _t1643 = _t1644 end - _t1636 = _t1637 + _t1642 = _t1643 end - _t1633 = _t1636 + _t1639 = _t1642 end - _t1632 = _t1633 + _t1638 = _t1639 end - _t1631 = _t1632 + _t1637 = _t1638 end - _t1630 = _t1631 - end - prediction873 = _t1630 - if prediction873 == 12 - _t1646 = parse_boolean_value(parser) - boolean_value885 = _t1646 - _t1647 = Proto.Value(value=OneOf(:boolean_value, boolean_value885)) - _t1645 = _t1647 + _t1636 = _t1637 + end + prediction876 = _t1636 + if prediction876 == 12 + _t1652 = parse_boolean_value(parser) + boolean_value888 = _t1652 + _t1653 = Proto.Value(value=OneOf(:boolean_value, boolean_value888)) + _t1651 = _t1653 else - if prediction873 == 11 + if prediction876 == 11 consume_literal!(parser, "missing") - _t1649 = Proto.MissingValue() - _t1650 = Proto.Value(value=OneOf(:missing_value, _t1649)) - _t1648 = _t1650 + _t1655 = Proto.MissingValue() + _t1656 = Proto.Value(value=OneOf(:missing_value, _t1655)) + _t1654 = _t1656 else - if prediction873 == 10 - formatted_decimal884 = consume_terminal!(parser, "DECIMAL") - _t1652 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal884)) - _t1651 = _t1652 + if prediction876 == 10 + formatted_decimal887 = consume_terminal!(parser, "DECIMAL") + _t1658 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal887)) + _t1657 = _t1658 else - if prediction873 == 9 - formatted_int128883 = consume_terminal!(parser, "INT128") - _t1654 = Proto.Value(value=OneOf(:int128_value, formatted_int128883)) - _t1653 = _t1654 + if prediction876 == 9 + formatted_int128886 = consume_terminal!(parser, "INT128") + _t1660 = Proto.Value(value=OneOf(:int128_value, formatted_int128886)) + _t1659 = _t1660 else - if prediction873 == 8 - formatted_uint128882 = consume_terminal!(parser, "UINT128") - _t1656 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128882)) - _t1655 = _t1656 + if prediction876 == 8 + formatted_uint128885 = consume_terminal!(parser, "UINT128") + _t1662 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128885)) + _t1661 = _t1662 else - if prediction873 == 7 - formatted_uint32881 = consume_terminal!(parser, "UINT32") - _t1658 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32881)) - _t1657 = _t1658 + if prediction876 == 7 + formatted_uint32884 = consume_terminal!(parser, "UINT32") + _t1664 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32884)) + _t1663 = _t1664 else - if prediction873 == 6 - formatted_float880 = consume_terminal!(parser, "FLOAT") - _t1660 = Proto.Value(value=OneOf(:float_value, formatted_float880)) - _t1659 = _t1660 + if prediction876 == 6 + formatted_float883 = consume_terminal!(parser, "FLOAT") + _t1666 = Proto.Value(value=OneOf(:float_value, formatted_float883)) + _t1665 = _t1666 else - if prediction873 == 5 - formatted_float32879 = consume_terminal!(parser, "FLOAT32") - _t1662 = Proto.Value(value=OneOf(:float32_value, formatted_float32879)) - _t1661 = _t1662 + if prediction876 == 5 + formatted_float32882 = consume_terminal!(parser, "FLOAT32") + _t1668 = Proto.Value(value=OneOf(:float32_value, formatted_float32882)) + _t1667 = _t1668 else - if prediction873 == 4 - formatted_int878 = consume_terminal!(parser, "INT") - _t1664 = Proto.Value(value=OneOf(:int_value, formatted_int878)) - _t1663 = _t1664 + if prediction876 == 4 + formatted_int881 = consume_terminal!(parser, "INT") + _t1670 = Proto.Value(value=OneOf(:int_value, formatted_int881)) + _t1669 = _t1670 else - if prediction873 == 3 - formatted_int32877 = consume_terminal!(parser, "INT32") - _t1666 = Proto.Value(value=OneOf(:int32_value, formatted_int32877)) - _t1665 = _t1666 + if prediction876 == 3 + formatted_int32880 = consume_terminal!(parser, "INT32") + _t1672 = Proto.Value(value=OneOf(:int32_value, formatted_int32880)) + _t1671 = _t1672 else - if prediction873 == 2 - formatted_string876 = consume_terminal!(parser, "STRING") - _t1668 = Proto.Value(value=OneOf(:string_value, formatted_string876)) - _t1667 = _t1668 + if prediction876 == 2 + formatted_string879 = consume_terminal!(parser, "STRING") + _t1674 = Proto.Value(value=OneOf(:string_value, formatted_string879)) + _t1673 = _t1674 else - if prediction873 == 1 - _t1670 = parse_datetime(parser) - datetime875 = _t1670 - _t1671 = Proto.Value(value=OneOf(:datetime_value, datetime875)) - _t1669 = _t1671 + if prediction876 == 1 + _t1676 = parse_datetime(parser) + datetime878 = _t1676 + _t1677 = Proto.Value(value=OneOf(:datetime_value, datetime878)) + _t1675 = _t1677 else - if prediction873 == 0 - _t1673 = parse_date(parser) - date874 = _t1673 - _t1674 = Proto.Value(value=OneOf(:date_value, date874)) - _t1672 = _t1674 + if prediction876 == 0 + _t1679 = parse_date(parser) + date877 = _t1679 + _t1680 = Proto.Value(value=OneOf(:date_value, date877)) + _t1678 = _t1680 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t1669 = _t1672 + _t1675 = _t1678 end - _t1667 = _t1669 + _t1673 = _t1675 end - _t1665 = _t1667 + _t1671 = _t1673 end - _t1663 = _t1665 + _t1669 = _t1671 end - _t1661 = _t1663 + _t1667 = _t1669 end - _t1659 = _t1661 + _t1665 = _t1667 end - _t1657 = _t1659 + _t1663 = _t1665 end - _t1655 = _t1657 + _t1661 = _t1663 end - _t1653 = _t1655 + _t1659 = _t1661 end - _t1651 = _t1653 + _t1657 = _t1659 end - _t1648 = _t1651 + _t1654 = _t1657 end - _t1645 = _t1648 + _t1651 = _t1654 end - result887 = _t1645 - record_span!(parser, span_start886, "Value") - return result887 + result890 = _t1651 + record_span!(parser, span_start889, "Value") + return result890 end function parse_date(parser::ParserState)::Proto.DateValue - span_start891 = span_start(parser) + span_start894 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - formatted_int888 = consume_terminal!(parser, "INT") - formatted_int_3889 = consume_terminal!(parser, "INT") - formatted_int_4890 = consume_terminal!(parser, "INT") + formatted_int891 = consume_terminal!(parser, "INT") + formatted_int_3892 = consume_terminal!(parser, "INT") + formatted_int_4893 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1675 = Proto.DateValue(year=Int32(formatted_int888), month=Int32(formatted_int_3889), day=Int32(formatted_int_4890)) - result892 = _t1675 - record_span!(parser, span_start891, "DateValue") - return result892 + _t1681 = Proto.DateValue(year=Int32(formatted_int891), month=Int32(formatted_int_3892), day=Int32(formatted_int_4893)) + result895 = _t1681 + record_span!(parser, span_start894, "DateValue") + return result895 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue - span_start900 = span_start(parser) + span_start903 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - formatted_int893 = consume_terminal!(parser, "INT") - formatted_int_3894 = consume_terminal!(parser, "INT") - formatted_int_4895 = consume_terminal!(parser, "INT") - formatted_int_5896 = consume_terminal!(parser, "INT") - formatted_int_6897 = consume_terminal!(parser, "INT") - formatted_int_7898 = consume_terminal!(parser, "INT") + formatted_int896 = consume_terminal!(parser, "INT") + formatted_int_3897 = consume_terminal!(parser, "INT") + formatted_int_4898 = consume_terminal!(parser, "INT") + formatted_int_5899 = consume_terminal!(parser, "INT") + formatted_int_6900 = consume_terminal!(parser, "INT") + formatted_int_7901 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1676 = consume_terminal!(parser, "INT") + _t1682 = consume_terminal!(parser, "INT") else - _t1676 = nothing + _t1682 = nothing end - formatted_int_8899 = _t1676 + formatted_int_8902 = _t1682 consume_literal!(parser, ")") - _t1677 = Proto.DateTimeValue(year=Int32(formatted_int893), month=Int32(formatted_int_3894), day=Int32(formatted_int_4895), hour=Int32(formatted_int_5896), minute=Int32(formatted_int_6897), second=Int32(formatted_int_7898), microsecond=Int32((!isnothing(formatted_int_8899) ? formatted_int_8899 : 0))) - result901 = _t1677 - record_span!(parser, span_start900, "DateTimeValue") - return result901 + _t1683 = Proto.DateTimeValue(year=Int32(formatted_int896), month=Int32(formatted_int_3897), day=Int32(formatted_int_4898), hour=Int32(formatted_int_5899), minute=Int32(formatted_int_6900), second=Int32(formatted_int_7901), microsecond=Int32((!isnothing(formatted_int_8902) ? formatted_int_8902 : 0))) + result904 = _t1683 + record_span!(parser, span_start903, "DateTimeValue") + return result904 end function parse_conjunction(parser::ParserState)::Proto.Conjunction - span_start906 = span_start(parser) + span_start909 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "and") - xs902 = Proto.Formula[] - cond903 = match_lookahead_literal(parser, "(", 0) - while cond903 - _t1678 = parse_formula(parser) - item904 = _t1678 - push!(xs902, item904) - cond903 = match_lookahead_literal(parser, "(", 0) - end - formulas905 = xs902 + xs905 = Proto.Formula[] + cond906 = match_lookahead_literal(parser, "(", 0) + while cond906 + _t1684 = parse_formula(parser) + item907 = _t1684 + push!(xs905, item907) + cond906 = match_lookahead_literal(parser, "(", 0) + end + formulas908 = xs905 consume_literal!(parser, ")") - _t1679 = Proto.Conjunction(args=formulas905) - result907 = _t1679 - record_span!(parser, span_start906, "Conjunction") - return result907 + _t1685 = Proto.Conjunction(args=formulas908) + result910 = _t1685 + record_span!(parser, span_start909, "Conjunction") + return result910 end function parse_disjunction(parser::ParserState)::Proto.Disjunction - span_start912 = span_start(parser) + span_start915 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") - xs908 = Proto.Formula[] - cond909 = match_lookahead_literal(parser, "(", 0) - while cond909 - _t1680 = parse_formula(parser) - item910 = _t1680 - push!(xs908, item910) - cond909 = match_lookahead_literal(parser, "(", 0) - end - formulas911 = xs908 + xs911 = Proto.Formula[] + cond912 = match_lookahead_literal(parser, "(", 0) + while cond912 + _t1686 = parse_formula(parser) + item913 = _t1686 + push!(xs911, item913) + cond912 = match_lookahead_literal(parser, "(", 0) + end + formulas914 = xs911 consume_literal!(parser, ")") - _t1681 = Proto.Disjunction(args=formulas911) - result913 = _t1681 - record_span!(parser, span_start912, "Disjunction") - return result913 + _t1687 = Proto.Disjunction(args=formulas914) + result916 = _t1687 + record_span!(parser, span_start915, "Disjunction") + return result916 end function parse_not(parser::ParserState)::Proto.Not - span_start915 = span_start(parser) + span_start918 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "not") - _t1682 = parse_formula(parser) - formula914 = _t1682 + _t1688 = parse_formula(parser) + formula917 = _t1688 consume_literal!(parser, ")") - _t1683 = Proto.Not(arg=formula914) - result916 = _t1683 - record_span!(parser, span_start915, "Not") - return result916 + _t1689 = Proto.Not(arg=formula917) + result919 = _t1689 + record_span!(parser, span_start918, "Not") + return result919 end function parse_ffi(parser::ParserState)::Proto.FFI - span_start920 = span_start(parser) + span_start923 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t1684 = parse_name(parser) - name917 = _t1684 - _t1685 = parse_ffi_args(parser) - ffi_args918 = _t1685 - _t1686 = parse_terms(parser) - terms919 = _t1686 + _t1690 = parse_name(parser) + name920 = _t1690 + _t1691 = parse_ffi_args(parser) + ffi_args921 = _t1691 + _t1692 = parse_terms(parser) + terms922 = _t1692 consume_literal!(parser, ")") - _t1687 = Proto.FFI(name=name917, args=ffi_args918, terms=terms919) - result921 = _t1687 - record_span!(parser, span_start920, "FFI") - return result921 + _t1693 = Proto.FFI(name=name920, args=ffi_args921, terms=terms922) + result924 = _t1693 + record_span!(parser, span_start923, "FFI") + return result924 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol922 = consume_terminal!(parser, "SYMBOL") - return symbol922 + symbol925 = consume_terminal!(parser, "SYMBOL") + return symbol925 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs923 = Proto.Abstraction[] - cond924 = match_lookahead_literal(parser, "(", 0) - while cond924 - _t1688 = parse_abstraction(parser) - item925 = _t1688 - push!(xs923, item925) - cond924 = match_lookahead_literal(parser, "(", 0) - end - abstractions926 = xs923 + xs926 = Proto.Abstraction[] + cond927 = match_lookahead_literal(parser, "(", 0) + while cond927 + _t1694 = parse_abstraction(parser) + item928 = _t1694 + push!(xs926, item928) + cond927 = match_lookahead_literal(parser, "(", 0) + end + abstractions929 = xs926 consume_literal!(parser, ")") - return abstractions926 + return abstractions929 end function parse_atom(parser::ParserState)::Proto.Atom - span_start932 = span_start(parser) + span_start935 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1689 = parse_relation_id(parser) - relation_id927 = _t1689 - xs928 = Proto.Term[] - cond929 = (((((((((((((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 cond929 - _t1690 = parse_term(parser) - item930 = _t1690 - push!(xs928, item930) - cond929 = (((((((((((((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 - terms931 = xs928 + _t1695 = parse_relation_id(parser) + relation_id930 = _t1695 + xs931 = Proto.Term[] + cond932 = (((((((((((((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 cond932 + _t1696 = parse_term(parser) + item933 = _t1696 + push!(xs931, item933) + cond932 = (((((((((((((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 + terms934 = xs931 consume_literal!(parser, ")") - _t1691 = Proto.Atom(name=relation_id927, terms=terms931) - result933 = _t1691 - record_span!(parser, span_start932, "Atom") - return result933 + _t1697 = Proto.Atom(name=relation_id930, terms=terms934) + result936 = _t1697 + record_span!(parser, span_start935, "Atom") + return result936 end function parse_pragma(parser::ParserState)::Proto.Pragma - span_start939 = span_start(parser) + span_start942 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1692 = parse_name(parser) - name934 = _t1692 - xs935 = Proto.Term[] - cond936 = (((((((((((((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 cond936 - _t1693 = parse_term(parser) - item937 = _t1693 - push!(xs935, item937) - cond936 = (((((((((((((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 - terms938 = xs935 + _t1698 = parse_name(parser) + name937 = _t1698 + xs938 = Proto.Term[] + cond939 = (((((((((((((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 cond939 + _t1699 = parse_term(parser) + item940 = _t1699 + push!(xs938, item940) + cond939 = (((((((((((((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 + terms941 = xs938 consume_literal!(parser, ")") - _t1694 = Proto.Pragma(name=name934, terms=terms938) - result940 = _t1694 - record_span!(parser, span_start939, "Pragma") - return result940 + _t1700 = Proto.Pragma(name=name937, terms=terms941) + result943 = _t1700 + record_span!(parser, span_start942, "Pragma") + return result943 end function parse_primitive(parser::ParserState)::Proto.Primitive - span_start956 = span_start(parser) + span_start959 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1696 = 9 + _t1702 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1697 = 4 + _t1703 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1698 = 3 + _t1704 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1699 = 0 + _t1705 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1700 = 2 + _t1706 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1701 = 1 + _t1707 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1702 = 8 + _t1708 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1703 = 6 + _t1709 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1704 = 5 + _t1710 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1705 = 7 + _t1711 = 7 else - _t1705 = -1 + _t1711 = -1 end - _t1704 = _t1705 + _t1710 = _t1711 end - _t1703 = _t1704 + _t1709 = _t1710 end - _t1702 = _t1703 + _t1708 = _t1709 end - _t1701 = _t1702 + _t1707 = _t1708 end - _t1700 = _t1701 + _t1706 = _t1707 end - _t1699 = _t1700 + _t1705 = _t1706 end - _t1698 = _t1699 + _t1704 = _t1705 end - _t1697 = _t1698 + _t1703 = _t1704 end - _t1696 = _t1697 + _t1702 = _t1703 end - _t1695 = _t1696 + _t1701 = _t1702 else - _t1695 = -1 + _t1701 = -1 end - prediction941 = _t1695 - if prediction941 == 9 + prediction944 = _t1701 + if prediction944 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1707 = parse_name(parser) - name951 = _t1707 - xs952 = Proto.RelTerm[] - cond953 = ((((((((((((((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 cond953 - _t1708 = parse_rel_term(parser) - item954 = _t1708 - push!(xs952, item954) - cond953 = ((((((((((((((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)) + _t1713 = parse_name(parser) + name954 = _t1713 + xs955 = Proto.RelTerm[] + cond956 = ((((((((((((((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 cond956 + _t1714 = parse_rel_term(parser) + item957 = _t1714 + push!(xs955, item957) + cond956 = ((((((((((((((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_terms955 = xs952 + rel_terms958 = xs955 consume_literal!(parser, ")") - _t1709 = Proto.Primitive(name=name951, terms=rel_terms955) - _t1706 = _t1709 + _t1715 = Proto.Primitive(name=name954, terms=rel_terms958) + _t1712 = _t1715 else - if prediction941 == 8 - _t1711 = parse_divide(parser) - divide950 = _t1711 - _t1710 = divide950 + if prediction944 == 8 + _t1717 = parse_divide(parser) + divide953 = _t1717 + _t1716 = divide953 else - if prediction941 == 7 - _t1713 = parse_multiply(parser) - multiply949 = _t1713 - _t1712 = multiply949 + if prediction944 == 7 + _t1719 = parse_multiply(parser) + multiply952 = _t1719 + _t1718 = multiply952 else - if prediction941 == 6 - _t1715 = parse_minus(parser) - minus948 = _t1715 - _t1714 = minus948 + if prediction944 == 6 + _t1721 = parse_minus(parser) + minus951 = _t1721 + _t1720 = minus951 else - if prediction941 == 5 - _t1717 = parse_add(parser) - add947 = _t1717 - _t1716 = add947 + if prediction944 == 5 + _t1723 = parse_add(parser) + add950 = _t1723 + _t1722 = add950 else - if prediction941 == 4 - _t1719 = parse_gt_eq(parser) - gt_eq946 = _t1719 - _t1718 = gt_eq946 + if prediction944 == 4 + _t1725 = parse_gt_eq(parser) + gt_eq949 = _t1725 + _t1724 = gt_eq949 else - if prediction941 == 3 - _t1721 = parse_gt(parser) - gt945 = _t1721 - _t1720 = gt945 + if prediction944 == 3 + _t1727 = parse_gt(parser) + gt948 = _t1727 + _t1726 = gt948 else - if prediction941 == 2 - _t1723 = parse_lt_eq(parser) - lt_eq944 = _t1723 - _t1722 = lt_eq944 + if prediction944 == 2 + _t1729 = parse_lt_eq(parser) + lt_eq947 = _t1729 + _t1728 = lt_eq947 else - if prediction941 == 1 - _t1725 = parse_lt(parser) - lt943 = _t1725 - _t1724 = lt943 + if prediction944 == 1 + _t1731 = parse_lt(parser) + lt946 = _t1731 + _t1730 = lt946 else - if prediction941 == 0 - _t1727 = parse_eq(parser) - eq942 = _t1727 - _t1726 = eq942 + if prediction944 == 0 + _t1733 = parse_eq(parser) + eq945 = _t1733 + _t1732 = eq945 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1724 = _t1726 + _t1730 = _t1732 end - _t1722 = _t1724 + _t1728 = _t1730 end - _t1720 = _t1722 + _t1726 = _t1728 end - _t1718 = _t1720 + _t1724 = _t1726 end - _t1716 = _t1718 + _t1722 = _t1724 end - _t1714 = _t1716 + _t1720 = _t1722 end - _t1712 = _t1714 + _t1718 = _t1720 end - _t1710 = _t1712 + _t1716 = _t1718 end - _t1706 = _t1710 + _t1712 = _t1716 end - result957 = _t1706 - record_span!(parser, span_start956, "Primitive") - return result957 + result960 = _t1712 + record_span!(parser, span_start959, "Primitive") + return result960 end function parse_eq(parser::ParserState)::Proto.Primitive - span_start960 = span_start(parser) + span_start963 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1728 = parse_term(parser) - term958 = _t1728 - _t1729 = parse_term(parser) - term_3959 = _t1729 + _t1734 = parse_term(parser) + term961 = _t1734 + _t1735 = parse_term(parser) + term_3962 = _t1735 consume_literal!(parser, ")") - _t1730 = Proto.RelTerm(rel_term_type=OneOf(:term, term958)) - _t1731 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3959)) - _t1732 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1730, _t1731]) - result961 = _t1732 - record_span!(parser, span_start960, "Primitive") - return result961 + _t1736 = Proto.RelTerm(rel_term_type=OneOf(:term, term961)) + _t1737 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3962)) + _t1738 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1736, _t1737]) + result964 = _t1738 + record_span!(parser, span_start963, "Primitive") + return result964 end function parse_lt(parser::ParserState)::Proto.Primitive - span_start964 = span_start(parser) + span_start967 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1733 = parse_term(parser) - term962 = _t1733 - _t1734 = parse_term(parser) - term_3963 = _t1734 + _t1739 = parse_term(parser) + term965 = _t1739 + _t1740 = parse_term(parser) + term_3966 = _t1740 consume_literal!(parser, ")") - _t1735 = Proto.RelTerm(rel_term_type=OneOf(:term, term962)) - _t1736 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3963)) - _t1737 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1735, _t1736]) - result965 = _t1737 - record_span!(parser, span_start964, "Primitive") - return result965 + _t1741 = Proto.RelTerm(rel_term_type=OneOf(:term, term965)) + _t1742 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3966)) + _t1743 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1741, _t1742]) + result968 = _t1743 + record_span!(parser, span_start967, "Primitive") + return result968 end function parse_lt_eq(parser::ParserState)::Proto.Primitive - span_start968 = span_start(parser) + span_start971 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1738 = parse_term(parser) - term966 = _t1738 - _t1739 = parse_term(parser) - term_3967 = _t1739 + _t1744 = parse_term(parser) + term969 = _t1744 + _t1745 = parse_term(parser) + term_3970 = _t1745 consume_literal!(parser, ")") - _t1740 = Proto.RelTerm(rel_term_type=OneOf(:term, term966)) - _t1741 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3967)) - _t1742 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1740, _t1741]) - result969 = _t1742 - record_span!(parser, span_start968, "Primitive") - return result969 + _t1746 = Proto.RelTerm(rel_term_type=OneOf(:term, term969)) + _t1747 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3970)) + _t1748 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1746, _t1747]) + result972 = _t1748 + record_span!(parser, span_start971, "Primitive") + return result972 end function parse_gt(parser::ParserState)::Proto.Primitive - span_start972 = span_start(parser) + span_start975 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1743 = parse_term(parser) - term970 = _t1743 - _t1744 = parse_term(parser) - term_3971 = _t1744 + _t1749 = parse_term(parser) + term973 = _t1749 + _t1750 = parse_term(parser) + term_3974 = _t1750 consume_literal!(parser, ")") - _t1745 = Proto.RelTerm(rel_term_type=OneOf(:term, term970)) - _t1746 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3971)) - _t1747 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1745, _t1746]) - result973 = _t1747 - record_span!(parser, span_start972, "Primitive") - return result973 + _t1751 = Proto.RelTerm(rel_term_type=OneOf(:term, term973)) + _t1752 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3974)) + _t1753 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1751, _t1752]) + result976 = _t1753 + record_span!(parser, span_start975, "Primitive") + return result976 end function parse_gt_eq(parser::ParserState)::Proto.Primitive - span_start976 = span_start(parser) + span_start979 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1748 = parse_term(parser) - term974 = _t1748 - _t1749 = parse_term(parser) - term_3975 = _t1749 + _t1754 = parse_term(parser) + term977 = _t1754 + _t1755 = parse_term(parser) + term_3978 = _t1755 consume_literal!(parser, ")") - _t1750 = Proto.RelTerm(rel_term_type=OneOf(:term, term974)) - _t1751 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3975)) - _t1752 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1750, _t1751]) - result977 = _t1752 - record_span!(parser, span_start976, "Primitive") - return result977 + _t1756 = Proto.RelTerm(rel_term_type=OneOf(:term, term977)) + _t1757 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3978)) + _t1758 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1756, _t1757]) + result980 = _t1758 + record_span!(parser, span_start979, "Primitive") + return result980 end function parse_add(parser::ParserState)::Proto.Primitive - span_start981 = span_start(parser) + span_start984 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1753 = parse_term(parser) - term978 = _t1753 - _t1754 = parse_term(parser) - term_3979 = _t1754 - _t1755 = parse_term(parser) - term_4980 = _t1755 + _t1759 = parse_term(parser) + term981 = _t1759 + _t1760 = parse_term(parser) + term_3982 = _t1760 + _t1761 = parse_term(parser) + term_4983 = _t1761 consume_literal!(parser, ")") - _t1756 = Proto.RelTerm(rel_term_type=OneOf(:term, term978)) - _t1757 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3979)) - _t1758 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4980)) - _t1759 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1756, _t1757, _t1758]) - result982 = _t1759 - record_span!(parser, span_start981, "Primitive") - return result982 + _t1762 = Proto.RelTerm(rel_term_type=OneOf(:term, term981)) + _t1763 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3982)) + _t1764 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4983)) + _t1765 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1762, _t1763, _t1764]) + result985 = _t1765 + record_span!(parser, span_start984, "Primitive") + return result985 end function parse_minus(parser::ParserState)::Proto.Primitive - span_start986 = span_start(parser) + span_start989 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1760 = parse_term(parser) - term983 = _t1760 - _t1761 = parse_term(parser) - term_3984 = _t1761 - _t1762 = parse_term(parser) - term_4985 = _t1762 + _t1766 = parse_term(parser) + term986 = _t1766 + _t1767 = parse_term(parser) + term_3987 = _t1767 + _t1768 = parse_term(parser) + term_4988 = _t1768 consume_literal!(parser, ")") - _t1763 = Proto.RelTerm(rel_term_type=OneOf(:term, term983)) - _t1764 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3984)) - _t1765 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4985)) - _t1766 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1763, _t1764, _t1765]) - result987 = _t1766 - record_span!(parser, span_start986, "Primitive") - return result987 + _t1769 = Proto.RelTerm(rel_term_type=OneOf(:term, term986)) + _t1770 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3987)) + _t1771 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4988)) + _t1772 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1769, _t1770, _t1771]) + result990 = _t1772 + record_span!(parser, span_start989, "Primitive") + return result990 end function parse_multiply(parser::ParserState)::Proto.Primitive - span_start991 = span_start(parser) + span_start994 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1767 = parse_term(parser) - term988 = _t1767 - _t1768 = parse_term(parser) - term_3989 = _t1768 - _t1769 = parse_term(parser) - term_4990 = _t1769 + _t1773 = parse_term(parser) + term991 = _t1773 + _t1774 = parse_term(parser) + term_3992 = _t1774 + _t1775 = parse_term(parser) + term_4993 = _t1775 consume_literal!(parser, ")") - _t1770 = Proto.RelTerm(rel_term_type=OneOf(:term, term988)) - _t1771 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3989)) - _t1772 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4990)) - _t1773 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1770, _t1771, _t1772]) - result992 = _t1773 - record_span!(parser, span_start991, "Primitive") - return result992 + _t1776 = Proto.RelTerm(rel_term_type=OneOf(:term, term991)) + _t1777 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3992)) + _t1778 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4993)) + _t1779 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1776, _t1777, _t1778]) + result995 = _t1779 + record_span!(parser, span_start994, "Primitive") + return result995 end function parse_divide(parser::ParserState)::Proto.Primitive - span_start996 = span_start(parser) + span_start999 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1774 = parse_term(parser) - term993 = _t1774 - _t1775 = parse_term(parser) - term_3994 = _t1775 - _t1776 = parse_term(parser) - term_4995 = _t1776 + _t1780 = parse_term(parser) + term996 = _t1780 + _t1781 = parse_term(parser) + term_3997 = _t1781 + _t1782 = parse_term(parser) + term_4998 = _t1782 consume_literal!(parser, ")") - _t1777 = Proto.RelTerm(rel_term_type=OneOf(:term, term993)) - _t1778 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3994)) - _t1779 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4995)) - _t1780 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1777, _t1778, _t1779]) - result997 = _t1780 - record_span!(parser, span_start996, "Primitive") - return result997 + _t1783 = Proto.RelTerm(rel_term_type=OneOf(:term, term996)) + _t1784 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3997)) + _t1785 = Proto.RelTerm(rel_term_type=OneOf(:term, term_4998)) + _t1786 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1783, _t1784, _t1785]) + result1000 = _t1786 + record_span!(parser, span_start999, "Primitive") + return result1000 end function parse_rel_term(parser::ParserState)::Proto.RelTerm - span_start1001 = span_start(parser) + span_start1004 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1781 = 1 + _t1787 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1782 = 1 + _t1788 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1783 = 1 + _t1789 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1784 = 1 + _t1790 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1785 = 0 + _t1791 = 0 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1786 = 1 + _t1792 = 1 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1787 = 1 + _t1793 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1788 = 1 + _t1794 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1789 = 1 + _t1795 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1790 = 1 + _t1796 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1791 = 1 + _t1797 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1792 = 1 + _t1798 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1793 = 1 + _t1799 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1794 = 1 + _t1800 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1795 = 1 + _t1801 = 1 else - _t1795 = -1 + _t1801 = -1 end - _t1794 = _t1795 + _t1800 = _t1801 end - _t1793 = _t1794 + _t1799 = _t1800 end - _t1792 = _t1793 + _t1798 = _t1799 end - _t1791 = _t1792 + _t1797 = _t1798 end - _t1790 = _t1791 + _t1796 = _t1797 end - _t1789 = _t1790 + _t1795 = _t1796 end - _t1788 = _t1789 + _t1794 = _t1795 end - _t1787 = _t1788 + _t1793 = _t1794 end - _t1786 = _t1787 + _t1792 = _t1793 end - _t1785 = _t1786 + _t1791 = _t1792 end - _t1784 = _t1785 + _t1790 = _t1791 end - _t1783 = _t1784 + _t1789 = _t1790 end - _t1782 = _t1783 + _t1788 = _t1789 end - _t1781 = _t1782 - end - prediction998 = _t1781 - if prediction998 == 1 - _t1797 = parse_term(parser) - term1000 = _t1797 - _t1798 = Proto.RelTerm(rel_term_type=OneOf(:term, term1000)) - _t1796 = _t1798 + _t1787 = _t1788 + end + prediction1001 = _t1787 + if prediction1001 == 1 + _t1803 = parse_term(parser) + term1003 = _t1803 + _t1804 = Proto.RelTerm(rel_term_type=OneOf(:term, term1003)) + _t1802 = _t1804 else - if prediction998 == 0 - _t1800 = parse_specialized_value(parser) - specialized_value999 = _t1800 - _t1801 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value999)) - _t1799 = _t1801 + if prediction1001 == 0 + _t1806 = parse_specialized_value(parser) + specialized_value1002 = _t1806 + _t1807 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1002)) + _t1805 = _t1807 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1796 = _t1799 + _t1802 = _t1805 end - result1002 = _t1796 - record_span!(parser, span_start1001, "RelTerm") - return result1002 + result1005 = _t1802 + record_span!(parser, span_start1004, "RelTerm") + return result1005 end function parse_specialized_value(parser::ParserState)::Proto.Value - span_start1004 = span_start(parser) + span_start1007 = span_start(parser) consume_literal!(parser, "#") - _t1802 = parse_raw_value(parser) - raw_value1003 = _t1802 - result1005 = raw_value1003 - record_span!(parser, span_start1004, "Value") - return result1005 + _t1808 = parse_raw_value(parser) + raw_value1006 = _t1808 + result1008 = raw_value1006 + record_span!(parser, span_start1007, "Value") + return result1008 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom - span_start1011 = span_start(parser) + span_start1014 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1803 = parse_name(parser) - name1006 = _t1803 - xs1007 = Proto.RelTerm[] - cond1008 = ((((((((((((((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 cond1008 - _t1804 = parse_rel_term(parser) - item1009 = _t1804 - push!(xs1007, item1009) - cond1008 = ((((((((((((((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_terms1010 = xs1007 + _t1809 = parse_name(parser) + name1009 = _t1809 + xs1010 = Proto.RelTerm[] + cond1011 = ((((((((((((((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 cond1011 + _t1810 = parse_rel_term(parser) + item1012 = _t1810 + push!(xs1010, item1012) + cond1011 = ((((((((((((((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_terms1013 = xs1010 consume_literal!(parser, ")") - _t1805 = Proto.RelAtom(name=name1006, terms=rel_terms1010) - result1012 = _t1805 - record_span!(parser, span_start1011, "RelAtom") - return result1012 + _t1811 = Proto.RelAtom(name=name1009, terms=rel_terms1013) + result1015 = _t1811 + record_span!(parser, span_start1014, "RelAtom") + return result1015 end function parse_cast(parser::ParserState)::Proto.Cast - span_start1015 = span_start(parser) + span_start1018 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1806 = parse_term(parser) - term1013 = _t1806 - _t1807 = parse_term(parser) - term_31014 = _t1807 + _t1812 = parse_term(parser) + term1016 = _t1812 + _t1813 = parse_term(parser) + term_31017 = _t1813 consume_literal!(parser, ")") - _t1808 = Proto.Cast(input=term1013, result=term_31014) - result1016 = _t1808 - record_span!(parser, span_start1015, "Cast") - return result1016 + _t1814 = Proto.Cast(input=term1016, result=term_31017) + result1019 = _t1814 + record_span!(parser, span_start1018, "Cast") + return result1019 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs1017 = Proto.Attribute[] - cond1018 = match_lookahead_literal(parser, "(", 0) - while cond1018 - _t1809 = parse_attribute(parser) - item1019 = _t1809 - push!(xs1017, item1019) - cond1018 = match_lookahead_literal(parser, "(", 0) - end - attributes1020 = xs1017 + xs1020 = Proto.Attribute[] + cond1021 = match_lookahead_literal(parser, "(", 0) + while cond1021 + _t1815 = parse_attribute(parser) + item1022 = _t1815 + push!(xs1020, item1022) + cond1021 = match_lookahead_literal(parser, "(", 0) + end + attributes1023 = xs1020 consume_literal!(parser, ")") - return attributes1020 + return attributes1023 end function parse_attribute(parser::ParserState)::Proto.Attribute - span_start1026 = span_start(parser) + span_start1029 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1810 = parse_name(parser) - name1021 = _t1810 - xs1022 = Proto.Value[] - cond1023 = ((((((((((((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 cond1023 - _t1811 = parse_raw_value(parser) - item1024 = _t1811 - push!(xs1022, item1024) - cond1023 = ((((((((((((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_values1025 = xs1022 + _t1816 = parse_name(parser) + name1024 = _t1816 + xs1025 = Proto.Value[] + cond1026 = ((((((((((((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 cond1026 + _t1817 = parse_raw_value(parser) + item1027 = _t1817 + push!(xs1025, item1027) + cond1026 = ((((((((((((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_values1028 = xs1025 consume_literal!(parser, ")") - _t1812 = Proto.Attribute(name=name1021, args=raw_values1025) - result1027 = _t1812 - record_span!(parser, span_start1026, "Attribute") - return result1027 + _t1818 = Proto.Attribute(name=name1024, args=raw_values1028) + result1030 = _t1818 + record_span!(parser, span_start1029, "Attribute") + return result1030 end function parse_algorithm(parser::ParserState)::Proto.Algorithm - span_start1034 = span_start(parser) + span_start1037 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs1028 = Proto.RelationId[] - cond1029 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1029 - _t1813 = parse_relation_id(parser) - item1030 = _t1813 - push!(xs1028, item1030) - cond1029 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1031 = xs1028 - _t1814 = parse_script(parser) - script1032 = _t1814 + xs1031 = Proto.RelationId[] + cond1032 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1032 + _t1819 = parse_relation_id(parser) + item1033 = _t1819 + push!(xs1031, item1033) + cond1032 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1034 = xs1031 + _t1820 = parse_script(parser) + script1035 = _t1820 if match_lookahead_literal(parser, "(", 0) - _t1816 = parse_attrs(parser) - _t1815 = _t1816 + _t1822 = parse_attrs(parser) + _t1821 = _t1822 else - _t1815 = nothing + _t1821 = nothing end - attrs1033 = _t1815 + attrs1036 = _t1821 consume_literal!(parser, ")") - _t1817 = Proto.Algorithm(var"#global"=relation_ids1031, body=script1032, attrs=(!isnothing(attrs1033) ? attrs1033 : Proto.Attribute[])) - result1035 = _t1817 - record_span!(parser, span_start1034, "Algorithm") - return result1035 + _t1823 = Proto.Algorithm(var"#global"=relation_ids1034, body=script1035, attrs=(!isnothing(attrs1036) ? attrs1036 : Proto.Attribute[])) + result1038 = _t1823 + record_span!(parser, span_start1037, "Algorithm") + return result1038 end function parse_script(parser::ParserState)::Proto.Script - span_start1040 = span_start(parser) + span_start1043 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "script") - xs1036 = Proto.Construct[] - cond1037 = match_lookahead_literal(parser, "(", 0) - while cond1037 - _t1818 = parse_construct(parser) - item1038 = _t1818 - push!(xs1036, item1038) - cond1037 = match_lookahead_literal(parser, "(", 0) - end - constructs1039 = xs1036 + xs1039 = Proto.Construct[] + cond1040 = match_lookahead_literal(parser, "(", 0) + while cond1040 + _t1824 = parse_construct(parser) + item1041 = _t1824 + push!(xs1039, item1041) + cond1040 = match_lookahead_literal(parser, "(", 0) + end + constructs1042 = xs1039 consume_literal!(parser, ")") - _t1819 = Proto.Script(constructs=constructs1039) - result1041 = _t1819 - record_span!(parser, span_start1040, "Script") - return result1041 + _t1825 = Proto.Script(constructs=constructs1042) + result1044 = _t1825 + record_span!(parser, span_start1043, "Script") + return result1044 end function parse_construct(parser::ParserState)::Proto.Construct - span_start1045 = span_start(parser) + span_start1048 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1821 = 1 + _t1827 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1822 = 1 + _t1828 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1823 = 1 + _t1829 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1824 = 0 + _t1830 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1825 = 1 + _t1831 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1826 = 1 + _t1832 = 1 else - _t1826 = -1 + _t1832 = -1 end - _t1825 = _t1826 + _t1831 = _t1832 end - _t1824 = _t1825 + _t1830 = _t1831 end - _t1823 = _t1824 + _t1829 = _t1830 end - _t1822 = _t1823 + _t1828 = _t1829 end - _t1821 = _t1822 + _t1827 = _t1828 end - _t1820 = _t1821 + _t1826 = _t1827 else - _t1820 = -1 - end - prediction1042 = _t1820 - if prediction1042 == 1 - _t1828 = parse_instruction(parser) - instruction1044 = _t1828 - _t1829 = Proto.Construct(construct_type=OneOf(:instruction, instruction1044)) - _t1827 = _t1829 + _t1826 = -1 + end + prediction1045 = _t1826 + if prediction1045 == 1 + _t1834 = parse_instruction(parser) + instruction1047 = _t1834 + _t1835 = Proto.Construct(construct_type=OneOf(:instruction, instruction1047)) + _t1833 = _t1835 else - if prediction1042 == 0 - _t1831 = parse_loop(parser) - loop1043 = _t1831 - _t1832 = Proto.Construct(construct_type=OneOf(:loop, loop1043)) - _t1830 = _t1832 + if prediction1045 == 0 + _t1837 = parse_loop(parser) + loop1046 = _t1837 + _t1838 = Proto.Construct(construct_type=OneOf(:loop, loop1046)) + _t1836 = _t1838 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1827 = _t1830 + _t1833 = _t1836 end - result1046 = _t1827 - record_span!(parser, span_start1045, "Construct") - return result1046 + result1049 = _t1833 + record_span!(parser, span_start1048, "Construct") + return result1049 end function parse_loop(parser::ParserState)::Proto.Loop - span_start1050 = span_start(parser) + span_start1053 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1833 = parse_init(parser) - init1047 = _t1833 - _t1834 = parse_script(parser) - script1048 = _t1834 + _t1839 = parse_init(parser) + init1050 = _t1839 + _t1840 = parse_script(parser) + script1051 = _t1840 if match_lookahead_literal(parser, "(", 0) - _t1836 = parse_attrs(parser) - _t1835 = _t1836 + _t1842 = parse_attrs(parser) + _t1841 = _t1842 else - _t1835 = nothing + _t1841 = nothing end - attrs1049 = _t1835 + attrs1052 = _t1841 consume_literal!(parser, ")") - _t1837 = Proto.Loop(init=init1047, body=script1048, attrs=(!isnothing(attrs1049) ? attrs1049 : Proto.Attribute[])) - result1051 = _t1837 - record_span!(parser, span_start1050, "Loop") - return result1051 + _t1843 = Proto.Loop(init=init1050, body=script1051, attrs=(!isnothing(attrs1052) ? attrs1052 : Proto.Attribute[])) + result1054 = _t1843 + record_span!(parser, span_start1053, "Loop") + return result1054 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs1052 = Proto.Instruction[] - cond1053 = match_lookahead_literal(parser, "(", 0) - while cond1053 - _t1838 = parse_instruction(parser) - item1054 = _t1838 - push!(xs1052, item1054) - cond1053 = match_lookahead_literal(parser, "(", 0) - end - instructions1055 = xs1052 + xs1055 = Proto.Instruction[] + cond1056 = match_lookahead_literal(parser, "(", 0) + while cond1056 + _t1844 = parse_instruction(parser) + item1057 = _t1844 + push!(xs1055, item1057) + cond1056 = match_lookahead_literal(parser, "(", 0) + end + instructions1058 = xs1055 consume_literal!(parser, ")") - return instructions1055 + return instructions1058 end function parse_instruction(parser::ParserState)::Proto.Instruction - span_start1062 = span_start(parser) + span_start1065 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1840 = 1 + _t1846 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1841 = 4 + _t1847 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1842 = 3 + _t1848 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1843 = 2 + _t1849 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1844 = 0 + _t1850 = 0 else - _t1844 = -1 + _t1850 = -1 end - _t1843 = _t1844 + _t1849 = _t1850 end - _t1842 = _t1843 + _t1848 = _t1849 end - _t1841 = _t1842 + _t1847 = _t1848 end - _t1840 = _t1841 + _t1846 = _t1847 end - _t1839 = _t1840 + _t1845 = _t1846 else - _t1839 = -1 - end - prediction1056 = _t1839 - if prediction1056 == 4 - _t1846 = parse_monus_def(parser) - monus_def1061 = _t1846 - _t1847 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1061)) - _t1845 = _t1847 + _t1845 = -1 + end + prediction1059 = _t1845 + if prediction1059 == 4 + _t1852 = parse_monus_def(parser) + monus_def1064 = _t1852 + _t1853 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1064)) + _t1851 = _t1853 else - if prediction1056 == 3 - _t1849 = parse_monoid_def(parser) - monoid_def1060 = _t1849 - _t1850 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1060)) - _t1848 = _t1850 + if prediction1059 == 3 + _t1855 = parse_monoid_def(parser) + monoid_def1063 = _t1855 + _t1856 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1063)) + _t1854 = _t1856 else - if prediction1056 == 2 - _t1852 = parse_break(parser) - break1059 = _t1852 - _t1853 = Proto.Instruction(instr_type=OneOf(:var"#break", break1059)) - _t1851 = _t1853 + if prediction1059 == 2 + _t1858 = parse_break(parser) + break1062 = _t1858 + _t1859 = Proto.Instruction(instr_type=OneOf(:var"#break", break1062)) + _t1857 = _t1859 else - if prediction1056 == 1 - _t1855 = parse_upsert(parser) - upsert1058 = _t1855 - _t1856 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1058)) - _t1854 = _t1856 + if prediction1059 == 1 + _t1861 = parse_upsert(parser) + upsert1061 = _t1861 + _t1862 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1061)) + _t1860 = _t1862 else - if prediction1056 == 0 - _t1858 = parse_assign(parser) - assign1057 = _t1858 - _t1859 = Proto.Instruction(instr_type=OneOf(:assign, assign1057)) - _t1857 = _t1859 + if prediction1059 == 0 + _t1864 = parse_assign(parser) + assign1060 = _t1864 + _t1865 = Proto.Instruction(instr_type=OneOf(:assign, assign1060)) + _t1863 = _t1865 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1854 = _t1857 + _t1860 = _t1863 end - _t1851 = _t1854 + _t1857 = _t1860 end - _t1848 = _t1851 + _t1854 = _t1857 end - _t1845 = _t1848 + _t1851 = _t1854 end - result1063 = _t1845 - record_span!(parser, span_start1062, "Instruction") - return result1063 + result1066 = _t1851 + record_span!(parser, span_start1065, "Instruction") + return result1066 end function parse_assign(parser::ParserState)::Proto.Assign - span_start1067 = span_start(parser) + span_start1070 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1860 = parse_relation_id(parser) - relation_id1064 = _t1860 - _t1861 = parse_abstraction(parser) - abstraction1065 = _t1861 + _t1866 = parse_relation_id(parser) + relation_id1067 = _t1866 + _t1867 = parse_abstraction(parser) + abstraction1068 = _t1867 if match_lookahead_literal(parser, "(", 0) - _t1863 = parse_attrs(parser) - _t1862 = _t1863 + _t1869 = parse_attrs(parser) + _t1868 = _t1869 else - _t1862 = nothing + _t1868 = nothing end - attrs1066 = _t1862 + attrs1069 = _t1868 consume_literal!(parser, ")") - _t1864 = Proto.Assign(name=relation_id1064, body=abstraction1065, attrs=(!isnothing(attrs1066) ? attrs1066 : Proto.Attribute[])) - result1068 = _t1864 - record_span!(parser, span_start1067, "Assign") - return result1068 + _t1870 = Proto.Assign(name=relation_id1067, body=abstraction1068, attrs=(!isnothing(attrs1069) ? attrs1069 : Proto.Attribute[])) + result1071 = _t1870 + record_span!(parser, span_start1070, "Assign") + return result1071 end function parse_upsert(parser::ParserState)::Proto.Upsert - span_start1072 = span_start(parser) + span_start1075 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1865 = parse_relation_id(parser) - relation_id1069 = _t1865 - _t1866 = parse_abstraction_with_arity(parser) - abstraction_with_arity1070 = _t1866 + _t1871 = parse_relation_id(parser) + relation_id1072 = _t1871 + _t1872 = parse_abstraction_with_arity(parser) + abstraction_with_arity1073 = _t1872 if match_lookahead_literal(parser, "(", 0) - _t1868 = parse_attrs(parser) - _t1867 = _t1868 + _t1874 = parse_attrs(parser) + _t1873 = _t1874 else - _t1867 = nothing + _t1873 = nothing end - attrs1071 = _t1867 + attrs1074 = _t1873 consume_literal!(parser, ")") - _t1869 = Proto.Upsert(name=relation_id1069, body=abstraction_with_arity1070[1], attrs=(!isnothing(attrs1071) ? attrs1071 : Proto.Attribute[]), value_arity=abstraction_with_arity1070[2]) - result1073 = _t1869 - record_span!(parser, span_start1072, "Upsert") - return result1073 + _t1875 = Proto.Upsert(name=relation_id1072, body=abstraction_with_arity1073[1], attrs=(!isnothing(attrs1074) ? attrs1074 : Proto.Attribute[]), value_arity=abstraction_with_arity1073[2]) + result1076 = _t1875 + record_span!(parser, span_start1075, "Upsert") + return result1076 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1870 = parse_bindings(parser) - bindings1074 = _t1870 - _t1871 = parse_formula(parser) - formula1075 = _t1871 + _t1876 = parse_bindings(parser) + bindings1077 = _t1876 + _t1877 = parse_formula(parser) + formula1078 = _t1877 consume_literal!(parser, ")") - _t1872 = Proto.Abstraction(vars=vcat(bindings1074[1], !isnothing(bindings1074[2]) ? bindings1074[2] : []), value=formula1075) - return (_t1872, length(bindings1074[2]),) + _t1878 = Proto.Abstraction(vars=vcat(bindings1077[1], !isnothing(bindings1077[2]) ? bindings1077[2] : []), value=formula1078) + return (_t1878, length(bindings1077[2]),) end function parse_break(parser::ParserState)::Proto.Break - span_start1079 = span_start(parser) + span_start1082 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1873 = parse_relation_id(parser) - relation_id1076 = _t1873 - _t1874 = parse_abstraction(parser) - abstraction1077 = _t1874 + _t1879 = parse_relation_id(parser) + relation_id1079 = _t1879 + _t1880 = parse_abstraction(parser) + abstraction1080 = _t1880 if match_lookahead_literal(parser, "(", 0) - _t1876 = parse_attrs(parser) - _t1875 = _t1876 + _t1882 = parse_attrs(parser) + _t1881 = _t1882 else - _t1875 = nothing + _t1881 = nothing end - attrs1078 = _t1875 + attrs1081 = _t1881 consume_literal!(parser, ")") - _t1877 = Proto.Break(name=relation_id1076, body=abstraction1077, attrs=(!isnothing(attrs1078) ? attrs1078 : Proto.Attribute[])) - result1080 = _t1877 - record_span!(parser, span_start1079, "Break") - return result1080 + _t1883 = Proto.Break(name=relation_id1079, body=abstraction1080, attrs=(!isnothing(attrs1081) ? attrs1081 : Proto.Attribute[])) + result1083 = _t1883 + record_span!(parser, span_start1082, "Break") + return result1083 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef - span_start1085 = span_start(parser) + span_start1088 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1878 = parse_monoid(parser) - monoid1081 = _t1878 - _t1879 = parse_relation_id(parser) - relation_id1082 = _t1879 - _t1880 = parse_abstraction_with_arity(parser) - abstraction_with_arity1083 = _t1880 + _t1884 = parse_monoid(parser) + monoid1084 = _t1884 + _t1885 = parse_relation_id(parser) + relation_id1085 = _t1885 + _t1886 = parse_abstraction_with_arity(parser) + abstraction_with_arity1086 = _t1886 if match_lookahead_literal(parser, "(", 0) - _t1882 = parse_attrs(parser) - _t1881 = _t1882 + _t1888 = parse_attrs(parser) + _t1887 = _t1888 else - _t1881 = nothing + _t1887 = nothing end - attrs1084 = _t1881 + attrs1087 = _t1887 consume_literal!(parser, ")") - _t1883 = Proto.MonoidDef(monoid=monoid1081, name=relation_id1082, body=abstraction_with_arity1083[1], attrs=(!isnothing(attrs1084) ? attrs1084 : Proto.Attribute[]), value_arity=abstraction_with_arity1083[2]) - result1086 = _t1883 - record_span!(parser, span_start1085, "MonoidDef") - return result1086 + _t1889 = Proto.MonoidDef(monoid=monoid1084, name=relation_id1085, body=abstraction_with_arity1086[1], attrs=(!isnothing(attrs1087) ? attrs1087 : Proto.Attribute[]), value_arity=abstraction_with_arity1086[2]) + result1089 = _t1889 + record_span!(parser, span_start1088, "MonoidDef") + return result1089 end function parse_monoid(parser::ParserState)::Proto.Monoid - span_start1092 = span_start(parser) + span_start1095 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1885 = 3 + _t1891 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1886 = 0 + _t1892 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1887 = 1 + _t1893 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1888 = 2 + _t1894 = 2 else - _t1888 = -1 + _t1894 = -1 end - _t1887 = _t1888 + _t1893 = _t1894 end - _t1886 = _t1887 + _t1892 = _t1893 end - _t1885 = _t1886 + _t1891 = _t1892 end - _t1884 = _t1885 + _t1890 = _t1891 else - _t1884 = -1 - end - prediction1087 = _t1884 - if prediction1087 == 3 - _t1890 = parse_sum_monoid(parser) - sum_monoid1091 = _t1890 - _t1891 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1091)) - _t1889 = _t1891 + _t1890 = -1 + end + prediction1090 = _t1890 + if prediction1090 == 3 + _t1896 = parse_sum_monoid(parser) + sum_monoid1094 = _t1896 + _t1897 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1094)) + _t1895 = _t1897 else - if prediction1087 == 2 - _t1893 = parse_max_monoid(parser) - max_monoid1090 = _t1893 - _t1894 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1090)) - _t1892 = _t1894 + if prediction1090 == 2 + _t1899 = parse_max_monoid(parser) + max_monoid1093 = _t1899 + _t1900 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1093)) + _t1898 = _t1900 else - if prediction1087 == 1 - _t1896 = parse_min_monoid(parser) - min_monoid1089 = _t1896 - _t1897 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1089)) - _t1895 = _t1897 + if prediction1090 == 1 + _t1902 = parse_min_monoid(parser) + min_monoid1092 = _t1902 + _t1903 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1092)) + _t1901 = _t1903 else - if prediction1087 == 0 - _t1899 = parse_or_monoid(parser) - or_monoid1088 = _t1899 - _t1900 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1088)) - _t1898 = _t1900 + if prediction1090 == 0 + _t1905 = parse_or_monoid(parser) + or_monoid1091 = _t1905 + _t1906 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1091)) + _t1904 = _t1906 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1895 = _t1898 + _t1901 = _t1904 end - _t1892 = _t1895 + _t1898 = _t1901 end - _t1889 = _t1892 + _t1895 = _t1898 end - result1093 = _t1889 - record_span!(parser, span_start1092, "Monoid") - return result1093 + result1096 = _t1895 + record_span!(parser, span_start1095, "Monoid") + return result1096 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid - span_start1094 = span_start(parser) + span_start1097 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1901 = Proto.OrMonoid() - result1095 = _t1901 - record_span!(parser, span_start1094, "OrMonoid") - return result1095 + _t1907 = Proto.OrMonoid() + result1098 = _t1907 + record_span!(parser, span_start1097, "OrMonoid") + return result1098 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid - span_start1097 = span_start(parser) + span_start1100 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1902 = parse_type(parser) - type1096 = _t1902 + _t1908 = parse_type(parser) + type1099 = _t1908 consume_literal!(parser, ")") - _t1903 = Proto.MinMonoid(var"#type"=type1096) - result1098 = _t1903 - record_span!(parser, span_start1097, "MinMonoid") - return result1098 + _t1909 = Proto.MinMonoid(var"#type"=type1099) + result1101 = _t1909 + record_span!(parser, span_start1100, "MinMonoid") + return result1101 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid - span_start1100 = span_start(parser) + span_start1103 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1904 = parse_type(parser) - type1099 = _t1904 + _t1910 = parse_type(parser) + type1102 = _t1910 consume_literal!(parser, ")") - _t1905 = Proto.MaxMonoid(var"#type"=type1099) - result1101 = _t1905 - record_span!(parser, span_start1100, "MaxMonoid") - return result1101 + _t1911 = Proto.MaxMonoid(var"#type"=type1102) + result1104 = _t1911 + record_span!(parser, span_start1103, "MaxMonoid") + return result1104 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid - span_start1103 = span_start(parser) + span_start1106 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1906 = parse_type(parser) - type1102 = _t1906 + _t1912 = parse_type(parser) + type1105 = _t1912 consume_literal!(parser, ")") - _t1907 = Proto.SumMonoid(var"#type"=type1102) - result1104 = _t1907 - record_span!(parser, span_start1103, "SumMonoid") - return result1104 + _t1913 = Proto.SumMonoid(var"#type"=type1105) + result1107 = _t1913 + record_span!(parser, span_start1106, "SumMonoid") + return result1107 end function parse_monus_def(parser::ParserState)::Proto.MonusDef - span_start1109 = span_start(parser) + span_start1112 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1908 = parse_monoid(parser) - monoid1105 = _t1908 - _t1909 = parse_relation_id(parser) - relation_id1106 = _t1909 - _t1910 = parse_abstraction_with_arity(parser) - abstraction_with_arity1107 = _t1910 + _t1914 = parse_monoid(parser) + monoid1108 = _t1914 + _t1915 = parse_relation_id(parser) + relation_id1109 = _t1915 + _t1916 = parse_abstraction_with_arity(parser) + abstraction_with_arity1110 = _t1916 if match_lookahead_literal(parser, "(", 0) - _t1912 = parse_attrs(parser) - _t1911 = _t1912 + _t1918 = parse_attrs(parser) + _t1917 = _t1918 else - _t1911 = nothing + _t1917 = nothing end - attrs1108 = _t1911 + attrs1111 = _t1917 consume_literal!(parser, ")") - _t1913 = Proto.MonusDef(monoid=monoid1105, name=relation_id1106, body=abstraction_with_arity1107[1], attrs=(!isnothing(attrs1108) ? attrs1108 : Proto.Attribute[]), value_arity=abstraction_with_arity1107[2]) - result1110 = _t1913 - record_span!(parser, span_start1109, "MonusDef") - return result1110 + _t1919 = Proto.MonusDef(monoid=monoid1108, name=relation_id1109, body=abstraction_with_arity1110[1], attrs=(!isnothing(attrs1111) ? attrs1111 : Proto.Attribute[]), value_arity=abstraction_with_arity1110[2]) + result1113 = _t1919 + record_span!(parser, span_start1112, "MonusDef") + return result1113 end function parse_constraint(parser::ParserState)::Proto.Constraint - span_start1115 = span_start(parser) + span_start1118 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1914 = parse_relation_id(parser) - relation_id1111 = _t1914 - _t1915 = parse_abstraction(parser) - abstraction1112 = _t1915 - _t1916 = parse_functional_dependency_keys(parser) - functional_dependency_keys1113 = _t1916 - _t1917 = parse_functional_dependency_values(parser) - functional_dependency_values1114 = _t1917 + _t1920 = parse_relation_id(parser) + relation_id1114 = _t1920 + _t1921 = parse_abstraction(parser) + abstraction1115 = _t1921 + _t1922 = parse_functional_dependency_keys(parser) + functional_dependency_keys1116 = _t1922 + _t1923 = parse_functional_dependency_values(parser) + functional_dependency_values1117 = _t1923 consume_literal!(parser, ")") - _t1918 = Proto.FunctionalDependency(guard=abstraction1112, keys=functional_dependency_keys1113, values=functional_dependency_values1114) - _t1919 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1918), name=relation_id1111) - result1116 = _t1919 - record_span!(parser, span_start1115, "Constraint") - return result1116 + _t1924 = Proto.FunctionalDependency(guard=abstraction1115, keys=functional_dependency_keys1116, values=functional_dependency_values1117) + _t1925 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1924), name=relation_id1114) + result1119 = _t1925 + record_span!(parser, span_start1118, "Constraint") + return result1119 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1117 = Proto.Var[] - cond1118 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1118 - _t1920 = parse_var(parser) - item1119 = _t1920 - push!(xs1117, item1119) - cond1118 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1120 = xs1117 + xs1120 = Proto.Var[] + cond1121 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1121 + _t1926 = parse_var(parser) + item1122 = _t1926 + push!(xs1120, item1122) + cond1121 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1123 = xs1120 consume_literal!(parser, ")") - return vars1120 + return vars1123 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs1121 = Proto.Var[] - cond1122 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1122 - _t1921 = parse_var(parser) - item1123 = _t1921 - push!(xs1121, item1123) - cond1122 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1124 = xs1121 + xs1124 = Proto.Var[] + cond1125 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1125 + _t1927 = parse_var(parser) + item1126 = _t1927 + push!(xs1124, item1126) + cond1125 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1127 = xs1124 consume_literal!(parser, ")") - return vars1124 + return vars1127 end function parse_data(parser::ParserState)::Proto.Data - span_start1130 = span_start(parser) + span_start1133 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1923 = 3 + _t1929 = 3 else if match_lookahead_literal(parser, "edb", 1) - _t1924 = 0 + _t1930 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1925 = 2 + _t1931 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1926 = 1 + _t1932 = 1 else - _t1926 = -1 + _t1932 = -1 end - _t1925 = _t1926 + _t1931 = _t1932 end - _t1924 = _t1925 + _t1930 = _t1931 end - _t1923 = _t1924 + _t1929 = _t1930 end - _t1922 = _t1923 + _t1928 = _t1929 else - _t1922 = -1 - end - prediction1125 = _t1922 - if prediction1125 == 3 - _t1928 = parse_iceberg_data(parser) - iceberg_data1129 = _t1928 - _t1929 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1129)) - _t1927 = _t1929 + _t1928 = -1 + end + prediction1128 = _t1928 + if prediction1128 == 3 + _t1934 = parse_iceberg_data(parser) + iceberg_data1132 = _t1934 + _t1935 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1132)) + _t1933 = _t1935 else - if prediction1125 == 2 - _t1931 = parse_csv_data(parser) - csv_data1128 = _t1931 - _t1932 = Proto.Data(data_type=OneOf(:csv_data, csv_data1128)) - _t1930 = _t1932 + if prediction1128 == 2 + _t1937 = parse_csv_data(parser) + csv_data1131 = _t1937 + _t1938 = Proto.Data(data_type=OneOf(:csv_data, csv_data1131)) + _t1936 = _t1938 else - if prediction1125 == 1 - _t1934 = parse_betree_relation(parser) - betree_relation1127 = _t1934 - _t1935 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1127)) - _t1933 = _t1935 + if prediction1128 == 1 + _t1940 = parse_betree_relation(parser) + betree_relation1130 = _t1940 + _t1941 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1130)) + _t1939 = _t1941 else - if prediction1125 == 0 - _t1937 = parse_edb(parser) - edb1126 = _t1937 - _t1938 = Proto.Data(data_type=OneOf(:edb, edb1126)) - _t1936 = _t1938 + if prediction1128 == 0 + _t1943 = parse_edb(parser) + edb1129 = _t1943 + _t1944 = Proto.Data(data_type=OneOf(:edb, edb1129)) + _t1942 = _t1944 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t1933 = _t1936 + _t1939 = _t1942 end - _t1930 = _t1933 + _t1936 = _t1939 end - _t1927 = _t1930 + _t1933 = _t1936 end - result1131 = _t1927 - record_span!(parser, span_start1130, "Data") - return result1131 + result1134 = _t1933 + record_span!(parser, span_start1133, "Data") + return result1134 end function parse_edb(parser::ParserState)::Proto.EDB - span_start1135 = span_start(parser) + span_start1138 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "edb") - _t1939 = parse_relation_id(parser) - relation_id1132 = _t1939 - _t1940 = parse_edb_path(parser) - edb_path1133 = _t1940 - _t1941 = parse_edb_types(parser) - edb_types1134 = _t1941 + _t1945 = parse_relation_id(parser) + relation_id1135 = _t1945 + _t1946 = parse_edb_path(parser) + edb_path1136 = _t1946 + _t1947 = parse_edb_types(parser) + edb_types1137 = _t1947 consume_literal!(parser, ")") - _t1942 = Proto.EDB(target_id=relation_id1132, path=edb_path1133, types=edb_types1134) - result1136 = _t1942 - record_span!(parser, span_start1135, "EDB") - return result1136 + _t1948 = Proto.EDB(target_id=relation_id1135, path=edb_path1136, types=edb_types1137) + result1139 = _t1948 + record_span!(parser, span_start1138, "EDB") + return result1139 end function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs1137 = String[] - cond1138 = match_lookahead_terminal(parser, "STRING", 0) - while cond1138 - item1139 = consume_terminal!(parser, "STRING") - push!(xs1137, item1139) - cond1138 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1140 = xs1137 + xs1140 = String[] + cond1141 = match_lookahead_terminal(parser, "STRING", 0) + while cond1141 + item1142 = consume_terminal!(parser, "STRING") + push!(xs1140, item1142) + cond1141 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1143 = xs1140 consume_literal!(parser, "]") - return strings1140 + return strings1143 end function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs1141 = Proto.var"#Type"[] - cond1142 = (((((((((((((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 cond1142 - _t1943 = parse_type(parser) - item1143 = _t1943 - push!(xs1141, item1143) - cond1142 = (((((((((((((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 - types1144 = xs1141 + xs1144 = Proto.var"#Type"[] + cond1145 = (((((((((((((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 cond1145 + _t1949 = parse_type(parser) + item1146 = _t1949 + push!(xs1144, item1146) + cond1145 = (((((((((((((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 + types1147 = xs1144 consume_literal!(parser, "]") - return types1144 + return types1147 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation - span_start1147 = span_start(parser) + span_start1150 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t1944 = parse_relation_id(parser) - relation_id1145 = _t1944 - _t1945 = parse_betree_info(parser) - betree_info1146 = _t1945 + _t1950 = parse_relation_id(parser) + relation_id1148 = _t1950 + _t1951 = parse_betree_info(parser) + betree_info1149 = _t1951 consume_literal!(parser, ")") - _t1946 = Proto.BeTreeRelation(name=relation_id1145, relation_info=betree_info1146) - result1148 = _t1946 - record_span!(parser, span_start1147, "BeTreeRelation") - return result1148 + _t1952 = Proto.BeTreeRelation(name=relation_id1148, relation_info=betree_info1149) + result1151 = _t1952 + record_span!(parser, span_start1150, "BeTreeRelation") + return result1151 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo - span_start1152 = span_start(parser) + span_start1155 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t1947 = parse_betree_info_key_types(parser) - betree_info_key_types1149 = _t1947 - _t1948 = parse_betree_info_value_types(parser) - betree_info_value_types1150 = _t1948 - _t1949 = parse_config_dict(parser) - config_dict1151 = _t1949 + _t1953 = parse_betree_info_key_types(parser) + betree_info_key_types1152 = _t1953 + _t1954 = parse_betree_info_value_types(parser) + betree_info_value_types1153 = _t1954 + _t1955 = parse_config_dict(parser) + config_dict1154 = _t1955 consume_literal!(parser, ")") - _t1950 = construct_betree_info(parser, betree_info_key_types1149, betree_info_value_types1150, config_dict1151) - result1153 = _t1950 - record_span!(parser, span_start1152, "BeTreeInfo") - return result1153 + _t1956 = construct_betree_info(parser, betree_info_key_types1152, betree_info_value_types1153, config_dict1154) + result1156 = _t1956 + record_span!(parser, span_start1155, "BeTreeInfo") + return result1156 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - xs1154 = Proto.var"#Type"[] - cond1155 = (((((((((((((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 cond1155 - _t1951 = parse_type(parser) - item1156 = _t1951 - push!(xs1154, item1156) - cond1155 = (((((((((((((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 - types1157 = xs1154 + xs1157 = Proto.var"#Type"[] + cond1158 = (((((((((((((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 cond1158 + _t1957 = parse_type(parser) + item1159 = _t1957 + push!(xs1157, item1159) + cond1158 = (((((((((((((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 + types1160 = xs1157 consume_literal!(parser, ")") - return types1157 + return types1160 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs1158 = Proto.var"#Type"[] - cond1159 = (((((((((((((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 cond1159 - _t1952 = parse_type(parser) - item1160 = _t1952 - push!(xs1158, item1160) - cond1159 = (((((((((((((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 - types1161 = xs1158 + xs1161 = Proto.var"#Type"[] + cond1162 = (((((((((((((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 cond1162 + _t1958 = parse_type(parser) + item1163 = _t1958 + push!(xs1161, item1163) + cond1162 = (((((((((((((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 + types1164 = xs1161 consume_literal!(parser, ")") - return types1161 + return types1164 end function parse_csv_data(parser::ParserState)::Proto.CSVData - span_start1166 = span_start(parser) + span_start1169 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t1953 = parse_csvlocator(parser) - csvlocator1162 = _t1953 - _t1954 = parse_csv_config(parser) - csv_config1163 = _t1954 - _t1955 = parse_gnf_columns(parser) - gnf_columns1164 = _t1955 - _t1956 = parse_csv_asof(parser) - csv_asof1165 = _t1956 + _t1959 = parse_csvlocator(parser) + csvlocator1165 = _t1959 + _t1960 = parse_csv_config(parser) + csv_config1166 = _t1960 + _t1961 = parse_gnf_columns(parser) + gnf_columns1167 = _t1961 + _t1962 = parse_csv_asof(parser) + csv_asof1168 = _t1962 consume_literal!(parser, ")") - _t1957 = Proto.CSVData(locator=csvlocator1162, config=csv_config1163, columns=gnf_columns1164, asof=csv_asof1165) - result1167 = _t1957 - record_span!(parser, span_start1166, "CSVData") - return result1167 + _t1963 = Proto.CSVData(locator=csvlocator1165, config=csv_config1166, columns=gnf_columns1167, asof=csv_asof1168) + result1170 = _t1963 + record_span!(parser, span_start1169, "CSVData") + return result1170 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator - span_start1170 = span_start(parser) + span_start1173 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t1959 = parse_csv_locator_paths(parser) - _t1958 = _t1959 + _t1965 = parse_csv_locator_paths(parser) + _t1964 = _t1965 else - _t1958 = nothing + _t1964 = nothing end - csv_locator_paths1168 = _t1958 + csv_locator_paths1171 = _t1964 if match_lookahead_literal(parser, "(", 0) - _t1961 = parse_csv_locator_inline_data(parser) - _t1960 = _t1961 + _t1967 = parse_csv_locator_inline_data(parser) + _t1966 = _t1967 else - _t1960 = nothing + _t1966 = nothing end - csv_locator_inline_data1169 = _t1960 + csv_locator_inline_data1172 = _t1966 consume_literal!(parser, ")") - _t1962 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1168) ? csv_locator_paths1168 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1169) ? csv_locator_inline_data1169 : ""))) - result1171 = _t1962 - record_span!(parser, span_start1170, "CSVLocator") - return result1171 + _t1968 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1171) ? csv_locator_paths1171 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1172) ? csv_locator_inline_data1172 : ""))) + result1174 = _t1968 + record_span!(parser, span_start1173, "CSVLocator") + return result1174 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs1172 = String[] - cond1173 = match_lookahead_terminal(parser, "STRING", 0) - while cond1173 - item1174 = consume_terminal!(parser, "STRING") - push!(xs1172, item1174) - cond1173 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1175 = xs1172 + xs1175 = String[] + cond1176 = match_lookahead_terminal(parser, "STRING", 0) + while cond1176 + item1177 = consume_terminal!(parser, "STRING") + push!(xs1175, item1177) + cond1176 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1178 = xs1175 consume_literal!(parser, ")") - return strings1175 + return strings1178 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - formatted_string1176 = consume_terminal!(parser, "STRING") + formatted_string1179 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return formatted_string1176 + return formatted_string1179 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig - span_start1179 = span_start(parser) + span_start1182 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t1963 = parse_config_dict(parser) - config_dict1177 = _t1963 + _t1969 = parse_config_dict(parser) + config_dict1180 = _t1969 if match_lookahead_literal(parser, "(", 0) - _t1965 = parse__storage_integration(parser) - _t1964 = _t1965 + _t1971 = parse__storage_integration(parser) + _t1970 = _t1971 else - _t1964 = nothing + _t1970 = nothing end - _storage_integration1178 = _t1964 + _storage_integration1181 = _t1970 consume_literal!(parser, ")") - _t1966 = construct_csv_config(parser, config_dict1177, _storage_integration1178) - result1180 = _t1966 - record_span!(parser, span_start1179, "CSVConfig") - return result1180 + _t1972 = construct_csv_config(parser, config_dict1180, _storage_integration1181) + result1183 = _t1972 + record_span!(parser, span_start1182, "CSVConfig") + return result1183 end function parse__storage_integration(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "(") consume_literal!(parser, "storage_integration") - _t1967 = parse_config_dict(parser) - config_dict1181 = _t1967 + _t1973 = parse_config_dict(parser) + config_dict1184 = _t1973 consume_literal!(parser, ")") - return config_dict1181 + return config_dict1184 end function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1182 = Proto.GNFColumn[] - cond1183 = match_lookahead_literal(parser, "(", 0) - while cond1183 - _t1968 = parse_gnf_column(parser) - item1184 = _t1968 - push!(xs1182, item1184) - cond1183 = match_lookahead_literal(parser, "(", 0) - end - gnf_columns1185 = xs1182 + xs1185 = Proto.GNFColumn[] + cond1186 = match_lookahead_literal(parser, "(", 0) + while cond1186 + _t1974 = parse_gnf_column(parser) + item1187 = _t1974 + push!(xs1185, item1187) + cond1186 = match_lookahead_literal(parser, "(", 0) + end + gnf_columns1188 = xs1185 consume_literal!(parser, ")") - return gnf_columns1185 + return gnf_columns1188 end function parse_gnf_column(parser::ParserState)::Proto.GNFColumn - span_start1192 = span_start(parser) + span_start1195 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - _t1969 = parse_gnf_column_path(parser) - gnf_column_path1186 = _t1969 + _t1975 = parse_gnf_column_path(parser) + gnf_column_path1189 = _t1975 if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - _t1971 = parse_relation_id(parser) - _t1970 = _t1971 + _t1977 = parse_relation_id(parser) + _t1976 = _t1977 else - _t1970 = nothing + _t1976 = nothing end - relation_id1187 = _t1970 + relation_id1190 = _t1976 consume_literal!(parser, "[") - xs1188 = Proto.var"#Type"[] - cond1189 = (((((((((((((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 cond1189 - _t1972 = parse_type(parser) - item1190 = _t1972 - push!(xs1188, item1190) - cond1189 = (((((((((((((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 - types1191 = xs1188 + xs1191 = Proto.var"#Type"[] + cond1192 = (((((((((((((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 cond1192 + _t1978 = parse_type(parser) + item1193 = _t1978 + push!(xs1191, item1193) + cond1192 = (((((((((((((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 + types1194 = xs1191 consume_literal!(parser, "]") consume_literal!(parser, ")") - _t1973 = Proto.GNFColumn(column_path=gnf_column_path1186, target_id=relation_id1187, types=types1191) - result1193 = _t1973 - record_span!(parser, span_start1192, "GNFColumn") - return result1193 + _t1979 = Proto.GNFColumn(column_path=gnf_column_path1189, target_id=relation_id1190, types=types1194) + result1196 = _t1979 + record_span!(parser, span_start1195, "GNFColumn") + return result1196 end function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t1974 = 1 + _t1980 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1975 = 0 + _t1981 = 0 else - _t1975 = -1 + _t1981 = -1 end - _t1974 = _t1975 + _t1980 = _t1981 end - prediction1194 = _t1974 - if prediction1194 == 1 + prediction1197 = _t1980 + if prediction1197 == 1 consume_literal!(parser, "[") - xs1196 = String[] - cond1197 = match_lookahead_terminal(parser, "STRING", 0) - while cond1197 - item1198 = consume_terminal!(parser, "STRING") - push!(xs1196, item1198) - cond1197 = match_lookahead_terminal(parser, "STRING", 0) + xs1199 = String[] + cond1200 = match_lookahead_terminal(parser, "STRING", 0) + while cond1200 + item1201 = consume_terminal!(parser, "STRING") + push!(xs1199, item1201) + cond1200 = match_lookahead_terminal(parser, "STRING", 0) end - strings1199 = xs1196 + strings1202 = xs1199 consume_literal!(parser, "]") - _t1976 = strings1199 + _t1982 = strings1202 else - if prediction1194 == 0 - string1195 = consume_terminal!(parser, "STRING") - _t1977 = String[string1195] + if prediction1197 == 0 + string1198 = consume_terminal!(parser, "STRING") + _t1983 = String[string1198] else throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t1976 = _t1977 + _t1982 = _t1983 end - return _t1976 + return _t1982 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string1200 = consume_terminal!(parser, "STRING") + string1203 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1200 + return string1203 end function parse_iceberg_data(parser::ParserState)::Proto.IcebergData - span_start1207 = span_start(parser) + span_start1210 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_data") - _t1978 = parse_iceberg_locator(parser) - iceberg_locator1201 = _t1978 - _t1979 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1202 = _t1979 - _t1980 = parse_gnf_columns(parser) - gnf_columns1203 = _t1980 + _t1984 = parse_iceberg_locator(parser) + iceberg_locator1204 = _t1984 + _t1985 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1205 = _t1985 + _t1986 = parse_gnf_columns(parser) + gnf_columns1206 = _t1986 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "from_snapshot", 1)) - _t1982 = parse_iceberg_from_snapshot(parser) - _t1981 = _t1982 + _t1988 = parse_iceberg_from_snapshot(parser) + _t1987 = _t1988 else - _t1981 = nothing + _t1987 = nothing end - iceberg_from_snapshot1204 = _t1981 + iceberg_from_snapshot1207 = _t1987 if match_lookahead_literal(parser, "(", 0) - _t1984 = parse_iceberg_to_snapshot(parser) - _t1983 = _t1984 + _t1990 = parse_iceberg_to_snapshot(parser) + _t1989 = _t1990 else - _t1983 = nothing + _t1989 = nothing end - iceberg_to_snapshot1205 = _t1983 - _t1985 = parse_boolean_value(parser) - boolean_value1206 = _t1985 + iceberg_to_snapshot1208 = _t1989 + _t1991 = parse_boolean_value(parser) + boolean_value1209 = _t1991 consume_literal!(parser, ")") - _t1986 = construct_iceberg_data(parser, iceberg_locator1201, iceberg_catalog_config1202, gnf_columns1203, iceberg_from_snapshot1204, iceberg_to_snapshot1205, boolean_value1206) - result1208 = _t1986 - record_span!(parser, span_start1207, "IcebergData") - return result1208 + _t1992 = construct_iceberg_data(parser, iceberg_locator1204, iceberg_catalog_config1205, gnf_columns1206, iceberg_from_snapshot1207, iceberg_to_snapshot1208, boolean_value1209) + result1211 = _t1992 + record_span!(parser, span_start1210, "IcebergData") + return result1211 end function parse_iceberg_locator(parser::ParserState)::Proto.IcebergLocator - span_start1212 = span_start(parser) + span_start1215 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_locator") - _t1987 = parse_iceberg_locator_table_name(parser) - iceberg_locator_table_name1209 = _t1987 - _t1988 = parse_iceberg_locator_namespace(parser) - iceberg_locator_namespace1210 = _t1988 - _t1989 = parse_iceberg_locator_warehouse(parser) - iceberg_locator_warehouse1211 = _t1989 + _t1993 = parse_iceberg_locator_table_name(parser) + iceberg_locator_table_name1212 = _t1993 + _t1994 = parse_iceberg_locator_namespace(parser) + iceberg_locator_namespace1213 = _t1994 + _t1995 = parse_iceberg_locator_warehouse(parser) + iceberg_locator_warehouse1214 = _t1995 consume_literal!(parser, ")") - _t1990 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1209, namespace=iceberg_locator_namespace1210, warehouse=iceberg_locator_warehouse1211) - result1213 = _t1990 - record_span!(parser, span_start1212, "IcebergLocator") - return result1213 + _t1996 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1212, namespace=iceberg_locator_namespace1213, warehouse=iceberg_locator_warehouse1214) + result1216 = _t1996 + record_span!(parser, span_start1215, "IcebergLocator") + return result1216 end function parse_iceberg_locator_table_name(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "table_name") - string1214 = consume_terminal!(parser, "STRING") + string1217 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1214 + return string1217 end function parse_iceberg_locator_namespace(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "namespace") - 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 + xs1218 = String[] + cond1219 = match_lookahead_terminal(parser, "STRING", 0) + while cond1219 + item1220 = consume_terminal!(parser, "STRING") + push!(xs1218, item1220) + cond1219 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1221 = xs1218 consume_literal!(parser, ")") - return strings1218 + return strings1221 end function parse_iceberg_locator_warehouse(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "warehouse") - string1219 = consume_terminal!(parser, "STRING") + string1222 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1219 + return string1222 end function parse_iceberg_catalog_config(parser::ParserState)::Proto.IcebergCatalogConfig - span_start1224 = span_start(parser) + span_start1227 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_catalog_config") - _t1991 = parse_iceberg_catalog_uri(parser) - iceberg_catalog_uri1220 = _t1991 + _t1997 = parse_iceberg_catalog_uri(parser) + iceberg_catalog_uri1223 = _t1997 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "scope", 1)) - _t1993 = parse_iceberg_catalog_config_scope(parser) - _t1992 = _t1993 + _t1999 = parse_iceberg_catalog_config_scope(parser) + _t1998 = _t1999 else - _t1992 = nothing + _t1998 = nothing end - iceberg_catalog_config_scope1221 = _t1992 - _t1994 = parse_iceberg_properties(parser) - iceberg_properties1222 = _t1994 - _t1995 = parse_iceberg_auth_properties(parser) - iceberg_auth_properties1223 = _t1995 + iceberg_catalog_config_scope1224 = _t1998 + _t2000 = parse_iceberg_properties(parser) + iceberg_properties1225 = _t2000 + _t2001 = parse_iceberg_auth_properties(parser) + iceberg_auth_properties1226 = _t2001 consume_literal!(parser, ")") - _t1996 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1220, iceberg_catalog_config_scope1221, iceberg_properties1222, iceberg_auth_properties1223) - result1225 = _t1996 - record_span!(parser, span_start1224, "IcebergCatalogConfig") - return result1225 + _t2002 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1223, iceberg_catalog_config_scope1224, iceberg_properties1225, iceberg_auth_properties1226) + result1228 = _t2002 + record_span!(parser, span_start1227, "IcebergCatalogConfig") + return result1228 end function parse_iceberg_catalog_uri(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "catalog_uri") - string1226 = consume_terminal!(parser, "STRING") + string1229 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1226 + return string1229 end function parse_iceberg_catalog_config_scope(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "scope") - string1227 = consume_terminal!(parser, "STRING") + string1230 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1227 + return string1230 end function parse_iceberg_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "properties") - xs1228 = Tuple{String, String}[] - cond1229 = match_lookahead_literal(parser, "(", 0) - while cond1229 - _t1997 = parse_iceberg_property_entry(parser) - item1230 = _t1997 - push!(xs1228, item1230) - cond1229 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1231 = xs1228 + xs1231 = Tuple{String, String}[] + cond1232 = match_lookahead_literal(parser, "(", 0) + while cond1232 + _t2003 = parse_iceberg_property_entry(parser) + item1233 = _t2003 + push!(xs1231, item1233) + cond1232 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1234 = xs1231 consume_literal!(parser, ")") - return iceberg_property_entrys1231 + return iceberg_property_entrys1234 end function parse_iceberg_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1232 = consume_terminal!(parser, "STRING") - string_31233 = consume_terminal!(parser, "STRING") + string1235 = consume_terminal!(parser, "STRING") + string_31236 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1232, string_31233,) + return (string1235, string_31236,) end function parse_iceberg_auth_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "auth_properties") - xs1234 = Tuple{String, String}[] - cond1235 = match_lookahead_literal(parser, "(", 0) - while cond1235 - _t1998 = parse_iceberg_masked_property_entry(parser) - item1236 = _t1998 - push!(xs1234, item1236) - cond1235 = match_lookahead_literal(parser, "(", 0) - end - iceberg_masked_property_entrys1237 = xs1234 + xs1237 = Tuple{String, String}[] + cond1238 = match_lookahead_literal(parser, "(", 0) + while cond1238 + _t2004 = parse_iceberg_masked_property_entry(parser) + item1239 = _t2004 + push!(xs1237, item1239) + cond1238 = match_lookahead_literal(parser, "(", 0) + end + iceberg_masked_property_entrys1240 = xs1237 consume_literal!(parser, ")") - return iceberg_masked_property_entrys1237 + return iceberg_masked_property_entrys1240 end function parse_iceberg_masked_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1238 = consume_terminal!(parser, "STRING") - string_31239 = consume_terminal!(parser, "STRING") + string1241 = consume_terminal!(parser, "STRING") + string_31242 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1238, string_31239,) + return (string1241, string_31242,) end function parse_iceberg_from_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "from_snapshot") - string1240 = consume_terminal!(parser, "STRING") + string1243 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1240 + return string1243 end function parse_iceberg_to_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "to_snapshot") - string1241 = consume_terminal!(parser, "STRING") + string1244 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1241 + return string1244 end function parse_undefine(parser::ParserState)::Proto.Undefine - span_start1243 = span_start(parser) + span_start1246 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t1999 = parse_fragment_id(parser) - fragment_id1242 = _t1999 + _t2005 = parse_fragment_id(parser) + fragment_id1245 = _t2005 consume_literal!(parser, ")") - _t2000 = Proto.Undefine(fragment_id=fragment_id1242) - result1244 = _t2000 - record_span!(parser, span_start1243, "Undefine") - return result1244 + _t2006 = Proto.Undefine(fragment_id=fragment_id1245) + result1247 = _t2006 + record_span!(parser, span_start1246, "Undefine") + return result1247 end function parse_context(parser::ParserState)::Proto.Context - span_start1249 = span_start(parser) + span_start1252 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "context") - xs1245 = Proto.RelationId[] - cond1246 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1246 - _t2001 = parse_relation_id(parser) - item1247 = _t2001 - push!(xs1245, item1247) - cond1246 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1248 = xs1245 + xs1248 = Proto.RelationId[] + cond1249 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1249 + _t2007 = parse_relation_id(parser) + item1250 = _t2007 + push!(xs1248, item1250) + cond1249 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1251 = xs1248 consume_literal!(parser, ")") - _t2002 = Proto.Context(relations=relation_ids1248) - result1250 = _t2002 - record_span!(parser, span_start1249, "Context") - return result1250 + _t2008 = Proto.Context(relations=relation_ids1251) + result1253 = _t2008 + record_span!(parser, span_start1252, "Context") + return result1253 end function parse_snapshot(parser::ParserState)::Proto.Snapshot - span_start1256 = span_start(parser) + span_start1259 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t2003 = parse_edb_path(parser) - edb_path1251 = _t2003 - xs1252 = Proto.SnapshotMapping[] - cond1253 = match_lookahead_literal(parser, "[", 0) - while cond1253 - _t2004 = parse_snapshot_mapping(parser) - item1254 = _t2004 - push!(xs1252, item1254) - cond1253 = match_lookahead_literal(parser, "[", 0) - end - snapshot_mappings1255 = xs1252 + _t2009 = parse_edb_path(parser) + edb_path1254 = _t2009 + xs1255 = Proto.SnapshotMapping[] + cond1256 = match_lookahead_literal(parser, "[", 0) + while cond1256 + _t2010 = parse_snapshot_mapping(parser) + item1257 = _t2010 + push!(xs1255, item1257) + cond1256 = match_lookahead_literal(parser, "[", 0) + end + snapshot_mappings1258 = xs1255 consume_literal!(parser, ")") - _t2005 = Proto.Snapshot(mappings=snapshot_mappings1255, prefix=edb_path1251) - result1257 = _t2005 - record_span!(parser, span_start1256, "Snapshot") - return result1257 + _t2011 = Proto.Snapshot(mappings=snapshot_mappings1258, prefix=edb_path1254) + result1260 = _t2011 + record_span!(parser, span_start1259, "Snapshot") + return result1260 end function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping - span_start1260 = span_start(parser) - _t2006 = parse_edb_path(parser) - edb_path1258 = _t2006 - _t2007 = parse_relation_id(parser) - relation_id1259 = _t2007 - _t2008 = Proto.SnapshotMapping(destination_path=edb_path1258, source_relation=relation_id1259) - result1261 = _t2008 - record_span!(parser, span_start1260, "SnapshotMapping") - return result1261 + span_start1263 = span_start(parser) + _t2012 = parse_edb_path(parser) + edb_path1261 = _t2012 + _t2013 = parse_relation_id(parser) + relation_id1262 = _t2013 + _t2014 = Proto.SnapshotMapping(destination_path=edb_path1261, source_relation=relation_id1262) + result1264 = _t2014 + record_span!(parser, span_start1263, "SnapshotMapping") + return result1264 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs1262 = Proto.Read[] - cond1263 = match_lookahead_literal(parser, "(", 0) - while cond1263 - _t2009 = parse_read(parser) - item1264 = _t2009 - push!(xs1262, item1264) - cond1263 = match_lookahead_literal(parser, "(", 0) - end - reads1265 = xs1262 + xs1265 = Proto.Read[] + cond1266 = match_lookahead_literal(parser, "(", 0) + while cond1266 + _t2015 = parse_read(parser) + item1267 = _t2015 + push!(xs1265, item1267) + cond1266 = match_lookahead_literal(parser, "(", 0) + end + reads1268 = xs1265 consume_literal!(parser, ")") - return reads1265 + return reads1268 end function parse_read(parser::ParserState)::Proto.Read - span_start1272 = span_start(parser) + span_start1275 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t2011 = 2 + _t2017 = 2 else if match_lookahead_literal(parser, "output", 1) - _t2012 = 1 + _t2018 = 1 else if match_lookahead_literal(parser, "export_iceberg", 1) - _t2013 = 4 + _t2019 = 4 else if match_lookahead_literal(parser, "export", 1) - _t2014 = 4 + _t2020 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t2015 = 0 + _t2021 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t2016 = 3 + _t2022 = 3 else - _t2016 = -1 + _t2022 = -1 end - _t2015 = _t2016 + _t2021 = _t2022 end - _t2014 = _t2015 + _t2020 = _t2021 end - _t2013 = _t2014 + _t2019 = _t2020 end - _t2012 = _t2013 + _t2018 = _t2019 end - _t2011 = _t2012 + _t2017 = _t2018 end - _t2010 = _t2011 + _t2016 = _t2017 else - _t2010 = -1 - end - prediction1266 = _t2010 - if prediction1266 == 4 - _t2018 = parse_export(parser) - export1271 = _t2018 - _t2019 = Proto.Read(read_type=OneOf(:var"#export", export1271)) - _t2017 = _t2019 + _t2016 = -1 + end + prediction1269 = _t2016 + if prediction1269 == 4 + _t2024 = parse_export(parser) + export1274 = _t2024 + _t2025 = Proto.Read(read_type=OneOf(:var"#export", export1274)) + _t2023 = _t2025 else - if prediction1266 == 3 - _t2021 = parse_abort(parser) - abort1270 = _t2021 - _t2022 = Proto.Read(read_type=OneOf(:abort, abort1270)) - _t2020 = _t2022 + if prediction1269 == 3 + _t2027 = parse_abort(parser) + abort1273 = _t2027 + _t2028 = Proto.Read(read_type=OneOf(:abort, abort1273)) + _t2026 = _t2028 else - if prediction1266 == 2 - _t2024 = parse_what_if(parser) - what_if1269 = _t2024 - _t2025 = Proto.Read(read_type=OneOf(:what_if, what_if1269)) - _t2023 = _t2025 + if prediction1269 == 2 + _t2030 = parse_what_if(parser) + what_if1272 = _t2030 + _t2031 = Proto.Read(read_type=OneOf(:what_if, what_if1272)) + _t2029 = _t2031 else - if prediction1266 == 1 - _t2027 = parse_output(parser) - output1268 = _t2027 - _t2028 = Proto.Read(read_type=OneOf(:output, output1268)) - _t2026 = _t2028 + if prediction1269 == 1 + _t2033 = parse_output(parser) + output1271 = _t2033 + _t2034 = Proto.Read(read_type=OneOf(:output, output1271)) + _t2032 = _t2034 else - if prediction1266 == 0 - _t2030 = parse_demand(parser) - demand1267 = _t2030 - _t2031 = Proto.Read(read_type=OneOf(:demand, demand1267)) - _t2029 = _t2031 + if prediction1269 == 0 + _t2036 = parse_demand(parser) + demand1270 = _t2036 + _t2037 = Proto.Read(read_type=OneOf(:demand, demand1270)) + _t2035 = _t2037 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t2026 = _t2029 + _t2032 = _t2035 end - _t2023 = _t2026 + _t2029 = _t2032 end - _t2020 = _t2023 + _t2026 = _t2029 end - _t2017 = _t2020 + _t2023 = _t2026 end - result1273 = _t2017 - record_span!(parser, span_start1272, "Read") - return result1273 + result1276 = _t2023 + record_span!(parser, span_start1275, "Read") + return result1276 end function parse_demand(parser::ParserState)::Proto.Demand - span_start1275 = span_start(parser) + span_start1278 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t2032 = parse_relation_id(parser) - relation_id1274 = _t2032 + _t2038 = parse_relation_id(parser) + relation_id1277 = _t2038 consume_literal!(parser, ")") - _t2033 = Proto.Demand(relation_id=relation_id1274) - result1276 = _t2033 - record_span!(parser, span_start1275, "Demand") - return result1276 + _t2039 = Proto.Demand(relation_id=relation_id1277) + result1279 = _t2039 + record_span!(parser, span_start1278, "Demand") + return result1279 end function parse_output(parser::ParserState)::Proto.Output - span_start1279 = span_start(parser) + span_start1282 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "output") - _t2034 = parse_name(parser) - name1277 = _t2034 - _t2035 = parse_relation_id(parser) - relation_id1278 = _t2035 + _t2040 = parse_name(parser) + name1280 = _t2040 + _t2041 = parse_relation_id(parser) + relation_id1281 = _t2041 consume_literal!(parser, ")") - _t2036 = Proto.Output(name=name1277, relation_id=relation_id1278) - result1280 = _t2036 - record_span!(parser, span_start1279, "Output") - return result1280 + _t2042 = Proto.Output(name=name1280, relation_id=relation_id1281) + result1283 = _t2042 + record_span!(parser, span_start1282, "Output") + return result1283 end function parse_what_if(parser::ParserState)::Proto.WhatIf - span_start1283 = span_start(parser) + span_start1286 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t2037 = parse_name(parser) - name1281 = _t2037 - _t2038 = parse_epoch(parser) - epoch1282 = _t2038 + _t2043 = parse_name(parser) + name1284 = _t2043 + _t2044 = parse_epoch(parser) + epoch1285 = _t2044 consume_literal!(parser, ")") - _t2039 = Proto.WhatIf(branch=name1281, epoch=epoch1282) - result1284 = _t2039 - record_span!(parser, span_start1283, "WhatIf") - return result1284 + _t2045 = Proto.WhatIf(branch=name1284, epoch=epoch1285) + result1287 = _t2045 + record_span!(parser, span_start1286, "WhatIf") + return result1287 end function parse_abort(parser::ParserState)::Proto.Abort - span_start1287 = span_start(parser) + span_start1290 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t2041 = parse_name(parser) - _t2040 = _t2041 + _t2047 = parse_name(parser) + _t2046 = _t2047 else - _t2040 = nothing + _t2046 = nothing end - name1285 = _t2040 - _t2042 = parse_relation_id(parser) - relation_id1286 = _t2042 + name1288 = _t2046 + _t2048 = parse_relation_id(parser) + relation_id1289 = _t2048 consume_literal!(parser, ")") - _t2043 = Proto.Abort(name=(!isnothing(name1285) ? name1285 : "abort"), relation_id=relation_id1286) - result1288 = _t2043 - record_span!(parser, span_start1287, "Abort") - return result1288 + _t2049 = Proto.Abort(name=(!isnothing(name1288) ? name1288 : "abort"), relation_id=relation_id1289) + result1291 = _t2049 + record_span!(parser, span_start1290, "Abort") + return result1291 end function parse_export(parser::ParserState)::Proto.Export - span_start1292 = span_start(parser) + span_start1295 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_iceberg", 1) - _t2045 = 1 + _t2051 = 1 else if match_lookahead_literal(parser, "export", 1) - _t2046 = 0 + _t2052 = 0 else - _t2046 = -1 + _t2052 = -1 end - _t2045 = _t2046 + _t2051 = _t2052 end - _t2044 = _t2045 + _t2050 = _t2051 else - _t2044 = -1 + _t2050 = -1 end - prediction1289 = _t2044 - if prediction1289 == 1 + prediction1292 = _t2050 + if prediction1292 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg") - _t2048 = parse_export_iceberg_config(parser) - export_iceberg_config1291 = _t2048 + _t2054 = parse_export_iceberg_config(parser) + export_iceberg_config1294 = _t2054 consume_literal!(parser, ")") - _t2049 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1291)) - _t2047 = _t2049 + _t2055 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1294)) + _t2053 = _t2055 else - if prediction1289 == 0 + if prediction1292 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export") - _t2051 = parse_export_csv_config(parser) - export_csv_config1290 = _t2051 + _t2057 = parse_export_csv_config(parser) + export_csv_config1293 = _t2057 consume_literal!(parser, ")") - _t2052 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1290)) - _t2050 = _t2052 + _t2058 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1293)) + _t2056 = _t2058 else throw(ParseError("Unexpected token in export" * ": " * string(lookahead(parser, 0)))) end - _t2047 = _t2050 + _t2053 = _t2056 end - result1293 = _t2047 - record_span!(parser, span_start1292, "Export") - return result1293 + result1296 = _t2053 + record_span!(parser, span_start1295, "Export") + return result1296 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig - span_start1301 = span_start(parser) + span_start1304 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_csv_config_v2", 1) - _t2054 = 0 + _t2060 = 0 else if match_lookahead_literal(parser, "export_csv_config", 1) - _t2055 = 1 + _t2061 = 1 else - _t2055 = -1 + _t2061 = -1 end - _t2054 = _t2055 + _t2060 = _t2061 end - _t2053 = _t2054 + _t2059 = _t2060 else - _t2053 = -1 + _t2059 = -1 end - prediction1294 = _t2053 - if prediction1294 == 1 + prediction1297 = _t2059 + if prediction1297 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t2057 = parse_export_csv_path(parser) - export_csv_path1298 = _t2057 - _t2058 = parse_export_csv_columns_list(parser) - export_csv_columns_list1299 = _t2058 - _t2059 = parse_config_dict(parser) - config_dict1300 = _t2059 + _t2063 = parse_export_csv_path(parser) + export_csv_path1301 = _t2063 + _t2064 = parse_export_csv_columns_list(parser) + export_csv_columns_list1302 = _t2064 + _t2065 = parse_config_dict(parser) + config_dict1303 = _t2065 consume_literal!(parser, ")") - _t2060 = construct_export_csv_config(parser, export_csv_path1298, export_csv_columns_list1299, config_dict1300) - _t2056 = _t2060 + _t2066 = construct_export_csv_config(parser, export_csv_path1301, export_csv_columns_list1302, config_dict1303) + _t2062 = _t2066 else - if prediction1294 == 0 + if prediction1297 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config_v2") - _t2062 = parse_export_csv_path(parser) - export_csv_path1295 = _t2062 - _t2063 = parse_export_csv_source(parser) - export_csv_source1296 = _t2063 - _t2064 = parse_csv_config(parser) - csv_config1297 = _t2064 + _t2068 = parse_export_csv_output_location(parser) + export_csv_output_location1298 = _t2068 + _t2069 = parse_export_csv_source(parser) + export_csv_source1299 = _t2069 + _t2070 = parse_csv_config(parser) + csv_config1300 = _t2070 consume_literal!(parser, ")") - _t2065 = construct_export_csv_config_with_source(parser, export_csv_path1295, export_csv_source1296, csv_config1297) - _t2061 = _t2065 + _t2071 = construct_export_csv_config_with_location(parser, export_csv_output_location1298, export_csv_source1299, csv_config1300) + _t2067 = _t2071 else throw(ParseError("Unexpected token in export_csv_config" * ": " * string(lookahead(parser, 0)))) end - _t2056 = _t2061 + _t2062 = _t2067 end - result1302 = _t2056 - record_span!(parser, span_start1301, "ExportCSVConfig") - return result1302 + result1305 = _t2062 + record_span!(parser, span_start1304, "ExportCSVConfig") + return result1305 end -function parse_export_csv_path(parser::ParserState)::String - consume_literal!(parser, "(") - consume_literal!(parser, "path") - string1303 = consume_terminal!(parser, "STRING") - consume_literal!(parser, ")") - return string1303 +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) + _t2073 = 1 + else + if match_lookahead_literal(parser, "path", 1) + _t2074 = 0 + else + _t2074 = -1 + end + _t2073 = _t2074 + end + _t2072 = _t2073 + else + _t2072 = -1 + end + prediction1306 = _t2072 + if prediction1306 == 1 + consume_literal!(parser, "(") + consume_literal!(parser, "transaction_output_name") + _t2076 = parse_name(parser) + name1308 = _t2076 + consume_literal!(parser, ")") + _t2075 = ("", name1308,) + else + if prediction1306 == 0 + consume_literal!(parser, "(") + consume_literal!(parser, "path") + string1307 = consume_terminal!(parser, "STRING") + consume_literal!(parser, ")") + _t2077 = (string1307, "",) + else + throw(ParseError("Unexpected token in export_csv_output_location" * ": " * string(lookahead(parser, 0)))) + end + _t2075 = _t2077 + end + return _t2075 end function parse_export_csv_source(parser::ParserState)::Proto.ExportCSVSource - span_start1310 = span_start(parser) + span_start1315 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "table_def", 1) - _t2067 = 1 + _t2079 = 1 else if match_lookahead_literal(parser, "gnf_columns", 1) - _t2068 = 0 + _t2080 = 0 else - _t2068 = -1 + _t2080 = -1 end - _t2067 = _t2068 + _t2079 = _t2080 end - _t2066 = _t2067 + _t2078 = _t2079 else - _t2066 = -1 + _t2078 = -1 end - prediction1304 = _t2066 - if prediction1304 == 1 + prediction1309 = _t2078 + if prediction1309 == 1 consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2070 = parse_relation_id(parser) - relation_id1309 = _t2070 + _t2082 = parse_relation_id(parser) + relation_id1314 = _t2082 consume_literal!(parser, ")") - _t2071 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1309)) - _t2069 = _t2071 + _t2083 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1314)) + _t2081 = _t2083 else - if prediction1304 == 0 + if prediction1309 == 0 consume_literal!(parser, "(") consume_literal!(parser, "gnf_columns") - xs1305 = Proto.ExportCSVColumn[] - cond1306 = match_lookahead_literal(parser, "(", 0) - while cond1306 - _t2073 = parse_export_csv_column(parser) - item1307 = _t2073 - push!(xs1305, item1307) - cond1306 = match_lookahead_literal(parser, "(", 0) + xs1310 = Proto.ExportCSVColumn[] + cond1311 = match_lookahead_literal(parser, "(", 0) + while cond1311 + _t2085 = parse_export_csv_column(parser) + item1312 = _t2085 + push!(xs1310, item1312) + cond1311 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1308 = xs1305 + export_csv_columns1313 = xs1310 consume_literal!(parser, ")") - _t2074 = Proto.ExportCSVColumns(columns=export_csv_columns1308) - _t2075 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2074)) - _t2072 = _t2075 + _t2086 = Proto.ExportCSVColumns(columns=export_csv_columns1313) + _t2087 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2086)) + _t2084 = _t2087 else throw(ParseError("Unexpected token in export_csv_source" * ": " * string(lookahead(parser, 0)))) end - _t2069 = _t2072 + _t2081 = _t2084 end - result1311 = _t2069 - record_span!(parser, span_start1310, "ExportCSVSource") - return result1311 + result1316 = _t2081 + record_span!(parser, span_start1315, "ExportCSVSource") + return result1316 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn - span_start1314 = span_start(parser) + span_start1319 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1312 = consume_terminal!(parser, "STRING") - _t2076 = parse_relation_id(parser) - relation_id1313 = _t2076 + string1317 = consume_terminal!(parser, "STRING") + _t2088 = parse_relation_id(parser) + relation_id1318 = _t2088 consume_literal!(parser, ")") - _t2077 = Proto.ExportCSVColumn(column_name=string1312, column_data=relation_id1313) - result1315 = _t2077 - record_span!(parser, span_start1314, "ExportCSVColumn") - return result1315 + _t2089 = Proto.ExportCSVColumn(column_name=string1317, column_data=relation_id1318) + result1320 = _t2089 + record_span!(parser, span_start1319, "ExportCSVColumn") + return result1320 +end + +function parse_export_csv_path(parser::ParserState)::String + consume_literal!(parser, "(") + consume_literal!(parser, "path") + string1321 = consume_terminal!(parser, "STRING") + consume_literal!(parser, ")") + return string1321 end function parse_export_csv_columns_list(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1316 = Proto.ExportCSVColumn[] - cond1317 = match_lookahead_literal(parser, "(", 0) - while cond1317 - _t2078 = parse_export_csv_column(parser) - item1318 = _t2078 - push!(xs1316, item1318) - cond1317 = match_lookahead_literal(parser, "(", 0) - end - export_csv_columns1319 = xs1316 + xs1322 = Proto.ExportCSVColumn[] + cond1323 = match_lookahead_literal(parser, "(", 0) + while cond1323 + _t2090 = parse_export_csv_column(parser) + item1324 = _t2090 + push!(xs1322, item1324) + cond1323 = match_lookahead_literal(parser, "(", 0) + end + export_csv_columns1325 = xs1322 consume_literal!(parser, ")") - return export_csv_columns1319 + return export_csv_columns1325 end function parse_export_iceberg_config(parser::ParserState)::Proto.ExportIcebergConfig - span_start1325 = span_start(parser) + span_start1331 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg_config") - _t2079 = parse_iceberg_locator(parser) - iceberg_locator1320 = _t2079 - _t2080 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1321 = _t2080 - _t2081 = parse_export_iceberg_table_def(parser) - export_iceberg_table_def1322 = _t2081 - _t2082 = parse_iceberg_table_properties(parser) - iceberg_table_properties1323 = _t2082 + _t2091 = parse_iceberg_locator(parser) + iceberg_locator1326 = _t2091 + _t2092 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1327 = _t2092 + _t2093 = parse_export_iceberg_table_def(parser) + export_iceberg_table_def1328 = _t2093 + _t2094 = parse_iceberg_table_properties(parser) + iceberg_table_properties1329 = _t2094 if match_lookahead_literal(parser, "{", 0) - _t2084 = parse_config_dict(parser) - _t2083 = _t2084 + _t2096 = parse_config_dict(parser) + _t2095 = _t2096 else - _t2083 = nothing + _t2095 = nothing end - config_dict1324 = _t2083 + config_dict1330 = _t2095 consume_literal!(parser, ")") - _t2085 = construct_export_iceberg_config_full(parser, iceberg_locator1320, iceberg_catalog_config1321, export_iceberg_table_def1322, iceberg_table_properties1323, config_dict1324) - result1326 = _t2085 - record_span!(parser, span_start1325, "ExportIcebergConfig") - return result1326 + _t2097 = construct_export_iceberg_config_full(parser, iceberg_locator1326, iceberg_catalog_config1327, export_iceberg_table_def1328, iceberg_table_properties1329, config_dict1330) + result1332 = _t2097 + record_span!(parser, span_start1331, "ExportIcebergConfig") + return result1332 end function parse_export_iceberg_table_def(parser::ParserState)::Proto.RelationId - span_start1328 = span_start(parser) + span_start1334 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2086 = parse_relation_id(parser) - relation_id1327 = _t2086 + _t2098 = parse_relation_id(parser) + relation_id1333 = _t2098 consume_literal!(parser, ")") - result1329 = relation_id1327 - record_span!(parser, span_start1328, "RelationId") - return result1329 + result1335 = relation_id1333 + record_span!(parser, span_start1334, "RelationId") + return result1335 end function parse_iceberg_table_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "table_properties") - xs1330 = Tuple{String, String}[] - cond1331 = match_lookahead_literal(parser, "(", 0) - while cond1331 - _t2087 = parse_iceberg_property_entry(parser) - item1332 = _t2087 - push!(xs1330, item1332) - cond1331 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1333 = xs1330 + xs1336 = Tuple{String, String}[] + cond1337 = match_lookahead_literal(parser, "(", 0) + while cond1337 + _t2099 = parse_iceberg_property_entry(parser) + item1338 = _t2099 + push!(xs1336, item1338) + cond1337 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1339 = xs1336 consume_literal!(parser, ")") - return iceberg_property_entrys1333 + return iceberg_property_entrys1339 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index 68914d6e..8284e9f9 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -376,90 +376,94 @@ end # --- Helper functions --- +function deconstruct_export_csv_output_location(pp::PrettyPrinter, msg::Proto.ExportCSVConfig)::Tuple{String, String} + return (msg.path, msg.transaction_output_name,) +end + function _make_value_int32(pp::PrettyPrinter, v::Int32)::Proto.Value - _t1781 = Proto.Value(value=OneOf(:int32_value, v)) - return _t1781 + _t1794 = Proto.Value(value=OneOf(:int32_value, v)) + return _t1794 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1782 = Proto.Value(value=OneOf(:int_value, v)) - return _t1782 + _t1795 = Proto.Value(value=OneOf(:int_value, v)) + return _t1795 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1783 = Proto.Value(value=OneOf(:float_value, v)) - return _t1783 + _t1796 = Proto.Value(value=OneOf(:float_value, v)) + return _t1796 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1784 = Proto.Value(value=OneOf(:string_value, v)) - return _t1784 + _t1797 = Proto.Value(value=OneOf(:string_value, v)) + return _t1797 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1785 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1785 + _t1798 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1798 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1786 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1786 + _t1799 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1799 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 - _t1787 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1787,)) + _t1800 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1800,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1788 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1788,)) + _t1801 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1801,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1789 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1789,)) + _t1802 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1802,)) end end end - _t1790 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1790,)) + _t1803 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1803,)) return sort(result) end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1791 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1791,)) - _t1792 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1792,)) + _t1804 = _make_value_int32(pp, msg.header_row) + push!(result, ("csv_header_row", _t1804,)) + _t1805 = _make_value_int64(pp, msg.skip) + push!(result, ("csv_skip", _t1805,)) if msg.new_line != "" - _t1793 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1793,)) - end - _t1794 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1794,)) - _t1795 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1795,)) - _t1796 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1796,)) + _t1806 = _make_value_string(pp, msg.new_line) + push!(result, ("csv_new_line", _t1806,)) + end + _t1807 = _make_value_string(pp, msg.delimiter) + push!(result, ("csv_delimiter", _t1807,)) + _t1808 = _make_value_string(pp, msg.quotechar) + push!(result, ("csv_quotechar", _t1808,)) + _t1809 = _make_value_string(pp, msg.escapechar) + push!(result, ("csv_escapechar", _t1809,)) if msg.comment != "" - _t1797 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1797,)) + _t1810 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1810,)) end for missing_string in msg.missing_strings - _t1798 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1798,)) - end - _t1799 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1799,)) - _t1800 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1800,)) - _t1801 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1801,)) + _t1811 = _make_value_string(pp, missing_string) + push!(result, ("csv_missing_strings", _t1811,)) + end + _t1812 = _make_value_string(pp, msg.decimal_separator) + push!(result, ("csv_decimal_separator", _t1812,)) + _t1813 = _make_value_string(pp, msg.encoding) + push!(result, ("csv_encoding", _t1813,)) + _t1814 = _make_value_string(pp, msg.compression) + push!(result, ("csv_compression", _t1814,)) if msg.partition_size_mb != 0 - _t1802 = _make_value_int64(pp, msg.partition_size_mb) - push!(result, ("csv_partition_size_mb", _t1802,)) + _t1815 = _make_value_int64(pp, msg.partition_size_mb) + push!(result, ("csv_partition_size_mb", _t1815,)) end return sort(result) end @@ -468,91 +472,91 @@ function deconstruct_csv_storage_integration_optional(pp::PrettyPrinter, msg::Pr if !_has_proto_field(msg, Symbol("storage_integration")) return nothing else - _t1803 = nothing + _t1816 = nothing end si = msg.storage_integration result = Tuple{String, Proto.Value}[] if si.provider != "" - _t1804 = _make_value_string(pp, si.provider) - push!(result, ("provider", _t1804,)) + _t1817 = _make_value_string(pp, si.provider) + push!(result, ("provider", _t1817,)) end if si.azure_sas_token != "" - _t1805 = _make_value_string(pp, "***") - push!(result, ("azure_sas_token", _t1805,)) + _t1818 = _make_value_string(pp, "***") + push!(result, ("azure_sas_token", _t1818,)) end if si.s3_region != "" - _t1806 = _make_value_string(pp, si.s3_region) - push!(result, ("s3_region", _t1806,)) + _t1819 = _make_value_string(pp, si.s3_region) + push!(result, ("s3_region", _t1819,)) end if si.s3_access_key_id != "" - _t1807 = _make_value_string(pp, "***") - push!(result, ("s3_access_key_id", _t1807,)) + _t1820 = _make_value_string(pp, "***") + push!(result, ("s3_access_key_id", _t1820,)) end if si.s3_secret_access_key != "" - _t1808 = _make_value_string(pp, "***") - push!(result, ("s3_secret_access_key", _t1808,)) + _t1821 = _make_value_string(pp, "***") + push!(result, ("s3_secret_access_key", _t1821,)) 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}[] - _t1809 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1809,)) - _t1810 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1810,)) - _t1811 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1811,)) - _t1812 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1812,)) + _t1822 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1822,)) + _t1823 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1823,)) + _t1824 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1824,)) + _t1825 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1825,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1813 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1813,)) + _t1826 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1826,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1814 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1814,)) + _t1827 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1827,)) end end - _t1815 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1815,)) - _t1816 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1816,)) + _t1828 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1828,)) + _t1829 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1829,)) 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) - _t1817 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1817,)) + _t1830 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1830,)) end if !isnothing(msg.compression) - _t1818 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1818,)) + _t1831 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1831,)) end if !isnothing(msg.syntax_header_row) - _t1819 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1819,)) + _t1832 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1832,)) end if !isnothing(msg.syntax_missing_string) - _t1820 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1820,)) + _t1833 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1833,)) end if !isnothing(msg.syntax_delim) - _t1821 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1821,)) + _t1834 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1834,)) end if !isnothing(msg.syntax_quotechar) - _t1822 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1822,)) + _t1835 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1835,)) end if !isnothing(msg.syntax_escapechar) - _t1823 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1823,)) + _t1836 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1836,)) end return sort(result) end @@ -565,7 +569,7 @@ function deconstruct_iceberg_catalog_config_scope_optional(pp::PrettyPrinter, ms if msg.scope != "" return msg.scope else - _t1824 = nothing + _t1837 = nothing end return nothing end @@ -574,7 +578,7 @@ function deconstruct_iceberg_data_from_snapshot_optional(pp::PrettyPrinter, msg: if msg.from_snapshot != "" return msg.from_snapshot else - _t1825 = nothing + _t1838 = nothing end return nothing end @@ -583,7 +587,7 @@ function deconstruct_iceberg_data_to_snapshot_optional(pp::PrettyPrinter, msg::P if msg.to_snapshot != "" return msg.to_snapshot else - _t1826 = nothing + _t1839 = nothing end return nothing end @@ -591,21 +595,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 != "" - _t1827 = _make_value_string(pp, msg.prefix) - push!(result, ("prefix", _t1827,)) + _t1840 = _make_value_string(pp, msg.prefix) + push!(result, ("prefix", _t1840,)) end if msg.target_file_size_bytes != 0 - _t1828 = _make_value_int64(pp, msg.target_file_size_bytes) - push!(result, ("target_file_size_bytes", _t1828,)) + _t1841 = _make_value_int64(pp, msg.target_file_size_bytes) + push!(result, ("target_file_size_bytes", _t1841,)) end if msg.compression != "" - _t1829 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1829,)) + _t1842 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1842,)) end if length(result) == 0 return nothing else - _t1830 = nothing + _t1843 = nothing end return sort(result) end @@ -620,7 +624,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1831 = nothing + _t1844 = nothing end return nothing end @@ -639,47 +643,47 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat808 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat808) - write(pp, flat808) + flat813 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat813) + write(pp, flat813) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1598 = _dollar_dollar.configure + _t1608 = _dollar_dollar.configure else - _t1598 = nothing + _t1608 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1599 = _dollar_dollar.sync + _t1609 = _dollar_dollar.sync else - _t1599 = nothing + _t1609 = nothing end - fields799 = (_t1598, _t1599, _dollar_dollar.epochs,) - unwrapped_fields800 = fields799 + fields804 = (_t1608, _t1609, _dollar_dollar.epochs,) + unwrapped_fields805 = fields804 write(pp, "(transaction") indent_sexp!(pp) - field801 = unwrapped_fields800[1] - if !isnothing(field801) + field806 = unwrapped_fields805[1] + if !isnothing(field806) newline(pp) - opt_val802 = field801 - pretty_configure(pp, opt_val802) + opt_val807 = field806 + pretty_configure(pp, opt_val807) end - field803 = unwrapped_fields800[2] - if !isnothing(field803) + field808 = unwrapped_fields805[2] + if !isnothing(field808) newline(pp) - opt_val804 = field803 - pretty_sync(pp, opt_val804) + opt_val809 = field808 + pretty_sync(pp, opt_val809) end - field805 = unwrapped_fields800[3] - if !isempty(field805) + field810 = unwrapped_fields805[3] + if !isempty(field810) newline(pp) - for (i1600, elem806) in enumerate(field805) - i807 = i1600 - 1 - if (i807 > 0) + for (i1610, elem811) in enumerate(field810) + i812 = i1610 - 1 + if (i812 > 0) newline(pp) end - pretty_epoch(pp, elem806) + pretty_epoch(pp, elem811) end end dedent!(pp) @@ -689,19 +693,19 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat811 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat811) - write(pp, flat811) + flat816 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat816) + write(pp, flat816) return nothing else _dollar_dollar = msg - _t1601 = deconstruct_configure(pp, _dollar_dollar) - fields809 = _t1601 - unwrapped_fields810 = fields809 + _t1611 = deconstruct_configure(pp, _dollar_dollar) + fields814 = _t1611 + unwrapped_fields815 = fields814 write(pp, "(configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields810) + pretty_config_dict(pp, unwrapped_fields815) dedent!(pp) write(pp, ")") end @@ -709,22 +713,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat815 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat815) - write(pp, flat815) + flat820 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat820) + write(pp, flat820) return nothing else - fields812 = msg + fields817 = msg write(pp, "{") indent!(pp) - if !isempty(fields812) + if !isempty(fields817) newline(pp) - for (i1602, elem813) in enumerate(fields812) - i814 = i1602 - 1 - if (i814 > 0) + for (i1612, elem818) in enumerate(fields817) + i819 = i1612 - 1 + if (i819 > 0) newline(pp) end - pretty_config_key_value(pp, elem813) + pretty_config_key_value(pp, elem818) end end dedent!(pp) @@ -734,163 +738,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}) - flat820 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat820) - write(pp, flat820) + flat825 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat825) + write(pp, flat825) return nothing else _dollar_dollar = msg - fields816 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields817 = fields816 + fields821 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields822 = fields821 write(pp, ":") - field818 = unwrapped_fields817[1] - write(pp, field818) + field823 = unwrapped_fields822[1] + write(pp, field823) write(pp, " ") - field819 = unwrapped_fields817[2] - pretty_raw_value(pp, field819) + field824 = unwrapped_fields822[2] + pretty_raw_value(pp, field824) end return nothing end function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) - flat846 = try_flat(pp, msg, pretty_raw_value) - if !isnothing(flat846) - write(pp, flat846) + flat851 = try_flat(pp, msg, pretty_raw_value) + if !isnothing(flat851) + write(pp, flat851) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1603 = _get_oneof_field(_dollar_dollar, :date_value) + _t1613 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1603 = nothing + _t1613 = nothing end - deconstruct_result844 = _t1603 - if !isnothing(deconstruct_result844) - unwrapped845 = deconstruct_result844 - pretty_raw_date(pp, unwrapped845) + deconstruct_result849 = _t1613 + if !isnothing(deconstruct_result849) + unwrapped850 = deconstruct_result849 + pretty_raw_date(pp, unwrapped850) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1604 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1614 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1604 = nothing + _t1614 = nothing end - deconstruct_result842 = _t1604 - if !isnothing(deconstruct_result842) - unwrapped843 = deconstruct_result842 - pretty_raw_datetime(pp, unwrapped843) + deconstruct_result847 = _t1614 + if !isnothing(deconstruct_result847) + unwrapped848 = deconstruct_result847 + pretty_raw_datetime(pp, unwrapped848) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1605 = _get_oneof_field(_dollar_dollar, :string_value) + _t1615 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1605 = nothing + _t1615 = nothing end - deconstruct_result840 = _t1605 - if !isnothing(deconstruct_result840) - unwrapped841 = deconstruct_result840 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped841)) + deconstruct_result845 = _t1615 + if !isnothing(deconstruct_result845) + unwrapped846 = deconstruct_result845 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped846)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1606 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1616 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1606 = nothing + _t1616 = nothing end - deconstruct_result838 = _t1606 - if !isnothing(deconstruct_result838) - unwrapped839 = deconstruct_result838 - write(pp, (string(Int64(unwrapped839)) * "i32")) + deconstruct_result843 = _t1616 + if !isnothing(deconstruct_result843) + unwrapped844 = deconstruct_result843 + write(pp, (string(Int64(unwrapped844)) * "i32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1607 = _get_oneof_field(_dollar_dollar, :int_value) + _t1617 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1607 = nothing + _t1617 = nothing end - deconstruct_result836 = _t1607 - if !isnothing(deconstruct_result836) - unwrapped837 = deconstruct_result836 - write(pp, string(unwrapped837)) + deconstruct_result841 = _t1617 + if !isnothing(deconstruct_result841) + unwrapped842 = deconstruct_result841 + write(pp, string(unwrapped842)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1608 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1618 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1608 = nothing + _t1618 = nothing end - deconstruct_result834 = _t1608 - if !isnothing(deconstruct_result834) - unwrapped835 = deconstruct_result834 - write(pp, format_float32_literal(unwrapped835)) + deconstruct_result839 = _t1618 + if !isnothing(deconstruct_result839) + unwrapped840 = deconstruct_result839 + write(pp, format_float32_literal(unwrapped840)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1609 = _get_oneof_field(_dollar_dollar, :float_value) + _t1619 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1609 = nothing + _t1619 = nothing end - deconstruct_result832 = _t1609 - if !isnothing(deconstruct_result832) - unwrapped833 = deconstruct_result832 - write(pp, lowercase(string(unwrapped833))) + deconstruct_result837 = _t1619 + if !isnothing(deconstruct_result837) + unwrapped838 = deconstruct_result837 + write(pp, lowercase(string(unwrapped838))) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1610 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1620 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1610 = nothing + _t1620 = nothing end - deconstruct_result830 = _t1610 - if !isnothing(deconstruct_result830) - unwrapped831 = deconstruct_result830 - write(pp, (string(Int64(unwrapped831)) * "u32")) + deconstruct_result835 = _t1620 + if !isnothing(deconstruct_result835) + unwrapped836 = deconstruct_result835 + write(pp, (string(Int64(unwrapped836)) * "u32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1611 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1621 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1611 = nothing + _t1621 = nothing end - deconstruct_result828 = _t1611 - if !isnothing(deconstruct_result828) - unwrapped829 = deconstruct_result828 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped829)) + deconstruct_result833 = _t1621 + if !isnothing(deconstruct_result833) + unwrapped834 = deconstruct_result833 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped834)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1612 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1622 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1612 = nothing + _t1622 = nothing end - deconstruct_result826 = _t1612 - if !isnothing(deconstruct_result826) - unwrapped827 = deconstruct_result826 - write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped827)) + deconstruct_result831 = _t1622 + if !isnothing(deconstruct_result831) + unwrapped832 = deconstruct_result831 + write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped832)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1613 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1623 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1613 = nothing + _t1623 = nothing end - deconstruct_result824 = _t1613 - if !isnothing(deconstruct_result824) - unwrapped825 = deconstruct_result824 - write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped825)) + deconstruct_result829 = _t1623 + if !isnothing(deconstruct_result829) + unwrapped830 = deconstruct_result829 + write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped830)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1614 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1624 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1614 = nothing + _t1624 = nothing end - deconstruct_result822 = _t1614 - if !isnothing(deconstruct_result822) - unwrapped823 = deconstruct_result822 - pretty_boolean_value(pp, unwrapped823) + deconstruct_result827 = _t1624 + if !isnothing(deconstruct_result827) + unwrapped828 = deconstruct_result827 + pretty_boolean_value(pp, unwrapped828) else - fields821 = msg + fields826 = msg write(pp, "missing") end end @@ -909,25 +913,25 @@ function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat852 = try_flat(pp, msg, pretty_raw_date) - if !isnothing(flat852) - write(pp, flat852) + flat857 = try_flat(pp, msg, pretty_raw_date) + if !isnothing(flat857) + write(pp, flat857) return nothing else _dollar_dollar = msg - fields847 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields848 = fields847 + fields852 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields853 = fields852 write(pp, "(date") indent_sexp!(pp) newline(pp) - field849 = unwrapped_fields848[1] - write(pp, string(field849)) + field854 = unwrapped_fields853[1] + write(pp, string(field854)) newline(pp) - field850 = unwrapped_fields848[2] - write(pp, string(field850)) + field855 = unwrapped_fields853[2] + write(pp, string(field855)) newline(pp) - field851 = unwrapped_fields848[3] - write(pp, string(field851)) + field856 = unwrapped_fields853[3] + write(pp, string(field856)) dedent!(pp) write(pp, ")") end @@ -935,39 +939,39 @@ function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_raw_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat863 = try_flat(pp, msg, pretty_raw_datetime) - if !isnothing(flat863) - write(pp, flat863) + flat868 = try_flat(pp, msg, pretty_raw_datetime) + if !isnothing(flat868) + write(pp, flat868) return nothing else _dollar_dollar = msg - fields853 = (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_fields854 = fields853 + fields858 = (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_fields859 = fields858 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field855 = unwrapped_fields854[1] - write(pp, string(field855)) + field860 = unwrapped_fields859[1] + write(pp, string(field860)) newline(pp) - field856 = unwrapped_fields854[2] - write(pp, string(field856)) + field861 = unwrapped_fields859[2] + write(pp, string(field861)) newline(pp) - field857 = unwrapped_fields854[3] - write(pp, string(field857)) + field862 = unwrapped_fields859[3] + write(pp, string(field862)) newline(pp) - field858 = unwrapped_fields854[4] - write(pp, string(field858)) + field863 = unwrapped_fields859[4] + write(pp, string(field863)) newline(pp) - field859 = unwrapped_fields854[5] - write(pp, string(field859)) + field864 = unwrapped_fields859[5] + write(pp, string(field864)) newline(pp) - field860 = unwrapped_fields854[6] - write(pp, string(field860)) - field861 = unwrapped_fields854[7] - if !isnothing(field861) + field865 = unwrapped_fields859[6] + write(pp, string(field865)) + field866 = unwrapped_fields859[7] + if !isnothing(field866) newline(pp) - opt_val862 = field861 - write(pp, string(opt_val862)) + opt_val867 = field866 + write(pp, string(opt_val867)) end dedent!(pp) write(pp, ")") @@ -978,24 +982,24 @@ end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) _dollar_dollar = msg if _dollar_dollar - _t1615 = () + _t1625 = () else - _t1615 = nothing + _t1625 = nothing end - deconstruct_result866 = _t1615 - if !isnothing(deconstruct_result866) - unwrapped867 = deconstruct_result866 + deconstruct_result871 = _t1625 + if !isnothing(deconstruct_result871) + unwrapped872 = deconstruct_result871 write(pp, "true") else _dollar_dollar = msg if !_dollar_dollar - _t1616 = () + _t1626 = () else - _t1616 = nothing + _t1626 = nothing end - deconstruct_result864 = _t1616 - if !isnothing(deconstruct_result864) - unwrapped865 = deconstruct_result864 + deconstruct_result869 = _t1626 + if !isnothing(deconstruct_result869) + unwrapped870 = deconstruct_result869 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -1005,24 +1009,24 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat872 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat872) - write(pp, flat872) + flat877 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat877) + write(pp, flat877) return nothing else _dollar_dollar = msg - fields868 = _dollar_dollar.fragments - unwrapped_fields869 = fields868 + fields873 = _dollar_dollar.fragments + unwrapped_fields874 = fields873 write(pp, "(sync") indent_sexp!(pp) - if !isempty(unwrapped_fields869) + if !isempty(unwrapped_fields874) newline(pp) - for (i1617, elem870) in enumerate(unwrapped_fields869) - i871 = i1617 - 1 - if (i871 > 0) + for (i1627, elem875) in enumerate(unwrapped_fields874) + i876 = i1627 - 1 + if (i876 > 0) newline(pp) end - pretty_fragment_id(pp, elem870) + pretty_fragment_id(pp, elem875) end end dedent!(pp) @@ -1032,52 +1036,52 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat875 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat875) - write(pp, flat875) + flat880 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat880) + write(pp, flat880) return nothing else _dollar_dollar = msg - fields873 = fragment_id_to_string(pp, _dollar_dollar) - unwrapped_fields874 = fields873 + fields878 = fragment_id_to_string(pp, _dollar_dollar) + unwrapped_fields879 = fields878 write(pp, ":") - write(pp, unwrapped_fields874) + write(pp, unwrapped_fields879) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat882 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat882) - write(pp, flat882) + flat887 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat887) + write(pp, flat887) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.writes) - _t1618 = _dollar_dollar.writes + _t1628 = _dollar_dollar.writes else - _t1618 = nothing + _t1628 = nothing end if !isempty(_dollar_dollar.reads) - _t1619 = _dollar_dollar.reads + _t1629 = _dollar_dollar.reads else - _t1619 = nothing + _t1629 = nothing end - fields876 = (_t1618, _t1619,) - unwrapped_fields877 = fields876 + fields881 = (_t1628, _t1629,) + unwrapped_fields882 = fields881 write(pp, "(epoch") indent_sexp!(pp) - field878 = unwrapped_fields877[1] - if !isnothing(field878) + field883 = unwrapped_fields882[1] + if !isnothing(field883) newline(pp) - opt_val879 = field878 - pretty_epoch_writes(pp, opt_val879) + opt_val884 = field883 + pretty_epoch_writes(pp, opt_val884) end - field880 = unwrapped_fields877[2] - if !isnothing(field880) + field885 = unwrapped_fields882[2] + if !isnothing(field885) newline(pp) - opt_val881 = field880 - pretty_epoch_reads(pp, opt_val881) + opt_val886 = field885 + pretty_epoch_reads(pp, opt_val886) end dedent!(pp) write(pp, ")") @@ -1086,22 +1090,22 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat886 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat886) - write(pp, flat886) + flat891 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat891) + write(pp, flat891) return nothing else - fields883 = msg + fields888 = msg write(pp, "(writes") indent_sexp!(pp) - if !isempty(fields883) + if !isempty(fields888) newline(pp) - for (i1620, elem884) in enumerate(fields883) - i885 = i1620 - 1 - if (i885 > 0) + for (i1630, elem889) in enumerate(fields888) + i890 = i1630 - 1 + if (i890 > 0) newline(pp) end - pretty_write(pp, elem884) + pretty_write(pp, elem889) end end dedent!(pp) @@ -1111,54 +1115,54 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat895 = try_flat(pp, msg, pretty_write) - if !isnothing(flat895) - write(pp, flat895) + flat900 = try_flat(pp, msg, pretty_write) + if !isnothing(flat900) + write(pp, flat900) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1621 = _get_oneof_field(_dollar_dollar, :define) + _t1631 = _get_oneof_field(_dollar_dollar, :define) else - _t1621 = nothing + _t1631 = nothing end - deconstruct_result893 = _t1621 - if !isnothing(deconstruct_result893) - unwrapped894 = deconstruct_result893 - pretty_define(pp, unwrapped894) + deconstruct_result898 = _t1631 + if !isnothing(deconstruct_result898) + unwrapped899 = deconstruct_result898 + pretty_define(pp, unwrapped899) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1622 = _get_oneof_field(_dollar_dollar, :undefine) + _t1632 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1622 = nothing + _t1632 = nothing end - deconstruct_result891 = _t1622 - if !isnothing(deconstruct_result891) - unwrapped892 = deconstruct_result891 - pretty_undefine(pp, unwrapped892) + deconstruct_result896 = _t1632 + if !isnothing(deconstruct_result896) + unwrapped897 = deconstruct_result896 + pretty_undefine(pp, unwrapped897) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1623 = _get_oneof_field(_dollar_dollar, :context) + _t1633 = _get_oneof_field(_dollar_dollar, :context) else - _t1623 = nothing + _t1633 = nothing end - deconstruct_result889 = _t1623 - if !isnothing(deconstruct_result889) - unwrapped890 = deconstruct_result889 - pretty_context(pp, unwrapped890) + deconstruct_result894 = _t1633 + if !isnothing(deconstruct_result894) + unwrapped895 = deconstruct_result894 + pretty_context(pp, unwrapped895) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1624 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1634 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1624 = nothing + _t1634 = nothing end - deconstruct_result887 = _t1624 - if !isnothing(deconstruct_result887) - unwrapped888 = deconstruct_result887 - pretty_snapshot(pp, unwrapped888) + deconstruct_result892 = _t1634 + if !isnothing(deconstruct_result892) + unwrapped893 = deconstruct_result892 + pretty_snapshot(pp, unwrapped893) else throw(ParseError("No matching rule for write")) end @@ -1170,18 +1174,18 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat898 = try_flat(pp, msg, pretty_define) - if !isnothing(flat898) - write(pp, flat898) + flat903 = try_flat(pp, msg, pretty_define) + if !isnothing(flat903) + write(pp, flat903) return nothing else _dollar_dollar = msg - fields896 = _dollar_dollar.fragment - unwrapped_fields897 = fields896 + fields901 = _dollar_dollar.fragment + unwrapped_fields902 = fields901 write(pp, "(define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields897) + pretty_fragment(pp, unwrapped_fields902) dedent!(pp) write(pp, ")") end @@ -1189,29 +1193,29 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat905 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat905) - write(pp, flat905) + flat910 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat910) + write(pp, flat910) return nothing else _dollar_dollar = msg start_pretty_fragment(pp, _dollar_dollar) - fields899 = (_dollar_dollar.id, _dollar_dollar.declarations,) - unwrapped_fields900 = fields899 + fields904 = (_dollar_dollar.id, _dollar_dollar.declarations,) + unwrapped_fields905 = fields904 write(pp, "(fragment") indent_sexp!(pp) newline(pp) - field901 = unwrapped_fields900[1] - pretty_new_fragment_id(pp, field901) - field902 = unwrapped_fields900[2] - if !isempty(field902) + field906 = unwrapped_fields905[1] + pretty_new_fragment_id(pp, field906) + field907 = unwrapped_fields905[2] + if !isempty(field907) newline(pp) - for (i1625, elem903) in enumerate(field902) - i904 = i1625 - 1 - if (i904 > 0) + for (i1635, elem908) in enumerate(field907) + i909 = i1635 - 1 + if (i909 > 0) newline(pp) end - pretty_declaration(pp, elem903) + pretty_declaration(pp, elem908) end end dedent!(pp) @@ -1221,66 +1225,66 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat907 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat907) - write(pp, flat907) + flat912 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat912) + write(pp, flat912) return nothing else - fields906 = msg - pretty_fragment_id(pp, fields906) + fields911 = msg + pretty_fragment_id(pp, fields911) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat916 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat916) - write(pp, flat916) + flat921 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat921) + write(pp, flat921) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1626 = _get_oneof_field(_dollar_dollar, :def) + _t1636 = _get_oneof_field(_dollar_dollar, :def) else - _t1626 = nothing + _t1636 = nothing end - deconstruct_result914 = _t1626 - if !isnothing(deconstruct_result914) - unwrapped915 = deconstruct_result914 - pretty_def(pp, unwrapped915) + deconstruct_result919 = _t1636 + if !isnothing(deconstruct_result919) + unwrapped920 = deconstruct_result919 + pretty_def(pp, unwrapped920) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1627 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1637 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1627 = nothing + _t1637 = nothing end - deconstruct_result912 = _t1627 - if !isnothing(deconstruct_result912) - unwrapped913 = deconstruct_result912 - pretty_algorithm(pp, unwrapped913) + deconstruct_result917 = _t1637 + if !isnothing(deconstruct_result917) + unwrapped918 = deconstruct_result917 + pretty_algorithm(pp, unwrapped918) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1628 = _get_oneof_field(_dollar_dollar, :constraint) + _t1638 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1628 = nothing + _t1638 = nothing end - deconstruct_result910 = _t1628 - if !isnothing(deconstruct_result910) - unwrapped911 = deconstruct_result910 - pretty_constraint(pp, unwrapped911) + deconstruct_result915 = _t1638 + if !isnothing(deconstruct_result915) + unwrapped916 = deconstruct_result915 + pretty_constraint(pp, unwrapped916) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1629 = _get_oneof_field(_dollar_dollar, :data) + _t1639 = _get_oneof_field(_dollar_dollar, :data) else - _t1629 = nothing + _t1639 = nothing end - deconstruct_result908 = _t1629 - if !isnothing(deconstruct_result908) - unwrapped909 = deconstruct_result908 - pretty_data(pp, unwrapped909) + deconstruct_result913 = _t1639 + if !isnothing(deconstruct_result913) + unwrapped914 = deconstruct_result913 + pretty_data(pp, unwrapped914) else throw(ParseError("No matching rule for declaration")) end @@ -1292,32 +1296,32 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat923 = try_flat(pp, msg, pretty_def) - if !isnothing(flat923) - write(pp, flat923) + flat928 = try_flat(pp, msg, pretty_def) + if !isnothing(flat928) + write(pp, flat928) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1630 = _dollar_dollar.attrs + _t1640 = _dollar_dollar.attrs else - _t1630 = nothing + _t1640 = nothing end - fields917 = (_dollar_dollar.name, _dollar_dollar.body, _t1630,) - unwrapped_fields918 = fields917 + fields922 = (_dollar_dollar.name, _dollar_dollar.body, _t1640,) + unwrapped_fields923 = fields922 write(pp, "(def") indent_sexp!(pp) newline(pp) - field919 = unwrapped_fields918[1] - pretty_relation_id(pp, field919) + field924 = unwrapped_fields923[1] + pretty_relation_id(pp, field924) newline(pp) - field920 = unwrapped_fields918[2] - pretty_abstraction(pp, field920) - field921 = unwrapped_fields918[3] - if !isnothing(field921) + field925 = unwrapped_fields923[2] + pretty_abstraction(pp, field925) + field926 = unwrapped_fields923[3] + if !isnothing(field926) newline(pp) - opt_val922 = field921 - pretty_attrs(pp, opt_val922) + opt_val927 = field926 + pretty_attrs(pp, opt_val927) end dedent!(pp) write(pp, ")") @@ -1326,30 +1330,30 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat928 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat928) - write(pp, flat928) + flat933 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat933) + write(pp, flat933) return nothing else _dollar_dollar = msg if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1632 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1631 = _t1632 + _t1642 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1641 = _t1642 else - _t1631 = nothing + _t1641 = nothing end - deconstruct_result926 = _t1631 - if !isnothing(deconstruct_result926) - unwrapped927 = deconstruct_result926 + deconstruct_result931 = _t1641 + if !isnothing(deconstruct_result931) + unwrapped932 = deconstruct_result931 write(pp, ":") - write(pp, unwrapped927) + write(pp, unwrapped932) else _dollar_dollar = msg - _t1633 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - deconstruct_result924 = _t1633 - if !isnothing(deconstruct_result924) - unwrapped925 = deconstruct_result924 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped925)) + _t1643 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + deconstruct_result929 = _t1643 + if !isnothing(deconstruct_result929) + unwrapped930 = deconstruct_result929 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped930)) else throw(ParseError("No matching rule for relation_id")) end @@ -1359,22 +1363,22 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat933 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat933) - write(pp, flat933) + flat938 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat938) + write(pp, flat938) return nothing else _dollar_dollar = msg - _t1634 = deconstruct_bindings(pp, _dollar_dollar) - fields929 = (_t1634, _dollar_dollar.value,) - unwrapped_fields930 = fields929 + _t1644 = deconstruct_bindings(pp, _dollar_dollar) + fields934 = (_t1644, _dollar_dollar.value,) + unwrapped_fields935 = fields934 write(pp, "(") indent!(pp) - field931 = unwrapped_fields930[1] - pretty_bindings(pp, field931) + field936 = unwrapped_fields935[1] + pretty_bindings(pp, field936) newline(pp) - field932 = unwrapped_fields930[2] - pretty_formula(pp, field932) + field937 = unwrapped_fields935[2] + pretty_formula(pp, field937) dedent!(pp) write(pp, ")") end @@ -1382,34 +1386,34 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat941 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat941) - write(pp, flat941) + flat946 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat946) + write(pp, flat946) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar[2]) - _t1635 = _dollar_dollar[2] + _t1645 = _dollar_dollar[2] else - _t1635 = nothing + _t1645 = nothing end - fields934 = (_dollar_dollar[1], _t1635,) - unwrapped_fields935 = fields934 + fields939 = (_dollar_dollar[1], _t1645,) + unwrapped_fields940 = fields939 write(pp, "[") indent!(pp) - field936 = unwrapped_fields935[1] - for (i1636, elem937) in enumerate(field936) - i938 = i1636 - 1 - if (i938 > 0) + field941 = unwrapped_fields940[1] + for (i1646, elem942) in enumerate(field941) + i943 = i1646 - 1 + if (i943 > 0) newline(pp) end - pretty_binding(pp, elem937) + pretty_binding(pp, elem942) end - field939 = unwrapped_fields935[2] - if !isnothing(field939) + field944 = unwrapped_fields940[2] + if !isnothing(field944) newline(pp) - opt_val940 = field939 - pretty_value_bindings(pp, opt_val940) + opt_val945 = field944 + pretty_value_bindings(pp, opt_val945) end dedent!(pp) write(pp, "]") @@ -1418,182 +1422,182 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat946 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat946) - write(pp, flat946) + flat951 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat951) + write(pp, flat951) return nothing else _dollar_dollar = msg - fields942 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) - unwrapped_fields943 = fields942 - field944 = unwrapped_fields943[1] - write(pp, field944) + fields947 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) + unwrapped_fields948 = fields947 + field949 = unwrapped_fields948[1] + write(pp, field949) write(pp, "::") - field945 = unwrapped_fields943[2] - pretty_type(pp, field945) + field950 = unwrapped_fields948[2] + pretty_type(pp, field950) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat975 = try_flat(pp, msg, pretty_type) - if !isnothing(flat975) - write(pp, flat975) + flat980 = try_flat(pp, msg, pretty_type) + if !isnothing(flat980) + write(pp, flat980) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1637 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1647 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1637 = nothing + _t1647 = nothing end - deconstruct_result973 = _t1637 - if !isnothing(deconstruct_result973) - unwrapped974 = deconstruct_result973 - pretty_unspecified_type(pp, unwrapped974) + deconstruct_result978 = _t1647 + if !isnothing(deconstruct_result978) + unwrapped979 = deconstruct_result978 + pretty_unspecified_type(pp, unwrapped979) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1638 = _get_oneof_field(_dollar_dollar, :string_type) + _t1648 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1638 = nothing + _t1648 = nothing end - deconstruct_result971 = _t1638 - if !isnothing(deconstruct_result971) - unwrapped972 = deconstruct_result971 - pretty_string_type(pp, unwrapped972) + deconstruct_result976 = _t1648 + if !isnothing(deconstruct_result976) + unwrapped977 = deconstruct_result976 + pretty_string_type(pp, unwrapped977) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1639 = _get_oneof_field(_dollar_dollar, :int_type) + _t1649 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1639 = nothing + _t1649 = nothing end - deconstruct_result969 = _t1639 - if !isnothing(deconstruct_result969) - unwrapped970 = deconstruct_result969 - pretty_int_type(pp, unwrapped970) + deconstruct_result974 = _t1649 + if !isnothing(deconstruct_result974) + unwrapped975 = deconstruct_result974 + pretty_int_type(pp, unwrapped975) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1640 = _get_oneof_field(_dollar_dollar, :float_type) + _t1650 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1640 = nothing + _t1650 = nothing end - deconstruct_result967 = _t1640 - if !isnothing(deconstruct_result967) - unwrapped968 = deconstruct_result967 - pretty_float_type(pp, unwrapped968) + deconstruct_result972 = _t1650 + if !isnothing(deconstruct_result972) + unwrapped973 = deconstruct_result972 + pretty_float_type(pp, unwrapped973) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1641 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1651 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1641 = nothing + _t1651 = nothing end - deconstruct_result965 = _t1641 - if !isnothing(deconstruct_result965) - unwrapped966 = deconstruct_result965 - pretty_uint128_type(pp, unwrapped966) + deconstruct_result970 = _t1651 + if !isnothing(deconstruct_result970) + unwrapped971 = deconstruct_result970 + pretty_uint128_type(pp, unwrapped971) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1642 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1652 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1642 = nothing + _t1652 = nothing end - deconstruct_result963 = _t1642 - if !isnothing(deconstruct_result963) - unwrapped964 = deconstruct_result963 - pretty_int128_type(pp, unwrapped964) + deconstruct_result968 = _t1652 + if !isnothing(deconstruct_result968) + unwrapped969 = deconstruct_result968 + pretty_int128_type(pp, unwrapped969) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1643 = _get_oneof_field(_dollar_dollar, :date_type) + _t1653 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1643 = nothing + _t1653 = nothing end - deconstruct_result961 = _t1643 - if !isnothing(deconstruct_result961) - unwrapped962 = deconstruct_result961 - pretty_date_type(pp, unwrapped962) + deconstruct_result966 = _t1653 + if !isnothing(deconstruct_result966) + unwrapped967 = deconstruct_result966 + pretty_date_type(pp, unwrapped967) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1644 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1654 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1644 = nothing + _t1654 = nothing end - deconstruct_result959 = _t1644 - if !isnothing(deconstruct_result959) - unwrapped960 = deconstruct_result959 - pretty_datetime_type(pp, unwrapped960) + deconstruct_result964 = _t1654 + if !isnothing(deconstruct_result964) + unwrapped965 = deconstruct_result964 + pretty_datetime_type(pp, unwrapped965) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1645 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1655 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1645 = nothing + _t1655 = nothing end - deconstruct_result957 = _t1645 - if !isnothing(deconstruct_result957) - unwrapped958 = deconstruct_result957 - pretty_missing_type(pp, unwrapped958) + deconstruct_result962 = _t1655 + if !isnothing(deconstruct_result962) + unwrapped963 = deconstruct_result962 + pretty_missing_type(pp, unwrapped963) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1646 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1656 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1646 = nothing + _t1656 = nothing end - deconstruct_result955 = _t1646 - if !isnothing(deconstruct_result955) - unwrapped956 = deconstruct_result955 - pretty_decimal_type(pp, unwrapped956) + deconstruct_result960 = _t1656 + if !isnothing(deconstruct_result960) + unwrapped961 = deconstruct_result960 + pretty_decimal_type(pp, unwrapped961) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1647 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1657 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1647 = nothing + _t1657 = nothing end - deconstruct_result953 = _t1647 - if !isnothing(deconstruct_result953) - unwrapped954 = deconstruct_result953 - pretty_boolean_type(pp, unwrapped954) + deconstruct_result958 = _t1657 + if !isnothing(deconstruct_result958) + unwrapped959 = deconstruct_result958 + pretty_boolean_type(pp, unwrapped959) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_type")) - _t1648 = _get_oneof_field(_dollar_dollar, :int32_type) + _t1658 = _get_oneof_field(_dollar_dollar, :int32_type) else - _t1648 = nothing + _t1658 = nothing end - deconstruct_result951 = _t1648 - if !isnothing(deconstruct_result951) - unwrapped952 = deconstruct_result951 - pretty_int32_type(pp, unwrapped952) + deconstruct_result956 = _t1658 + if !isnothing(deconstruct_result956) + unwrapped957 = deconstruct_result956 + pretty_int32_type(pp, unwrapped957) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_type")) - _t1649 = _get_oneof_field(_dollar_dollar, :float32_type) + _t1659 = _get_oneof_field(_dollar_dollar, :float32_type) else - _t1649 = nothing + _t1659 = nothing end - deconstruct_result949 = _t1649 - if !isnothing(deconstruct_result949) - unwrapped950 = deconstruct_result949 - pretty_float32_type(pp, unwrapped950) + deconstruct_result954 = _t1659 + if !isnothing(deconstruct_result954) + unwrapped955 = deconstruct_result954 + pretty_float32_type(pp, unwrapped955) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_type")) - _t1650 = _get_oneof_field(_dollar_dollar, :uint32_type) + _t1660 = _get_oneof_field(_dollar_dollar, :uint32_type) else - _t1650 = nothing + _t1660 = nothing end - deconstruct_result947 = _t1650 - if !isnothing(deconstruct_result947) - unwrapped948 = deconstruct_result947 - pretty_uint32_type(pp, unwrapped948) + deconstruct_result952 = _t1660 + if !isnothing(deconstruct_result952) + unwrapped953 = deconstruct_result952 + pretty_uint32_type(pp, unwrapped953) else throw(ParseError("No matching rule for type")) end @@ -1615,76 +1619,76 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields976 = msg + fields981 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields977 = msg + fields982 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields978 = msg + fields983 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields979 = msg + fields984 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields980 = msg + fields985 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields981 = msg + fields986 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields982 = msg + fields987 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields983 = msg + fields988 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields984 = msg + fields989 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat989 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat989) - write(pp, flat989) + flat994 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat994) + write(pp, flat994) return nothing else _dollar_dollar = msg - fields985 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) - unwrapped_fields986 = fields985 + fields990 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) + unwrapped_fields991 = fields990 write(pp, "(DECIMAL") indent_sexp!(pp) newline(pp) - field987 = unwrapped_fields986[1] - write(pp, string(field987)) + field992 = unwrapped_fields991[1] + write(pp, string(field992)) newline(pp) - field988 = unwrapped_fields986[2] - write(pp, string(field988)) + field993 = unwrapped_fields991[2] + write(pp, string(field993)) dedent!(pp) write(pp, ")") end @@ -1692,45 +1696,45 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields990 = msg + fields995 = msg write(pp, "BOOLEAN") return nothing end function pretty_int32_type(pp::PrettyPrinter, msg::Proto.Int32Type) - fields991 = msg + fields996 = msg write(pp, "INT32") return nothing end function pretty_float32_type(pp::PrettyPrinter, msg::Proto.Float32Type) - fields992 = msg + fields997 = msg write(pp, "FLOAT32") return nothing end function pretty_uint32_type(pp::PrettyPrinter, msg::Proto.UInt32Type) - fields993 = msg + fields998 = msg write(pp, "UINT32") return nothing end function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat997 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat997) - write(pp, flat997) + flat1002 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat1002) + write(pp, flat1002) return nothing else - fields994 = msg + fields999 = msg write(pp, "|") - if !isempty(fields994) + if !isempty(fields999) write(pp, " ") - for (i1651, elem995) in enumerate(fields994) - i996 = i1651 - 1 - if (i996 > 0) + for (i1661, elem1000) in enumerate(fields999) + i1001 = i1661 - 1 + if (i1001 > 0) newline(pp) end - pretty_binding(pp, elem995) + pretty_binding(pp, elem1000) end end end @@ -1738,153 +1742,153 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat1024 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat1024) - write(pp, flat1024) + flat1029 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat1029) + write(pp, flat1029) return nothing else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1652 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1662 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1652 = nothing + _t1662 = nothing end - deconstruct_result1022 = _t1652 - if !isnothing(deconstruct_result1022) - unwrapped1023 = deconstruct_result1022 - pretty_true(pp, unwrapped1023) + deconstruct_result1027 = _t1662 + if !isnothing(deconstruct_result1027) + unwrapped1028 = deconstruct_result1027 + pretty_true(pp, unwrapped1028) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1653 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1663 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1653 = nothing + _t1663 = nothing end - deconstruct_result1020 = _t1653 - if !isnothing(deconstruct_result1020) - unwrapped1021 = deconstruct_result1020 - pretty_false(pp, unwrapped1021) + deconstruct_result1025 = _t1663 + if !isnothing(deconstruct_result1025) + unwrapped1026 = deconstruct_result1025 + pretty_false(pp, unwrapped1026) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1654 = _get_oneof_field(_dollar_dollar, :exists) + _t1664 = _get_oneof_field(_dollar_dollar, :exists) else - _t1654 = nothing + _t1664 = nothing end - deconstruct_result1018 = _t1654 - if !isnothing(deconstruct_result1018) - unwrapped1019 = deconstruct_result1018 - pretty_exists(pp, unwrapped1019) + deconstruct_result1023 = _t1664 + if !isnothing(deconstruct_result1023) + unwrapped1024 = deconstruct_result1023 + pretty_exists(pp, unwrapped1024) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1655 = _get_oneof_field(_dollar_dollar, :reduce) + _t1665 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1655 = nothing + _t1665 = nothing end - deconstruct_result1016 = _t1655 - if !isnothing(deconstruct_result1016) - unwrapped1017 = deconstruct_result1016 - pretty_reduce(pp, unwrapped1017) + deconstruct_result1021 = _t1665 + if !isnothing(deconstruct_result1021) + unwrapped1022 = deconstruct_result1021 + pretty_reduce(pp, unwrapped1022) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1656 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1666 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1656 = nothing + _t1666 = nothing end - deconstruct_result1014 = _t1656 - if !isnothing(deconstruct_result1014) - unwrapped1015 = deconstruct_result1014 - pretty_conjunction(pp, unwrapped1015) + deconstruct_result1019 = _t1666 + if !isnothing(deconstruct_result1019) + unwrapped1020 = deconstruct_result1019 + pretty_conjunction(pp, unwrapped1020) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1657 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1667 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1657 = nothing + _t1667 = nothing end - deconstruct_result1012 = _t1657 - if !isnothing(deconstruct_result1012) - unwrapped1013 = deconstruct_result1012 - pretty_disjunction(pp, unwrapped1013) + deconstruct_result1017 = _t1667 + if !isnothing(deconstruct_result1017) + unwrapped1018 = deconstruct_result1017 + pretty_disjunction(pp, unwrapped1018) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1658 = _get_oneof_field(_dollar_dollar, :not) + _t1668 = _get_oneof_field(_dollar_dollar, :not) else - _t1658 = nothing + _t1668 = nothing end - deconstruct_result1010 = _t1658 - if !isnothing(deconstruct_result1010) - unwrapped1011 = deconstruct_result1010 - pretty_not(pp, unwrapped1011) + deconstruct_result1015 = _t1668 + if !isnothing(deconstruct_result1015) + unwrapped1016 = deconstruct_result1015 + pretty_not(pp, unwrapped1016) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1659 = _get_oneof_field(_dollar_dollar, :ffi) + _t1669 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1659 = nothing + _t1669 = nothing end - deconstruct_result1008 = _t1659 - if !isnothing(deconstruct_result1008) - unwrapped1009 = deconstruct_result1008 - pretty_ffi(pp, unwrapped1009) + deconstruct_result1013 = _t1669 + if !isnothing(deconstruct_result1013) + unwrapped1014 = deconstruct_result1013 + pretty_ffi(pp, unwrapped1014) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1660 = _get_oneof_field(_dollar_dollar, :atom) + _t1670 = _get_oneof_field(_dollar_dollar, :atom) else - _t1660 = nothing + _t1670 = nothing end - deconstruct_result1006 = _t1660 - if !isnothing(deconstruct_result1006) - unwrapped1007 = deconstruct_result1006 - pretty_atom(pp, unwrapped1007) + deconstruct_result1011 = _t1670 + if !isnothing(deconstruct_result1011) + unwrapped1012 = deconstruct_result1011 + pretty_atom(pp, unwrapped1012) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1661 = _get_oneof_field(_dollar_dollar, :pragma) + _t1671 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1661 = nothing + _t1671 = nothing end - deconstruct_result1004 = _t1661 - if !isnothing(deconstruct_result1004) - unwrapped1005 = deconstruct_result1004 - pretty_pragma(pp, unwrapped1005) + deconstruct_result1009 = _t1671 + if !isnothing(deconstruct_result1009) + unwrapped1010 = deconstruct_result1009 + pretty_pragma(pp, unwrapped1010) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1662 = _get_oneof_field(_dollar_dollar, :primitive) + _t1672 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1662 = nothing + _t1672 = nothing end - deconstruct_result1002 = _t1662 - if !isnothing(deconstruct_result1002) - unwrapped1003 = deconstruct_result1002 - pretty_primitive(pp, unwrapped1003) + deconstruct_result1007 = _t1672 + if !isnothing(deconstruct_result1007) + unwrapped1008 = deconstruct_result1007 + pretty_primitive(pp, unwrapped1008) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1663 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1673 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1663 = nothing + _t1673 = nothing end - deconstruct_result1000 = _t1663 - if !isnothing(deconstruct_result1000) - unwrapped1001 = deconstruct_result1000 - pretty_rel_atom(pp, unwrapped1001) + deconstruct_result1005 = _t1673 + if !isnothing(deconstruct_result1005) + unwrapped1006 = deconstruct_result1005 + pretty_rel_atom(pp, unwrapped1006) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1664 = _get_oneof_field(_dollar_dollar, :cast) + _t1674 = _get_oneof_field(_dollar_dollar, :cast) else - _t1664 = nothing + _t1674 = nothing end - deconstruct_result998 = _t1664 - if !isnothing(deconstruct_result998) - unwrapped999 = deconstruct_result998 - pretty_cast(pp, unwrapped999) + deconstruct_result1003 = _t1674 + if !isnothing(deconstruct_result1003) + unwrapped1004 = deconstruct_result1003 + pretty_cast(pp, unwrapped1004) else throw(ParseError("No matching rule for formula")) end @@ -1905,35 +1909,35 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields1025 = msg + fields1030 = msg write(pp, "(true)") return nothing end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields1026 = msg + fields1031 = msg write(pp, "(false)") return nothing end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat1031 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat1031) - write(pp, flat1031) + flat1036 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat1036) + write(pp, flat1036) return nothing else _dollar_dollar = msg - _t1665 = deconstruct_bindings(pp, _dollar_dollar.body) - fields1027 = (_t1665, _dollar_dollar.body.value,) - unwrapped_fields1028 = fields1027 + _t1675 = deconstruct_bindings(pp, _dollar_dollar.body) + fields1032 = (_t1675, _dollar_dollar.body.value,) + unwrapped_fields1033 = fields1032 write(pp, "(exists") indent_sexp!(pp) newline(pp) - field1029 = unwrapped_fields1028[1] - pretty_bindings(pp, field1029) + field1034 = unwrapped_fields1033[1] + pretty_bindings(pp, field1034) newline(pp) - field1030 = unwrapped_fields1028[2] - pretty_formula(pp, field1030) + field1035 = unwrapped_fields1033[2] + pretty_formula(pp, field1035) dedent!(pp) write(pp, ")") end @@ -1941,25 +1945,25 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat1037 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat1037) - write(pp, flat1037) + flat1042 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat1042) + write(pp, flat1042) return nothing else _dollar_dollar = msg - fields1032 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - unwrapped_fields1033 = fields1032 + fields1037 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + unwrapped_fields1038 = fields1037 write(pp, "(reduce") indent_sexp!(pp) newline(pp) - field1034 = unwrapped_fields1033[1] - pretty_abstraction(pp, field1034) + field1039 = unwrapped_fields1038[1] + pretty_abstraction(pp, field1039) newline(pp) - field1035 = unwrapped_fields1033[2] - pretty_abstraction(pp, field1035) + field1040 = unwrapped_fields1038[2] + pretty_abstraction(pp, field1040) newline(pp) - field1036 = unwrapped_fields1033[3] - pretty_terms(pp, field1036) + field1041 = unwrapped_fields1038[3] + pretty_terms(pp, field1041) dedent!(pp) write(pp, ")") end @@ -1967,22 +1971,22 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat1041 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat1041) - write(pp, flat1041) + flat1046 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat1046) + write(pp, flat1046) return nothing else - fields1038 = msg + fields1043 = msg write(pp, "(terms") indent_sexp!(pp) - if !isempty(fields1038) + if !isempty(fields1043) newline(pp) - for (i1666, elem1039) in enumerate(fields1038) - i1040 = i1666 - 1 - if (i1040 > 0) + for (i1676, elem1044) in enumerate(fields1043) + i1045 = i1676 - 1 + if (i1045 > 0) newline(pp) end - pretty_term(pp, elem1039) + pretty_term(pp, elem1044) end end dedent!(pp) @@ -1992,32 +1996,32 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat1046 = try_flat(pp, msg, pretty_term) - if !isnothing(flat1046) - write(pp, flat1046) + flat1051 = try_flat(pp, msg, pretty_term) + if !isnothing(flat1051) + write(pp, flat1051) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1667 = _get_oneof_field(_dollar_dollar, :var) + _t1677 = _get_oneof_field(_dollar_dollar, :var) else - _t1667 = nothing + _t1677 = nothing end - deconstruct_result1044 = _t1667 - if !isnothing(deconstruct_result1044) - unwrapped1045 = deconstruct_result1044 - pretty_var(pp, unwrapped1045) + deconstruct_result1049 = _t1677 + if !isnothing(deconstruct_result1049) + unwrapped1050 = deconstruct_result1049 + pretty_var(pp, unwrapped1050) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1668 = _get_oneof_field(_dollar_dollar, :constant) + _t1678 = _get_oneof_field(_dollar_dollar, :constant) else - _t1668 = nothing + _t1678 = nothing end - deconstruct_result1042 = _t1668 - if !isnothing(deconstruct_result1042) - unwrapped1043 = deconstruct_result1042 - pretty_value(pp, unwrapped1043) + deconstruct_result1047 = _t1678 + if !isnothing(deconstruct_result1047) + unwrapped1048 = deconstruct_result1047 + pretty_value(pp, unwrapped1048) else throw(ParseError("No matching rule for term")) end @@ -2027,158 +2031,158 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat1049 = try_flat(pp, msg, pretty_var) - if !isnothing(flat1049) - write(pp, flat1049) + flat1054 = try_flat(pp, msg, pretty_var) + if !isnothing(flat1054) + write(pp, flat1054) return nothing else _dollar_dollar = msg - fields1047 = _dollar_dollar.name - unwrapped_fields1048 = fields1047 - write(pp, unwrapped_fields1048) + fields1052 = _dollar_dollar.name + unwrapped_fields1053 = fields1052 + write(pp, unwrapped_fields1053) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat1075 = try_flat(pp, msg, pretty_value) - if !isnothing(flat1075) - write(pp, flat1075) + flat1080 = try_flat(pp, msg, pretty_value) + if !isnothing(flat1080) + write(pp, flat1080) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1669 = _get_oneof_field(_dollar_dollar, :date_value) + _t1679 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1669 = nothing + _t1679 = nothing end - deconstruct_result1073 = _t1669 - if !isnothing(deconstruct_result1073) - unwrapped1074 = deconstruct_result1073 - pretty_date(pp, unwrapped1074) + deconstruct_result1078 = _t1679 + if !isnothing(deconstruct_result1078) + unwrapped1079 = deconstruct_result1078 + pretty_date(pp, unwrapped1079) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1670 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1680 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1670 = nothing + _t1680 = nothing end - deconstruct_result1071 = _t1670 - if !isnothing(deconstruct_result1071) - unwrapped1072 = deconstruct_result1071 - pretty_datetime(pp, unwrapped1072) + deconstruct_result1076 = _t1680 + if !isnothing(deconstruct_result1076) + unwrapped1077 = deconstruct_result1076 + pretty_datetime(pp, unwrapped1077) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1671 = _get_oneof_field(_dollar_dollar, :string_value) + _t1681 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1671 = nothing + _t1681 = nothing end - deconstruct_result1069 = _t1671 - if !isnothing(deconstruct_result1069) - unwrapped1070 = deconstruct_result1069 - write(pp, format_string(pp, unwrapped1070)) + deconstruct_result1074 = _t1681 + if !isnothing(deconstruct_result1074) + unwrapped1075 = deconstruct_result1074 + write(pp, format_string(pp, unwrapped1075)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1672 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1682 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1672 = nothing + _t1682 = nothing end - deconstruct_result1067 = _t1672 - if !isnothing(deconstruct_result1067) - unwrapped1068 = deconstruct_result1067 - write(pp, format_int32(pp, unwrapped1068)) + deconstruct_result1072 = _t1682 + if !isnothing(deconstruct_result1072) + unwrapped1073 = deconstruct_result1072 + write(pp, format_int32(pp, unwrapped1073)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1673 = _get_oneof_field(_dollar_dollar, :int_value) + _t1683 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1673 = nothing + _t1683 = nothing end - deconstruct_result1065 = _t1673 - if !isnothing(deconstruct_result1065) - unwrapped1066 = deconstruct_result1065 - write(pp, format_int(pp, unwrapped1066)) + deconstruct_result1070 = _t1683 + if !isnothing(deconstruct_result1070) + unwrapped1071 = deconstruct_result1070 + write(pp, format_int(pp, unwrapped1071)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1674 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1684 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1674 = nothing + _t1684 = nothing end - deconstruct_result1063 = _t1674 - if !isnothing(deconstruct_result1063) - unwrapped1064 = deconstruct_result1063 - write(pp, format_float32(pp, unwrapped1064)) + deconstruct_result1068 = _t1684 + if !isnothing(deconstruct_result1068) + unwrapped1069 = deconstruct_result1068 + write(pp, format_float32(pp, unwrapped1069)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1675 = _get_oneof_field(_dollar_dollar, :float_value) + _t1685 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1675 = nothing + _t1685 = nothing end - deconstruct_result1061 = _t1675 - if !isnothing(deconstruct_result1061) - unwrapped1062 = deconstruct_result1061 - write(pp, format_float(pp, unwrapped1062)) + deconstruct_result1066 = _t1685 + if !isnothing(deconstruct_result1066) + unwrapped1067 = deconstruct_result1066 + write(pp, format_float(pp, unwrapped1067)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1676 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1686 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1676 = nothing + _t1686 = nothing end - deconstruct_result1059 = _t1676 - if !isnothing(deconstruct_result1059) - unwrapped1060 = deconstruct_result1059 - write(pp, format_uint32(pp, unwrapped1060)) + deconstruct_result1064 = _t1686 + if !isnothing(deconstruct_result1064) + unwrapped1065 = deconstruct_result1064 + write(pp, format_uint32(pp, unwrapped1065)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1677 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1687 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1677 = nothing + _t1687 = nothing end - deconstruct_result1057 = _t1677 - if !isnothing(deconstruct_result1057) - unwrapped1058 = deconstruct_result1057 - write(pp, format_uint128(pp, unwrapped1058)) + deconstruct_result1062 = _t1687 + if !isnothing(deconstruct_result1062) + unwrapped1063 = deconstruct_result1062 + write(pp, format_uint128(pp, unwrapped1063)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1678 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1688 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1678 = nothing + _t1688 = nothing end - deconstruct_result1055 = _t1678 - if !isnothing(deconstruct_result1055) - unwrapped1056 = deconstruct_result1055 - write(pp, format_int128(pp, unwrapped1056)) + deconstruct_result1060 = _t1688 + if !isnothing(deconstruct_result1060) + unwrapped1061 = deconstruct_result1060 + write(pp, format_int128(pp, unwrapped1061)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1679 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1689 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1679 = nothing + _t1689 = nothing end - deconstruct_result1053 = _t1679 - if !isnothing(deconstruct_result1053) - unwrapped1054 = deconstruct_result1053 - write(pp, format_decimal(pp, unwrapped1054)) + deconstruct_result1058 = _t1689 + if !isnothing(deconstruct_result1058) + unwrapped1059 = deconstruct_result1058 + write(pp, format_decimal(pp, unwrapped1059)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1680 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1690 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1680 = nothing + _t1690 = nothing end - deconstruct_result1051 = _t1680 - if !isnothing(deconstruct_result1051) - unwrapped1052 = deconstruct_result1051 - pretty_boolean_value(pp, unwrapped1052) + deconstruct_result1056 = _t1690 + if !isnothing(deconstruct_result1056) + unwrapped1057 = deconstruct_result1056 + pretty_boolean_value(pp, unwrapped1057) else - fields1050 = msg + fields1055 = msg write(pp, "missing") end end @@ -2197,25 +2201,25 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat1081 = try_flat(pp, msg, pretty_date) - if !isnothing(flat1081) - write(pp, flat1081) + flat1086 = try_flat(pp, msg, pretty_date) + if !isnothing(flat1086) + write(pp, flat1086) return nothing else _dollar_dollar = msg - fields1076 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields1077 = fields1076 + fields1081 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields1082 = fields1081 write(pp, "(date") indent_sexp!(pp) newline(pp) - field1078 = unwrapped_fields1077[1] - write(pp, format_int(pp, field1078)) + field1083 = unwrapped_fields1082[1] + write(pp, format_int(pp, field1083)) newline(pp) - field1079 = unwrapped_fields1077[2] - write(pp, format_int(pp, field1079)) + field1084 = unwrapped_fields1082[2] + write(pp, format_int(pp, field1084)) newline(pp) - field1080 = unwrapped_fields1077[3] - write(pp, format_int(pp, field1080)) + field1085 = unwrapped_fields1082[3] + write(pp, format_int(pp, field1085)) dedent!(pp) write(pp, ")") end @@ -2223,39 +2227,39 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat1092 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat1092) - write(pp, flat1092) + flat1097 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat1097) + write(pp, flat1097) return nothing else _dollar_dollar = msg - fields1082 = (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_fields1083 = fields1082 + fields1087 = (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_fields1088 = fields1087 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field1084 = unwrapped_fields1083[1] - write(pp, format_int(pp, field1084)) + field1089 = unwrapped_fields1088[1] + write(pp, format_int(pp, field1089)) newline(pp) - field1085 = unwrapped_fields1083[2] - write(pp, format_int(pp, field1085)) + field1090 = unwrapped_fields1088[2] + write(pp, format_int(pp, field1090)) newline(pp) - field1086 = unwrapped_fields1083[3] - write(pp, format_int(pp, field1086)) + field1091 = unwrapped_fields1088[3] + write(pp, format_int(pp, field1091)) newline(pp) - field1087 = unwrapped_fields1083[4] - write(pp, format_int(pp, field1087)) + field1092 = unwrapped_fields1088[4] + write(pp, format_int(pp, field1092)) newline(pp) - field1088 = unwrapped_fields1083[5] - write(pp, format_int(pp, field1088)) + field1093 = unwrapped_fields1088[5] + write(pp, format_int(pp, field1093)) newline(pp) - field1089 = unwrapped_fields1083[6] - write(pp, format_int(pp, field1089)) - field1090 = unwrapped_fields1083[7] - if !isnothing(field1090) + field1094 = unwrapped_fields1088[6] + write(pp, format_int(pp, field1094)) + field1095 = unwrapped_fields1088[7] + if !isnothing(field1095) newline(pp) - opt_val1091 = field1090 - write(pp, format_int(pp, opt_val1091)) + opt_val1096 = field1095 + write(pp, format_int(pp, opt_val1096)) end dedent!(pp) write(pp, ")") @@ -2264,24 +2268,24 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat1097 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat1097) - write(pp, flat1097) + flat1102 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat1102) + write(pp, flat1102) return nothing else _dollar_dollar = msg - fields1093 = _dollar_dollar.args - unwrapped_fields1094 = fields1093 + fields1098 = _dollar_dollar.args + unwrapped_fields1099 = fields1098 write(pp, "(and") indent_sexp!(pp) - if !isempty(unwrapped_fields1094) + if !isempty(unwrapped_fields1099) newline(pp) - for (i1681, elem1095) in enumerate(unwrapped_fields1094) - i1096 = i1681 - 1 - if (i1096 > 0) + for (i1691, elem1100) in enumerate(unwrapped_fields1099) + i1101 = i1691 - 1 + if (i1101 > 0) newline(pp) end - pretty_formula(pp, elem1095) + pretty_formula(pp, elem1100) end end dedent!(pp) @@ -2291,24 +2295,24 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat1102 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat1102) - write(pp, flat1102) + flat1107 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat1107) + write(pp, flat1107) return nothing else _dollar_dollar = msg - fields1098 = _dollar_dollar.args - unwrapped_fields1099 = fields1098 + fields1103 = _dollar_dollar.args + unwrapped_fields1104 = fields1103 write(pp, "(or") indent_sexp!(pp) - if !isempty(unwrapped_fields1099) + if !isempty(unwrapped_fields1104) newline(pp) - for (i1682, elem1100) in enumerate(unwrapped_fields1099) - i1101 = i1682 - 1 - if (i1101 > 0) + for (i1692, elem1105) in enumerate(unwrapped_fields1104) + i1106 = i1692 - 1 + if (i1106 > 0) newline(pp) end - pretty_formula(pp, elem1100) + pretty_formula(pp, elem1105) end end dedent!(pp) @@ -2318,18 +2322,18 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat1105 = try_flat(pp, msg, pretty_not) - if !isnothing(flat1105) - write(pp, flat1105) + flat1110 = try_flat(pp, msg, pretty_not) + if !isnothing(flat1110) + write(pp, flat1110) return nothing else _dollar_dollar = msg - fields1103 = _dollar_dollar.arg - unwrapped_fields1104 = fields1103 + fields1108 = _dollar_dollar.arg + unwrapped_fields1109 = fields1108 write(pp, "(not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields1104) + pretty_formula(pp, unwrapped_fields1109) dedent!(pp) write(pp, ")") end @@ -2337,25 +2341,25 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat1111 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat1111) - write(pp, flat1111) + flat1116 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat1116) + write(pp, flat1116) return nothing else _dollar_dollar = msg - fields1106 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - unwrapped_fields1107 = fields1106 + fields1111 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + unwrapped_fields1112 = fields1111 write(pp, "(ffi") indent_sexp!(pp) newline(pp) - field1108 = unwrapped_fields1107[1] - pretty_name(pp, field1108) + field1113 = unwrapped_fields1112[1] + pretty_name(pp, field1113) newline(pp) - field1109 = unwrapped_fields1107[2] - pretty_ffi_args(pp, field1109) + field1114 = unwrapped_fields1112[2] + pretty_ffi_args(pp, field1114) newline(pp) - field1110 = unwrapped_fields1107[3] - pretty_terms(pp, field1110) + field1115 = unwrapped_fields1112[3] + pretty_terms(pp, field1115) dedent!(pp) write(pp, ")") end @@ -2363,35 +2367,35 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat1113 = try_flat(pp, msg, pretty_name) - if !isnothing(flat1113) - write(pp, flat1113) + flat1118 = try_flat(pp, msg, pretty_name) + if !isnothing(flat1118) + write(pp, flat1118) return nothing else - fields1112 = msg + fields1117 = msg write(pp, ":") - write(pp, fields1112) + write(pp, fields1117) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat1117 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat1117) - write(pp, flat1117) + flat1122 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat1122) + write(pp, flat1122) return nothing else - fields1114 = msg + fields1119 = msg write(pp, "(args") indent_sexp!(pp) - if !isempty(fields1114) + if !isempty(fields1119) newline(pp) - for (i1683, elem1115) in enumerate(fields1114) - i1116 = i1683 - 1 - if (i1116 > 0) + for (i1693, elem1120) in enumerate(fields1119) + i1121 = i1693 - 1 + if (i1121 > 0) newline(pp) end - pretty_abstraction(pp, elem1115) + pretty_abstraction(pp, elem1120) end end dedent!(pp) @@ -2401,28 +2405,28 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat1124 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat1124) - write(pp, flat1124) + flat1129 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat1129) + write(pp, flat1129) return nothing else _dollar_dollar = msg - fields1118 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1119 = fields1118 + fields1123 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1124 = fields1123 write(pp, "(atom") indent_sexp!(pp) newline(pp) - field1120 = unwrapped_fields1119[1] - pretty_relation_id(pp, field1120) - field1121 = unwrapped_fields1119[2] - if !isempty(field1121) + field1125 = unwrapped_fields1124[1] + pretty_relation_id(pp, field1125) + field1126 = unwrapped_fields1124[2] + if !isempty(field1126) newline(pp) - for (i1684, elem1122) in enumerate(field1121) - i1123 = i1684 - 1 - if (i1123 > 0) + for (i1694, elem1127) in enumerate(field1126) + i1128 = i1694 - 1 + if (i1128 > 0) newline(pp) end - pretty_term(pp, elem1122) + pretty_term(pp, elem1127) end end dedent!(pp) @@ -2432,28 +2436,28 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat1131 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat1131) - write(pp, flat1131) + flat1136 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat1136) + write(pp, flat1136) return nothing else _dollar_dollar = msg - fields1125 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1126 = fields1125 + fields1130 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1131 = fields1130 write(pp, "(pragma") indent_sexp!(pp) newline(pp) - field1127 = unwrapped_fields1126[1] - pretty_name(pp, field1127) - field1128 = unwrapped_fields1126[2] - if !isempty(field1128) + field1132 = unwrapped_fields1131[1] + pretty_name(pp, field1132) + field1133 = unwrapped_fields1131[2] + if !isempty(field1133) newline(pp) - for (i1685, elem1129) in enumerate(field1128) - i1130 = i1685 - 1 - if (i1130 > 0) + for (i1695, elem1134) in enumerate(field1133) + i1135 = i1695 - 1 + if (i1135 > 0) newline(pp) end - pretty_term(pp, elem1129) + pretty_term(pp, elem1134) end end dedent!(pp) @@ -2463,118 +2467,118 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat1147 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat1147) - write(pp, flat1147) + flat1152 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat1152) + write(pp, flat1152) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1686 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1696 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1686 = nothing + _t1696 = nothing end - guard_result1146 = _t1686 - if !isnothing(guard_result1146) + guard_result1151 = _t1696 + if !isnothing(guard_result1151) pretty_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1687 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1697 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1687 = nothing + _t1697 = nothing end - guard_result1145 = _t1687 - if !isnothing(guard_result1145) + guard_result1150 = _t1697 + if !isnothing(guard_result1150) pretty_lt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1688 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1698 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1688 = nothing + _t1698 = nothing end - guard_result1144 = _t1688 - if !isnothing(guard_result1144) + guard_result1149 = _t1698 + if !isnothing(guard_result1149) pretty_lt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1689 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1699 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1689 = nothing + _t1699 = nothing end - guard_result1143 = _t1689 - if !isnothing(guard_result1143) + guard_result1148 = _t1699 + if !isnothing(guard_result1148) pretty_gt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1690 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1700 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1690 = nothing + _t1700 = nothing end - guard_result1142 = _t1690 - if !isnothing(guard_result1142) + guard_result1147 = _t1700 + if !isnothing(guard_result1147) pretty_gt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1691 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1701 = (_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 - _t1691 = nothing + _t1701 = nothing end - guard_result1141 = _t1691 - if !isnothing(guard_result1141) + guard_result1146 = _t1701 + if !isnothing(guard_result1146) pretty_add(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1692 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1702 = (_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 - _t1692 = nothing + _t1702 = nothing end - guard_result1140 = _t1692 - if !isnothing(guard_result1140) + guard_result1145 = _t1702 + if !isnothing(guard_result1145) pretty_minus(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1693 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1703 = (_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 - _t1693 = nothing + _t1703 = nothing end - guard_result1139 = _t1693 - if !isnothing(guard_result1139) + guard_result1144 = _t1703 + if !isnothing(guard_result1144) pretty_multiply(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1694 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1704 = (_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 - _t1694 = nothing + _t1704 = nothing end - guard_result1138 = _t1694 - if !isnothing(guard_result1138) + guard_result1143 = _t1704 + if !isnothing(guard_result1143) pretty_divide(pp, msg) else _dollar_dollar = msg - fields1132 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1133 = fields1132 + fields1137 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1138 = fields1137 write(pp, "(primitive") indent_sexp!(pp) newline(pp) - field1134 = unwrapped_fields1133[1] - pretty_name(pp, field1134) - field1135 = unwrapped_fields1133[2] - if !isempty(field1135) + field1139 = unwrapped_fields1138[1] + pretty_name(pp, field1139) + field1140 = unwrapped_fields1138[2] + if !isempty(field1140) newline(pp) - for (i1695, elem1136) in enumerate(field1135) - i1137 = i1695 - 1 - if (i1137 > 0) + for (i1705, elem1141) in enumerate(field1140) + i1142 = i1705 - 1 + if (i1142 > 0) newline(pp) end - pretty_rel_term(pp, elem1136) + pretty_rel_term(pp, elem1141) end end dedent!(pp) @@ -2593,48 +2597,20 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1152 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat1152) - write(pp, flat1152) - return nothing - else - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_eq" - _t1696 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) - else - _t1696 = nothing - end - fields1148 = _t1696 - unwrapped_fields1149 = fields1148 - write(pp, "(=") - indent_sexp!(pp) - newline(pp) - field1150 = unwrapped_fields1149[1] - pretty_term(pp, field1150) - newline(pp) - field1151 = unwrapped_fields1149[2] - pretty_term(pp, field1151) - dedent!(pp) - write(pp, ")") - end - return nothing -end - -function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1157 = try_flat(pp, msg, pretty_lt) + flat1157 = try_flat(pp, msg, pretty_eq) if !isnothing(flat1157) write(pp, flat1157) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1697 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + if _dollar_dollar.name == "rel_primitive_eq" + _t1706 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1697 = nothing + _t1706 = nothing end - fields1153 = _t1697 + fields1153 = _t1706 unwrapped_fields1154 = fields1153 - write(pp, "(<") + write(pp, "(=") indent_sexp!(pp) newline(pp) field1155 = unwrapped_fields1154[1] @@ -2648,21 +2624,21 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1162 = try_flat(pp, msg, pretty_lt_eq) +function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) + flat1162 = try_flat(pp, msg, pretty_lt) if !isnothing(flat1162) write(pp, flat1162) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1698 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + if _dollar_dollar.name == "rel_primitive_lt_monotype" + _t1707 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1698 = nothing + _t1707 = nothing end - fields1158 = _t1698 + fields1158 = _t1707 unwrapped_fields1159 = fields1158 - write(pp, "(<=") + write(pp, "(<") indent_sexp!(pp) newline(pp) field1160 = unwrapped_fields1159[1] @@ -2676,21 +2652,21 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1167 = try_flat(pp, msg, pretty_gt) +function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) + flat1167 = try_flat(pp, msg, pretty_lt_eq) if !isnothing(flat1167) write(pp, flat1167) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1699 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" + _t1708 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1699 = nothing + _t1708 = nothing end - fields1163 = _t1699 + fields1163 = _t1708 unwrapped_fields1164 = fields1163 - write(pp, "(>") + write(pp, "(<=") indent_sexp!(pp) newline(pp) field1165 = unwrapped_fields1164[1] @@ -2704,21 +2680,21 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1172 = try_flat(pp, msg, pretty_gt_eq) +function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) + flat1172 = try_flat(pp, msg, pretty_gt) if !isnothing(flat1172) write(pp, flat1172) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1700 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + if _dollar_dollar.name == "rel_primitive_gt_monotype" + _t1709 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1700 = nothing + _t1709 = nothing end - fields1168 = _t1700 + fields1168 = _t1709 unwrapped_fields1169 = fields1168 - write(pp, "(>=") + write(pp, "(>") indent_sexp!(pp) newline(pp) field1170 = unwrapped_fields1169[1] @@ -2732,21 +2708,21 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat1178 = try_flat(pp, msg, pretty_add) - if !isnothing(flat1178) - write(pp, flat1178) +function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) + flat1177 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat1177) + write(pp, flat1177) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1701 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" + _t1710 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1701 = nothing + _t1710 = nothing end - fields1173 = _t1701 + fields1173 = _t1710 unwrapped_fields1174 = fields1173 - write(pp, "(+") + write(pp, "(>=") indent_sexp!(pp) newline(pp) field1175 = unwrapped_fields1174[1] @@ -2754,9 +2730,37 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) newline(pp) field1176 = unwrapped_fields1174[2] pretty_term(pp, field1176) + dedent!(pp) + write(pp, ")") + end + return nothing +end + +function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) + flat1183 = try_flat(pp, msg, pretty_add) + if !isnothing(flat1183) + write(pp, flat1183) + return nothing + else + _dollar_dollar = msg + if _dollar_dollar.name == "rel_primitive_add_monotype" + _t1711 = (_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 + _t1711 = nothing + end + fields1178 = _t1711 + unwrapped_fields1179 = fields1178 + write(pp, "(+") + indent_sexp!(pp) + newline(pp) + field1180 = unwrapped_fields1179[1] + pretty_term(pp, field1180) newline(pp) - field1177 = unwrapped_fields1174[3] - pretty_term(pp, field1177) + field1181 = unwrapped_fields1179[2] + pretty_term(pp, field1181) + newline(pp) + field1182 = unwrapped_fields1179[3] + pretty_term(pp, field1182) dedent!(pp) write(pp, ")") end @@ -2764,30 +2768,30 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat1184 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat1184) - write(pp, flat1184) + flat1189 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat1189) + write(pp, flat1189) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1702 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1712 = (_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 - _t1702 = nothing + _t1712 = nothing end - fields1179 = _t1702 - unwrapped_fields1180 = fields1179 + fields1184 = _t1712 + unwrapped_fields1185 = fields1184 write(pp, "(-") indent_sexp!(pp) newline(pp) - field1181 = unwrapped_fields1180[1] - pretty_term(pp, field1181) + field1186 = unwrapped_fields1185[1] + pretty_term(pp, field1186) newline(pp) - field1182 = unwrapped_fields1180[2] - pretty_term(pp, field1182) + field1187 = unwrapped_fields1185[2] + pretty_term(pp, field1187) newline(pp) - field1183 = unwrapped_fields1180[3] - pretty_term(pp, field1183) + field1188 = unwrapped_fields1185[3] + pretty_term(pp, field1188) dedent!(pp) write(pp, ")") end @@ -2795,30 +2799,30 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat1190 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat1190) - write(pp, flat1190) + flat1195 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat1195) + write(pp, flat1195) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1703 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1713 = (_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 - _t1703 = nothing + _t1713 = nothing end - fields1185 = _t1703 - unwrapped_fields1186 = fields1185 + fields1190 = _t1713 + unwrapped_fields1191 = fields1190 write(pp, "(*") indent_sexp!(pp) newline(pp) - field1187 = unwrapped_fields1186[1] - pretty_term(pp, field1187) + field1192 = unwrapped_fields1191[1] + pretty_term(pp, field1192) newline(pp) - field1188 = unwrapped_fields1186[2] - pretty_term(pp, field1188) + field1193 = unwrapped_fields1191[2] + pretty_term(pp, field1193) newline(pp) - field1189 = unwrapped_fields1186[3] - pretty_term(pp, field1189) + field1194 = unwrapped_fields1191[3] + pretty_term(pp, field1194) dedent!(pp) write(pp, ")") end @@ -2826,30 +2830,30 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat1196 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat1196) - write(pp, flat1196) + flat1201 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat1201) + write(pp, flat1201) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1704 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1714 = (_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 - _t1704 = nothing + _t1714 = nothing end - fields1191 = _t1704 - unwrapped_fields1192 = fields1191 + fields1196 = _t1714 + unwrapped_fields1197 = fields1196 write(pp, "(/") indent_sexp!(pp) newline(pp) - field1193 = unwrapped_fields1192[1] - pretty_term(pp, field1193) + field1198 = unwrapped_fields1197[1] + pretty_term(pp, field1198) newline(pp) - field1194 = unwrapped_fields1192[2] - pretty_term(pp, field1194) + field1199 = unwrapped_fields1197[2] + pretty_term(pp, field1199) newline(pp) - field1195 = unwrapped_fields1192[3] - pretty_term(pp, field1195) + field1200 = unwrapped_fields1197[3] + pretty_term(pp, field1200) dedent!(pp) write(pp, ")") end @@ -2857,32 +2861,32 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat1201 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat1201) - write(pp, flat1201) + flat1206 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat1206) + write(pp, flat1206) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1705 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1715 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1705 = nothing + _t1715 = nothing end - deconstruct_result1199 = _t1705 - if !isnothing(deconstruct_result1199) - unwrapped1200 = deconstruct_result1199 - pretty_specialized_value(pp, unwrapped1200) + deconstruct_result1204 = _t1715 + if !isnothing(deconstruct_result1204) + unwrapped1205 = deconstruct_result1204 + pretty_specialized_value(pp, unwrapped1205) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1706 = _get_oneof_field(_dollar_dollar, :term) + _t1716 = _get_oneof_field(_dollar_dollar, :term) else - _t1706 = nothing + _t1716 = nothing end - deconstruct_result1197 = _t1706 - if !isnothing(deconstruct_result1197) - unwrapped1198 = deconstruct_result1197 - pretty_term(pp, unwrapped1198) + deconstruct_result1202 = _t1716 + if !isnothing(deconstruct_result1202) + unwrapped1203 = deconstruct_result1202 + pretty_term(pp, unwrapped1203) else throw(ParseError("No matching rule for rel_term")) end @@ -2892,41 +2896,41 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat1203 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat1203) - write(pp, flat1203) + flat1208 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat1208) + write(pp, flat1208) return nothing else - fields1202 = msg + fields1207 = msg write(pp, "#") - pretty_raw_value(pp, fields1202) + pretty_raw_value(pp, fields1207) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat1210 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat1210) - write(pp, flat1210) + flat1215 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat1215) + write(pp, flat1215) return nothing else _dollar_dollar = msg - fields1204 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1205 = fields1204 + fields1209 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1210 = fields1209 write(pp, "(relatom") indent_sexp!(pp) newline(pp) - field1206 = unwrapped_fields1205[1] - pretty_name(pp, field1206) - field1207 = unwrapped_fields1205[2] - if !isempty(field1207) + field1211 = unwrapped_fields1210[1] + pretty_name(pp, field1211) + field1212 = unwrapped_fields1210[2] + if !isempty(field1212) newline(pp) - for (i1707, elem1208) in enumerate(field1207) - i1209 = i1707 - 1 - if (i1209 > 0) + for (i1717, elem1213) in enumerate(field1212) + i1214 = i1717 - 1 + if (i1214 > 0) newline(pp) end - pretty_rel_term(pp, elem1208) + pretty_rel_term(pp, elem1213) end end dedent!(pp) @@ -2936,22 +2940,22 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat1215 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat1215) - write(pp, flat1215) + flat1220 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat1220) + write(pp, flat1220) return nothing else _dollar_dollar = msg - fields1211 = (_dollar_dollar.input, _dollar_dollar.result,) - unwrapped_fields1212 = fields1211 + fields1216 = (_dollar_dollar.input, _dollar_dollar.result,) + unwrapped_fields1217 = fields1216 write(pp, "(cast") indent_sexp!(pp) newline(pp) - field1213 = unwrapped_fields1212[1] - pretty_term(pp, field1213) + field1218 = unwrapped_fields1217[1] + pretty_term(pp, field1218) newline(pp) - field1214 = unwrapped_fields1212[2] - pretty_term(pp, field1214) + field1219 = unwrapped_fields1217[2] + pretty_term(pp, field1219) dedent!(pp) write(pp, ")") end @@ -2959,22 +2963,22 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat1219 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat1219) - write(pp, flat1219) + flat1224 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1224) + write(pp, flat1224) return nothing else - fields1216 = msg + fields1221 = msg write(pp, "(attrs") indent_sexp!(pp) - if !isempty(fields1216) + if !isempty(fields1221) newline(pp) - for (i1708, elem1217) in enumerate(fields1216) - i1218 = i1708 - 1 - if (i1218 > 0) + for (i1718, elem1222) in enumerate(fields1221) + i1223 = i1718 - 1 + if (i1223 > 0) newline(pp) end - pretty_attribute(pp, elem1217) + pretty_attribute(pp, elem1222) end end dedent!(pp) @@ -2984,28 +2988,28 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1226 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1226) - write(pp, flat1226) + flat1231 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1231) + write(pp, flat1231) return nothing else _dollar_dollar = msg - fields1220 = (_dollar_dollar.name, _dollar_dollar.args,) - unwrapped_fields1221 = fields1220 + fields1225 = (_dollar_dollar.name, _dollar_dollar.args,) + unwrapped_fields1226 = fields1225 write(pp, "(attribute") indent_sexp!(pp) newline(pp) - field1222 = unwrapped_fields1221[1] - pretty_name(pp, field1222) - field1223 = unwrapped_fields1221[2] - if !isempty(field1223) + field1227 = unwrapped_fields1226[1] + pretty_name(pp, field1227) + field1228 = unwrapped_fields1226[2] + if !isempty(field1228) newline(pp) - for (i1709, elem1224) in enumerate(field1223) - i1225 = i1709 - 1 - if (i1225 > 0) + for (i1719, elem1229) in enumerate(field1228) + i1230 = i1719 - 1 + if (i1230 > 0) newline(pp) end - pretty_raw_value(pp, elem1224) + pretty_raw_value(pp, elem1229) end end dedent!(pp) @@ -3015,40 +3019,40 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1235 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1235) - write(pp, flat1235) + flat1240 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1240) + write(pp, flat1240) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1710 = _dollar_dollar.attrs + _t1720 = _dollar_dollar.attrs else - _t1710 = nothing + _t1720 = nothing end - fields1227 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1710,) - unwrapped_fields1228 = fields1227 + fields1232 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1720,) + unwrapped_fields1233 = fields1232 write(pp, "(algorithm") indent_sexp!(pp) - field1229 = unwrapped_fields1228[1] - if !isempty(field1229) + field1234 = unwrapped_fields1233[1] + if !isempty(field1234) newline(pp) - for (i1711, elem1230) in enumerate(field1229) - i1231 = i1711 - 1 - if (i1231 > 0) + for (i1721, elem1235) in enumerate(field1234) + i1236 = i1721 - 1 + if (i1236 > 0) newline(pp) end - pretty_relation_id(pp, elem1230) + pretty_relation_id(pp, elem1235) end end newline(pp) - field1232 = unwrapped_fields1228[2] - pretty_script(pp, field1232) - field1233 = unwrapped_fields1228[3] - if !isnothing(field1233) + field1237 = unwrapped_fields1233[2] + pretty_script(pp, field1237) + field1238 = unwrapped_fields1233[3] + if !isnothing(field1238) newline(pp) - opt_val1234 = field1233 - pretty_attrs(pp, opt_val1234) + opt_val1239 = field1238 + pretty_attrs(pp, opt_val1239) end dedent!(pp) write(pp, ")") @@ -3057,24 +3061,24 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1240 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1240) - write(pp, flat1240) + flat1245 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1245) + write(pp, flat1245) return nothing else _dollar_dollar = msg - fields1236 = _dollar_dollar.constructs - unwrapped_fields1237 = fields1236 + fields1241 = _dollar_dollar.constructs + unwrapped_fields1242 = fields1241 write(pp, "(script") indent_sexp!(pp) - if !isempty(unwrapped_fields1237) + if !isempty(unwrapped_fields1242) newline(pp) - for (i1712, elem1238) in enumerate(unwrapped_fields1237) - i1239 = i1712 - 1 - if (i1239 > 0) + for (i1722, elem1243) in enumerate(unwrapped_fields1242) + i1244 = i1722 - 1 + if (i1244 > 0) newline(pp) end - pretty_construct(pp, elem1238) + pretty_construct(pp, elem1243) end end dedent!(pp) @@ -3084,32 +3088,32 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1245 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1245) - write(pp, flat1245) + flat1250 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1250) + write(pp, flat1250) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1713 = _get_oneof_field(_dollar_dollar, :loop) + _t1723 = _get_oneof_field(_dollar_dollar, :loop) else - _t1713 = nothing + _t1723 = nothing end - deconstruct_result1243 = _t1713 - if !isnothing(deconstruct_result1243) - unwrapped1244 = deconstruct_result1243 - pretty_loop(pp, unwrapped1244) + deconstruct_result1248 = _t1723 + if !isnothing(deconstruct_result1248) + unwrapped1249 = deconstruct_result1248 + pretty_loop(pp, unwrapped1249) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1714 = _get_oneof_field(_dollar_dollar, :instruction) + _t1724 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1714 = nothing + _t1724 = nothing end - deconstruct_result1241 = _t1714 - if !isnothing(deconstruct_result1241) - unwrapped1242 = deconstruct_result1241 - pretty_instruction(pp, unwrapped1242) + deconstruct_result1246 = _t1724 + if !isnothing(deconstruct_result1246) + unwrapped1247 = deconstruct_result1246 + pretty_instruction(pp, unwrapped1247) else throw(ParseError("No matching rule for construct")) end @@ -3119,32 +3123,32 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1252 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1252) - write(pp, flat1252) + flat1257 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1257) + write(pp, flat1257) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1715 = _dollar_dollar.attrs + _t1725 = _dollar_dollar.attrs else - _t1715 = nothing + _t1725 = nothing end - fields1246 = (_dollar_dollar.init, _dollar_dollar.body, _t1715,) - unwrapped_fields1247 = fields1246 + fields1251 = (_dollar_dollar.init, _dollar_dollar.body, _t1725,) + unwrapped_fields1252 = fields1251 write(pp, "(loop") indent_sexp!(pp) newline(pp) - field1248 = unwrapped_fields1247[1] - pretty_init(pp, field1248) + field1253 = unwrapped_fields1252[1] + pretty_init(pp, field1253) newline(pp) - field1249 = unwrapped_fields1247[2] - pretty_script(pp, field1249) - field1250 = unwrapped_fields1247[3] - if !isnothing(field1250) + field1254 = unwrapped_fields1252[2] + pretty_script(pp, field1254) + field1255 = unwrapped_fields1252[3] + if !isnothing(field1255) newline(pp) - opt_val1251 = field1250 - pretty_attrs(pp, opt_val1251) + opt_val1256 = field1255 + pretty_attrs(pp, opt_val1256) end dedent!(pp) write(pp, ")") @@ -3153,22 +3157,22 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1256 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1256) - write(pp, flat1256) + flat1261 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1261) + write(pp, flat1261) return nothing else - fields1253 = msg + fields1258 = msg write(pp, "(init") indent_sexp!(pp) - if !isempty(fields1253) + if !isempty(fields1258) newline(pp) - for (i1716, elem1254) in enumerate(fields1253) - i1255 = i1716 - 1 - if (i1255 > 0) + for (i1726, elem1259) in enumerate(fields1258) + i1260 = i1726 - 1 + if (i1260 > 0) newline(pp) end - pretty_instruction(pp, elem1254) + pretty_instruction(pp, elem1259) end end dedent!(pp) @@ -3178,65 +3182,65 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1267 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1267) - write(pp, flat1267) + flat1272 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1272) + write(pp, flat1272) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1717 = _get_oneof_field(_dollar_dollar, :assign) + _t1727 = _get_oneof_field(_dollar_dollar, :assign) else - _t1717 = nothing + _t1727 = nothing end - deconstruct_result1265 = _t1717 - if !isnothing(deconstruct_result1265) - unwrapped1266 = deconstruct_result1265 - pretty_assign(pp, unwrapped1266) + deconstruct_result1270 = _t1727 + if !isnothing(deconstruct_result1270) + unwrapped1271 = deconstruct_result1270 + pretty_assign(pp, unwrapped1271) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1718 = _get_oneof_field(_dollar_dollar, :upsert) + _t1728 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1718 = nothing + _t1728 = nothing end - deconstruct_result1263 = _t1718 - if !isnothing(deconstruct_result1263) - unwrapped1264 = deconstruct_result1263 - pretty_upsert(pp, unwrapped1264) + deconstruct_result1268 = _t1728 + if !isnothing(deconstruct_result1268) + unwrapped1269 = deconstruct_result1268 + pretty_upsert(pp, unwrapped1269) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1719 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1729 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1719 = nothing + _t1729 = nothing end - deconstruct_result1261 = _t1719 - if !isnothing(deconstruct_result1261) - unwrapped1262 = deconstruct_result1261 - pretty_break(pp, unwrapped1262) + deconstruct_result1266 = _t1729 + if !isnothing(deconstruct_result1266) + unwrapped1267 = deconstruct_result1266 + pretty_break(pp, unwrapped1267) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1720 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1730 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1720 = nothing + _t1730 = nothing end - deconstruct_result1259 = _t1720 - if !isnothing(deconstruct_result1259) - unwrapped1260 = deconstruct_result1259 - pretty_monoid_def(pp, unwrapped1260) + deconstruct_result1264 = _t1730 + if !isnothing(deconstruct_result1264) + unwrapped1265 = deconstruct_result1264 + pretty_monoid_def(pp, unwrapped1265) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1721 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1731 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1721 = nothing + _t1731 = nothing end - deconstruct_result1257 = _t1721 - if !isnothing(deconstruct_result1257) - unwrapped1258 = deconstruct_result1257 - pretty_monus_def(pp, unwrapped1258) + deconstruct_result1262 = _t1731 + if !isnothing(deconstruct_result1262) + unwrapped1263 = deconstruct_result1262 + pretty_monus_def(pp, unwrapped1263) else throw(ParseError("No matching rule for instruction")) end @@ -3249,32 +3253,32 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1274 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1274) - write(pp, flat1274) + flat1279 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1279) + write(pp, flat1279) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1722 = _dollar_dollar.attrs + _t1732 = _dollar_dollar.attrs else - _t1722 = nothing + _t1732 = nothing end - fields1268 = (_dollar_dollar.name, _dollar_dollar.body, _t1722,) - unwrapped_fields1269 = fields1268 + fields1273 = (_dollar_dollar.name, _dollar_dollar.body, _t1732,) + unwrapped_fields1274 = fields1273 write(pp, "(assign") indent_sexp!(pp) newline(pp) - field1270 = unwrapped_fields1269[1] - pretty_relation_id(pp, field1270) + field1275 = unwrapped_fields1274[1] + pretty_relation_id(pp, field1275) newline(pp) - field1271 = unwrapped_fields1269[2] - pretty_abstraction(pp, field1271) - field1272 = unwrapped_fields1269[3] - if !isnothing(field1272) + field1276 = unwrapped_fields1274[2] + pretty_abstraction(pp, field1276) + field1277 = unwrapped_fields1274[3] + if !isnothing(field1277) newline(pp) - opt_val1273 = field1272 - pretty_attrs(pp, opt_val1273) + opt_val1278 = field1277 + pretty_attrs(pp, opt_val1278) end dedent!(pp) write(pp, ")") @@ -3283,32 +3287,32 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1281 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1281) - write(pp, flat1281) + flat1286 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1286) + write(pp, flat1286) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1723 = _dollar_dollar.attrs + _t1733 = _dollar_dollar.attrs else - _t1723 = nothing + _t1733 = nothing end - fields1275 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1723,) - unwrapped_fields1276 = fields1275 + fields1280 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1733,) + unwrapped_fields1281 = fields1280 write(pp, "(upsert") indent_sexp!(pp) newline(pp) - field1277 = unwrapped_fields1276[1] - pretty_relation_id(pp, field1277) + field1282 = unwrapped_fields1281[1] + pretty_relation_id(pp, field1282) newline(pp) - field1278 = unwrapped_fields1276[2] - pretty_abstraction_with_arity(pp, field1278) - field1279 = unwrapped_fields1276[3] - if !isnothing(field1279) + field1283 = unwrapped_fields1281[2] + pretty_abstraction_with_arity(pp, field1283) + field1284 = unwrapped_fields1281[3] + if !isnothing(field1284) newline(pp) - opt_val1280 = field1279 - pretty_attrs(pp, opt_val1280) + opt_val1285 = field1284 + pretty_attrs(pp, opt_val1285) end dedent!(pp) write(pp, ")") @@ -3317,22 +3321,22 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1286 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1286) - write(pp, flat1286) + flat1291 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1291) + write(pp, flat1291) return nothing else _dollar_dollar = msg - _t1724 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - fields1282 = (_t1724, _dollar_dollar[1].value,) - unwrapped_fields1283 = fields1282 + _t1734 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + fields1287 = (_t1734, _dollar_dollar[1].value,) + unwrapped_fields1288 = fields1287 write(pp, "(") indent!(pp) - field1284 = unwrapped_fields1283[1] - pretty_bindings(pp, field1284) + field1289 = unwrapped_fields1288[1] + pretty_bindings(pp, field1289) newline(pp) - field1285 = unwrapped_fields1283[2] - pretty_formula(pp, field1285) + field1290 = unwrapped_fields1288[2] + pretty_formula(pp, field1290) dedent!(pp) write(pp, ")") end @@ -3340,32 +3344,32 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1293 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1293) - write(pp, flat1293) + flat1298 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1298) + write(pp, flat1298) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1725 = _dollar_dollar.attrs + _t1735 = _dollar_dollar.attrs else - _t1725 = nothing + _t1735 = nothing end - fields1287 = (_dollar_dollar.name, _dollar_dollar.body, _t1725,) - unwrapped_fields1288 = fields1287 + fields1292 = (_dollar_dollar.name, _dollar_dollar.body, _t1735,) + unwrapped_fields1293 = fields1292 write(pp, "(break") indent_sexp!(pp) newline(pp) - field1289 = unwrapped_fields1288[1] - pretty_relation_id(pp, field1289) + field1294 = unwrapped_fields1293[1] + pretty_relation_id(pp, field1294) newline(pp) - field1290 = unwrapped_fields1288[2] - pretty_abstraction(pp, field1290) - field1291 = unwrapped_fields1288[3] - if !isnothing(field1291) + field1295 = unwrapped_fields1293[2] + pretty_abstraction(pp, field1295) + field1296 = unwrapped_fields1293[3] + if !isnothing(field1296) newline(pp) - opt_val1292 = field1291 - pretty_attrs(pp, opt_val1292) + opt_val1297 = field1296 + pretty_attrs(pp, opt_val1297) end dedent!(pp) write(pp, ")") @@ -3374,35 +3378,35 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1301 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1301) - write(pp, flat1301) + flat1306 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1306) + write(pp, flat1306) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1726 = _dollar_dollar.attrs + _t1736 = _dollar_dollar.attrs else - _t1726 = nothing + _t1736 = nothing end - fields1294 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1726,) - unwrapped_fields1295 = fields1294 + fields1299 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1736,) + unwrapped_fields1300 = fields1299 write(pp, "(monoid") indent_sexp!(pp) newline(pp) - field1296 = unwrapped_fields1295[1] - pretty_monoid(pp, field1296) + field1301 = unwrapped_fields1300[1] + pretty_monoid(pp, field1301) newline(pp) - field1297 = unwrapped_fields1295[2] - pretty_relation_id(pp, field1297) + field1302 = unwrapped_fields1300[2] + pretty_relation_id(pp, field1302) newline(pp) - field1298 = unwrapped_fields1295[3] - pretty_abstraction_with_arity(pp, field1298) - field1299 = unwrapped_fields1295[4] - if !isnothing(field1299) + field1303 = unwrapped_fields1300[3] + pretty_abstraction_with_arity(pp, field1303) + field1304 = unwrapped_fields1300[4] + if !isnothing(field1304) newline(pp) - opt_val1300 = field1299 - pretty_attrs(pp, opt_val1300) + opt_val1305 = field1304 + pretty_attrs(pp, opt_val1305) end dedent!(pp) write(pp, ")") @@ -3411,54 +3415,54 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1310 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1310) - write(pp, flat1310) + flat1315 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1315) + write(pp, flat1315) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1727 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1737 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1727 = nothing + _t1737 = nothing end - deconstruct_result1308 = _t1727 - if !isnothing(deconstruct_result1308) - unwrapped1309 = deconstruct_result1308 - pretty_or_monoid(pp, unwrapped1309) + deconstruct_result1313 = _t1737 + if !isnothing(deconstruct_result1313) + unwrapped1314 = deconstruct_result1313 + pretty_or_monoid(pp, unwrapped1314) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1728 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1738 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1728 = nothing + _t1738 = nothing end - deconstruct_result1306 = _t1728 - if !isnothing(deconstruct_result1306) - unwrapped1307 = deconstruct_result1306 - pretty_min_monoid(pp, unwrapped1307) + deconstruct_result1311 = _t1738 + if !isnothing(deconstruct_result1311) + unwrapped1312 = deconstruct_result1311 + pretty_min_monoid(pp, unwrapped1312) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1729 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1739 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1729 = nothing + _t1739 = nothing end - deconstruct_result1304 = _t1729 - if !isnothing(deconstruct_result1304) - unwrapped1305 = deconstruct_result1304 - pretty_max_monoid(pp, unwrapped1305) + deconstruct_result1309 = _t1739 + if !isnothing(deconstruct_result1309) + unwrapped1310 = deconstruct_result1309 + pretty_max_monoid(pp, unwrapped1310) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1730 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1740 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1730 = nothing + _t1740 = nothing end - deconstruct_result1302 = _t1730 - if !isnothing(deconstruct_result1302) - unwrapped1303 = deconstruct_result1302 - pretty_sum_monoid(pp, unwrapped1303) + deconstruct_result1307 = _t1740 + if !isnothing(deconstruct_result1307) + unwrapped1308 = deconstruct_result1307 + pretty_sum_monoid(pp, unwrapped1308) else throw(ParseError("No matching rule for monoid")) end @@ -3470,24 +3474,24 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1311 = msg + fields1316 = msg write(pp, "(or)") return nothing end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1314 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1314) - write(pp, flat1314) + flat1319 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1319) + write(pp, flat1319) return nothing else _dollar_dollar = msg - fields1312 = _dollar_dollar.var"#type" - unwrapped_fields1313 = fields1312 + fields1317 = _dollar_dollar.var"#type" + unwrapped_fields1318 = fields1317 write(pp, "(min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1313) + pretty_type(pp, unwrapped_fields1318) dedent!(pp) write(pp, ")") end @@ -3495,18 +3499,18 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1317 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1317) - write(pp, flat1317) + flat1322 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1322) + write(pp, flat1322) return nothing else _dollar_dollar = msg - fields1315 = _dollar_dollar.var"#type" - unwrapped_fields1316 = fields1315 + fields1320 = _dollar_dollar.var"#type" + unwrapped_fields1321 = fields1320 write(pp, "(max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1316) + pretty_type(pp, unwrapped_fields1321) dedent!(pp) write(pp, ")") end @@ -3514,18 +3518,18 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1320 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1320) - write(pp, flat1320) + flat1325 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1325) + write(pp, flat1325) return nothing else _dollar_dollar = msg - fields1318 = _dollar_dollar.var"#type" - unwrapped_fields1319 = fields1318 + fields1323 = _dollar_dollar.var"#type" + unwrapped_fields1324 = fields1323 write(pp, "(sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1319) + pretty_type(pp, unwrapped_fields1324) dedent!(pp) write(pp, ")") end @@ -3533,35 +3537,35 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1328 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1328) - write(pp, flat1328) + flat1333 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1333) + write(pp, flat1333) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1731 = _dollar_dollar.attrs + _t1741 = _dollar_dollar.attrs else - _t1731 = nothing + _t1741 = nothing end - fields1321 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1731,) - unwrapped_fields1322 = fields1321 + fields1326 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1741,) + unwrapped_fields1327 = fields1326 write(pp, "(monus") indent_sexp!(pp) newline(pp) - field1323 = unwrapped_fields1322[1] - pretty_monoid(pp, field1323) + field1328 = unwrapped_fields1327[1] + pretty_monoid(pp, field1328) newline(pp) - field1324 = unwrapped_fields1322[2] - pretty_relation_id(pp, field1324) + field1329 = unwrapped_fields1327[2] + pretty_relation_id(pp, field1329) newline(pp) - field1325 = unwrapped_fields1322[3] - pretty_abstraction_with_arity(pp, field1325) - field1326 = unwrapped_fields1322[4] - if !isnothing(field1326) + field1330 = unwrapped_fields1327[3] + pretty_abstraction_with_arity(pp, field1330) + field1331 = unwrapped_fields1327[4] + if !isnothing(field1331) newline(pp) - opt_val1327 = field1326 - pretty_attrs(pp, opt_val1327) + opt_val1332 = field1331 + pretty_attrs(pp, opt_val1332) end dedent!(pp) write(pp, ")") @@ -3570,28 +3574,28 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1335 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1335) - write(pp, flat1335) + flat1340 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1340) + write(pp, flat1340) return nothing else _dollar_dollar = msg - fields1329 = (_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_fields1330 = fields1329 + fields1334 = (_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_fields1335 = fields1334 write(pp, "(functional_dependency") indent_sexp!(pp) newline(pp) - field1331 = unwrapped_fields1330[1] - pretty_relation_id(pp, field1331) + field1336 = unwrapped_fields1335[1] + pretty_relation_id(pp, field1336) newline(pp) - field1332 = unwrapped_fields1330[2] - pretty_abstraction(pp, field1332) + field1337 = unwrapped_fields1335[2] + pretty_abstraction(pp, field1337) newline(pp) - field1333 = unwrapped_fields1330[3] - pretty_functional_dependency_keys(pp, field1333) + field1338 = unwrapped_fields1335[3] + pretty_functional_dependency_keys(pp, field1338) newline(pp) - field1334 = unwrapped_fields1330[4] - pretty_functional_dependency_values(pp, field1334) + field1339 = unwrapped_fields1335[4] + pretty_functional_dependency_values(pp, field1339) dedent!(pp) write(pp, ")") end @@ -3599,22 +3603,22 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1339 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1339) - write(pp, flat1339) + flat1344 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1344) + write(pp, flat1344) return nothing else - fields1336 = msg + fields1341 = msg write(pp, "(keys") indent_sexp!(pp) - if !isempty(fields1336) + if !isempty(fields1341) newline(pp) - for (i1732, elem1337) in enumerate(fields1336) - i1338 = i1732 - 1 - if (i1338 > 0) + for (i1742, elem1342) in enumerate(fields1341) + i1343 = i1742 - 1 + if (i1343 > 0) newline(pp) end - pretty_var(pp, elem1337) + pretty_var(pp, elem1342) end end dedent!(pp) @@ -3624,22 +3628,22 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1343 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1343) - write(pp, flat1343) + flat1348 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1348) + write(pp, flat1348) return nothing else - fields1340 = msg + fields1345 = msg write(pp, "(values") indent_sexp!(pp) - if !isempty(fields1340) + if !isempty(fields1345) newline(pp) - for (i1733, elem1341) in enumerate(fields1340) - i1342 = i1733 - 1 - if (i1342 > 0) + for (i1743, elem1346) in enumerate(fields1345) + i1347 = i1743 - 1 + if (i1347 > 0) newline(pp) end - pretty_var(pp, elem1341) + pretty_var(pp, elem1346) end end dedent!(pp) @@ -3649,54 +3653,54 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1352 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1352) - write(pp, flat1352) + flat1357 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1357) + write(pp, flat1357) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("edb")) - _t1734 = _get_oneof_field(_dollar_dollar, :edb) + _t1744 = _get_oneof_field(_dollar_dollar, :edb) else - _t1734 = nothing + _t1744 = nothing end - deconstruct_result1350 = _t1734 - if !isnothing(deconstruct_result1350) - unwrapped1351 = deconstruct_result1350 - pretty_edb(pp, unwrapped1351) + deconstruct_result1355 = _t1744 + if !isnothing(deconstruct_result1355) + unwrapped1356 = deconstruct_result1355 + pretty_edb(pp, unwrapped1356) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1735 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1745 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1735 = nothing + _t1745 = nothing end - deconstruct_result1348 = _t1735 - if !isnothing(deconstruct_result1348) - unwrapped1349 = deconstruct_result1348 - pretty_betree_relation(pp, unwrapped1349) + deconstruct_result1353 = _t1745 + if !isnothing(deconstruct_result1353) + unwrapped1354 = deconstruct_result1353 + pretty_betree_relation(pp, unwrapped1354) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1736 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1746 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1736 = nothing + _t1746 = nothing end - deconstruct_result1346 = _t1736 - if !isnothing(deconstruct_result1346) - unwrapped1347 = deconstruct_result1346 - pretty_csv_data(pp, unwrapped1347) + deconstruct_result1351 = _t1746 + if !isnothing(deconstruct_result1351) + unwrapped1352 = deconstruct_result1351 + pretty_csv_data(pp, unwrapped1352) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_data")) - _t1737 = _get_oneof_field(_dollar_dollar, :iceberg_data) + _t1747 = _get_oneof_field(_dollar_dollar, :iceberg_data) else - _t1737 = nothing + _t1747 = nothing end - deconstruct_result1344 = _t1737 - if !isnothing(deconstruct_result1344) - unwrapped1345 = deconstruct_result1344 - pretty_iceberg_data(pp, unwrapped1345) + deconstruct_result1349 = _t1747 + if !isnothing(deconstruct_result1349) + unwrapped1350 = deconstruct_result1349 + pretty_iceberg_data(pp, unwrapped1350) else throw(ParseError("No matching rule for data")) end @@ -3708,25 +3712,25 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) end function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) - flat1358 = try_flat(pp, msg, pretty_edb) - if !isnothing(flat1358) - write(pp, flat1358) + flat1363 = try_flat(pp, msg, pretty_edb) + if !isnothing(flat1363) + write(pp, flat1363) return nothing else _dollar_dollar = msg - fields1353 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - unwrapped_fields1354 = fields1353 + fields1358 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + unwrapped_fields1359 = fields1358 write(pp, "(edb") indent_sexp!(pp) newline(pp) - field1355 = unwrapped_fields1354[1] - pretty_relation_id(pp, field1355) + field1360 = unwrapped_fields1359[1] + pretty_relation_id(pp, field1360) newline(pp) - field1356 = unwrapped_fields1354[2] - pretty_edb_path(pp, field1356) + field1361 = unwrapped_fields1359[2] + pretty_edb_path(pp, field1361) newline(pp) - field1357 = unwrapped_fields1354[3] - pretty_edb_types(pp, field1357) + field1362 = unwrapped_fields1359[3] + pretty_edb_types(pp, field1362) dedent!(pp) write(pp, ")") end @@ -3734,20 +3738,20 @@ function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) end function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1362 = try_flat(pp, msg, pretty_edb_path) - if !isnothing(flat1362) - write(pp, flat1362) + flat1367 = try_flat(pp, msg, pretty_edb_path) + if !isnothing(flat1367) + write(pp, flat1367) return nothing else - fields1359 = msg + fields1364 = msg write(pp, "[") indent!(pp) - for (i1738, elem1360) in enumerate(fields1359) - i1361 = i1738 - 1 - if (i1361 > 0) + for (i1748, elem1365) in enumerate(fields1364) + i1366 = i1748 - 1 + if (i1366 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1360)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1365)) end dedent!(pp) write(pp, "]") @@ -3756,20 +3760,20 @@ function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1366 = try_flat(pp, msg, pretty_edb_types) - if !isnothing(flat1366) - write(pp, flat1366) + flat1371 = try_flat(pp, msg, pretty_edb_types) + if !isnothing(flat1371) + write(pp, flat1371) return nothing else - fields1363 = msg + fields1368 = msg write(pp, "[") indent!(pp) - for (i1739, elem1364) in enumerate(fields1363) - i1365 = i1739 - 1 - if (i1365 > 0) + for (i1749, elem1369) in enumerate(fields1368) + i1370 = i1749 - 1 + if (i1370 > 0) newline(pp) end - pretty_type(pp, elem1364) + pretty_type(pp, elem1369) end dedent!(pp) write(pp, "]") @@ -3778,22 +3782,22 @@ function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1371 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1371) - write(pp, flat1371) + flat1376 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1376) + write(pp, flat1376) return nothing else _dollar_dollar = msg - fields1367 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - unwrapped_fields1368 = fields1367 + fields1372 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + unwrapped_fields1373 = fields1372 write(pp, "(betree_relation") indent_sexp!(pp) newline(pp) - field1369 = unwrapped_fields1368[1] - pretty_relation_id(pp, field1369) + field1374 = unwrapped_fields1373[1] + pretty_relation_id(pp, field1374) newline(pp) - field1370 = unwrapped_fields1368[2] - pretty_betree_info(pp, field1370) + field1375 = unwrapped_fields1373[2] + pretty_betree_info(pp, field1375) dedent!(pp) write(pp, ")") end @@ -3801,26 +3805,26 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1377 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1377) - write(pp, flat1377) + flat1382 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1382) + write(pp, flat1382) return nothing else _dollar_dollar = msg - _t1740 = deconstruct_betree_info_config(pp, _dollar_dollar) - fields1372 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1740,) - unwrapped_fields1373 = fields1372 + _t1750 = deconstruct_betree_info_config(pp, _dollar_dollar) + fields1377 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1750,) + unwrapped_fields1378 = fields1377 write(pp, "(betree_info") indent_sexp!(pp) newline(pp) - field1374 = unwrapped_fields1373[1] - pretty_betree_info_key_types(pp, field1374) + field1379 = unwrapped_fields1378[1] + pretty_betree_info_key_types(pp, field1379) newline(pp) - field1375 = unwrapped_fields1373[2] - pretty_betree_info_value_types(pp, field1375) + field1380 = unwrapped_fields1378[2] + pretty_betree_info_value_types(pp, field1380) newline(pp) - field1376 = unwrapped_fields1373[3] - pretty_config_dict(pp, field1376) + field1381 = unwrapped_fields1378[3] + pretty_config_dict(pp, field1381) dedent!(pp) write(pp, ")") end @@ -3828,22 +3832,22 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1381 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1381) - write(pp, flat1381) + flat1386 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1386) + write(pp, flat1386) return nothing else - fields1378 = msg + fields1383 = msg write(pp, "(key_types") indent_sexp!(pp) - if !isempty(fields1378) + if !isempty(fields1383) newline(pp) - for (i1741, elem1379) in enumerate(fields1378) - i1380 = i1741 - 1 - if (i1380 > 0) + for (i1751, elem1384) in enumerate(fields1383) + i1385 = i1751 - 1 + if (i1385 > 0) newline(pp) end - pretty_type(pp, elem1379) + pretty_type(pp, elem1384) end end dedent!(pp) @@ -3853,22 +3857,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"}) - flat1385 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1385) - write(pp, flat1385) + flat1390 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1390) + write(pp, flat1390) return nothing else - fields1382 = msg + fields1387 = msg write(pp, "(value_types") indent_sexp!(pp) - if !isempty(fields1382) + if !isempty(fields1387) newline(pp) - for (i1742, elem1383) in enumerate(fields1382) - i1384 = i1742 - 1 - if (i1384 > 0) + for (i1752, elem1388) in enumerate(fields1387) + i1389 = i1752 - 1 + if (i1389 > 0) newline(pp) end - pretty_type(pp, elem1383) + pretty_type(pp, elem1388) end end dedent!(pp) @@ -3878,28 +3882,28 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1392 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1392) - write(pp, flat1392) + flat1397 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1397) + write(pp, flat1397) return nothing else _dollar_dollar = msg - fields1386 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - unwrapped_fields1387 = fields1386 + fields1391 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) + unwrapped_fields1392 = fields1391 write(pp, "(csv_data") indent_sexp!(pp) newline(pp) - field1388 = unwrapped_fields1387[1] - pretty_csvlocator(pp, field1388) + field1393 = unwrapped_fields1392[1] + pretty_csvlocator(pp, field1393) newline(pp) - field1389 = unwrapped_fields1387[2] - pretty_csv_config(pp, field1389) + field1394 = unwrapped_fields1392[2] + pretty_csv_config(pp, field1394) newline(pp) - field1390 = unwrapped_fields1387[3] - pretty_gnf_columns(pp, field1390) + field1395 = unwrapped_fields1392[3] + pretty_gnf_columns(pp, field1395) newline(pp) - field1391 = unwrapped_fields1387[4] - pretty_csv_asof(pp, field1391) + field1396 = unwrapped_fields1392[4] + pretty_csv_asof(pp, field1396) dedent!(pp) write(pp, ")") end @@ -3907,37 +3911,37 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1399 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1399) - write(pp, flat1399) + flat1404 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1404) + write(pp, flat1404) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.paths) - _t1743 = _dollar_dollar.paths + _t1753 = _dollar_dollar.paths else - _t1743 = nothing + _t1753 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1744 = String(copy(_dollar_dollar.inline_data)) + _t1754 = String(copy(_dollar_dollar.inline_data)) else - _t1744 = nothing + _t1754 = nothing end - fields1393 = (_t1743, _t1744,) - unwrapped_fields1394 = fields1393 + fields1398 = (_t1753, _t1754,) + unwrapped_fields1399 = fields1398 write(pp, "(csv_locator") indent_sexp!(pp) - field1395 = unwrapped_fields1394[1] - if !isnothing(field1395) + field1400 = unwrapped_fields1399[1] + if !isnothing(field1400) newline(pp) - opt_val1396 = field1395 - pretty_csv_locator_paths(pp, opt_val1396) + opt_val1401 = field1400 + pretty_csv_locator_paths(pp, opt_val1401) end - field1397 = unwrapped_fields1394[2] - if !isnothing(field1397) + field1402 = unwrapped_fields1399[2] + if !isnothing(field1402) newline(pp) - opt_val1398 = field1397 - pretty_csv_locator_inline_data(pp, opt_val1398) + opt_val1403 = field1402 + pretty_csv_locator_inline_data(pp, opt_val1403) end dedent!(pp) write(pp, ")") @@ -3946,22 +3950,22 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1403 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1403) - write(pp, flat1403) + flat1408 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1408) + write(pp, flat1408) return nothing else - fields1400 = msg + fields1405 = msg write(pp, "(paths") indent_sexp!(pp) - if !isempty(fields1400) + if !isempty(fields1405) newline(pp) - for (i1745, elem1401) in enumerate(fields1400) - i1402 = i1745 - 1 - if (i1402 > 0) + for (i1755, elem1406) in enumerate(fields1405) + i1407 = i1755 - 1 + if (i1407 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1401)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1406)) end end dedent!(pp) @@ -3971,16 +3975,16 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1405 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1405) - write(pp, flat1405) + flat1410 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1410) + write(pp, flat1410) return nothing else - fields1404 = msg + fields1409 = msg write(pp, "(inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1404)) + write(pp, format_string(pp, fields1409)) dedent!(pp) write(pp, ")") end @@ -3988,26 +3992,26 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1411 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1411) - write(pp, flat1411) + flat1416 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1416) + write(pp, flat1416) return nothing else _dollar_dollar = msg - _t1746 = deconstruct_csv_config(pp, _dollar_dollar) - _t1747 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) - fields1406 = (_t1746, _t1747,) - unwrapped_fields1407 = fields1406 + _t1756 = deconstruct_csv_config(pp, _dollar_dollar) + _t1757 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) + fields1411 = (_t1756, _t1757,) + unwrapped_fields1412 = fields1411 write(pp, "(csv_config") indent_sexp!(pp) newline(pp) - field1408 = unwrapped_fields1407[1] - pretty_config_dict(pp, field1408) - field1409 = unwrapped_fields1407[2] - if !isnothing(field1409) + field1413 = unwrapped_fields1412[1] + pretty_config_dict(pp, field1413) + field1414 = unwrapped_fields1412[2] + if !isnothing(field1414) newline(pp) - opt_val1410 = field1409 - pretty__storage_integration(pp, opt_val1410) + opt_val1415 = field1414 + pretty__storage_integration(pp, opt_val1415) end dedent!(pp) write(pp, ")") @@ -4016,16 +4020,16 @@ function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) end function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat1413 = try_flat(pp, msg, pretty__storage_integration) - if !isnothing(flat1413) - write(pp, flat1413) + flat1418 = try_flat(pp, msg, pretty__storage_integration) + if !isnothing(flat1418) + write(pp, flat1418) return nothing else - fields1412 = msg + fields1417 = msg write(pp, "(storage_integration") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, fields1412) + pretty_config_dict(pp, fields1417) dedent!(pp) write(pp, ")") end @@ -4033,22 +4037,22 @@ function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String end function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) - flat1417 = try_flat(pp, msg, pretty_gnf_columns) - if !isnothing(flat1417) - write(pp, flat1417) + flat1422 = try_flat(pp, msg, pretty_gnf_columns) + if !isnothing(flat1422) + write(pp, flat1422) return nothing else - fields1414 = msg + fields1419 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1414) + if !isempty(fields1419) newline(pp) - for (i1748, elem1415) in enumerate(fields1414) - i1416 = i1748 - 1 - if (i1416 > 0) + for (i1758, elem1420) in enumerate(fields1419) + i1421 = i1758 - 1 + if (i1421 > 0) newline(pp) end - pretty_gnf_column(pp, elem1415) + pretty_gnf_column(pp, elem1420) end end dedent!(pp) @@ -4058,39 +4062,39 @@ function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) end function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) - flat1426 = try_flat(pp, msg, pretty_gnf_column) - if !isnothing(flat1426) - write(pp, flat1426) + flat1431 = try_flat(pp, msg, pretty_gnf_column) + if !isnothing(flat1431) + write(pp, flat1431) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("target_id")) - _t1749 = _dollar_dollar.target_id + _t1759 = _dollar_dollar.target_id else - _t1749 = nothing + _t1759 = nothing end - fields1418 = (_dollar_dollar.column_path, _t1749, _dollar_dollar.types,) - unwrapped_fields1419 = fields1418 + fields1423 = (_dollar_dollar.column_path, _t1759, _dollar_dollar.types,) + unwrapped_fields1424 = fields1423 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1420 = unwrapped_fields1419[1] - pretty_gnf_column_path(pp, field1420) - field1421 = unwrapped_fields1419[2] - if !isnothing(field1421) + field1425 = unwrapped_fields1424[1] + pretty_gnf_column_path(pp, field1425) + field1426 = unwrapped_fields1424[2] + if !isnothing(field1426) newline(pp) - opt_val1422 = field1421 - pretty_relation_id(pp, opt_val1422) + opt_val1427 = field1426 + pretty_relation_id(pp, opt_val1427) end newline(pp) write(pp, "[") - field1423 = unwrapped_fields1419[3] - for (i1750, elem1424) in enumerate(field1423) - i1425 = i1750 - 1 - if (i1425 > 0) + field1428 = unwrapped_fields1424[3] + for (i1760, elem1429) in enumerate(field1428) + i1430 = i1760 - 1 + if (i1430 > 0) newline(pp) end - pretty_type(pp, elem1424) + pretty_type(pp, elem1429) end write(pp, "]") dedent!(pp) @@ -4100,39 +4104,39 @@ function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) end function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) - flat1433 = try_flat(pp, msg, pretty_gnf_column_path) - if !isnothing(flat1433) - write(pp, flat1433) + flat1438 = try_flat(pp, msg, pretty_gnf_column_path) + if !isnothing(flat1438) + write(pp, flat1438) return nothing else _dollar_dollar = msg if length(_dollar_dollar) == 1 - _t1751 = _dollar_dollar[1] + _t1761 = _dollar_dollar[1] else - _t1751 = nothing + _t1761 = nothing end - deconstruct_result1431 = _t1751 - if !isnothing(deconstruct_result1431) - unwrapped1432 = deconstruct_result1431 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1432)) + deconstruct_result1436 = _t1761 + if !isnothing(deconstruct_result1436) + unwrapped1437 = deconstruct_result1436 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1437)) else _dollar_dollar = msg if length(_dollar_dollar) != 1 - _t1752 = _dollar_dollar + _t1762 = _dollar_dollar else - _t1752 = nothing + _t1762 = nothing end - deconstruct_result1427 = _t1752 - if !isnothing(deconstruct_result1427) - unwrapped1428 = deconstruct_result1427 + deconstruct_result1432 = _t1762 + if !isnothing(deconstruct_result1432) + unwrapped1433 = deconstruct_result1432 write(pp, "[") indent!(pp) - for (i1753, elem1429) in enumerate(unwrapped1428) - i1430 = i1753 - 1 - if (i1430 > 0) + for (i1763, elem1434) in enumerate(unwrapped1433) + i1435 = i1763 - 1 + if (i1435 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1429)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1434)) end dedent!(pp) write(pp, "]") @@ -4145,16 +4149,16 @@ function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1435 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1435) - write(pp, flat1435) + flat1440 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1440) + write(pp, flat1440) return nothing else - fields1434 = msg + fields1439 = msg write(pp, "(asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1434)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1439)) dedent!(pp) write(pp, ")") end @@ -4162,42 +4166,42 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) - flat1446 = try_flat(pp, msg, pretty_iceberg_data) - if !isnothing(flat1446) - write(pp, flat1446) + flat1451 = try_flat(pp, msg, pretty_iceberg_data) + if !isnothing(flat1451) + write(pp, flat1451) return nothing else _dollar_dollar = msg - _t1754 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) - _t1755 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) - fields1436 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1754, _t1755, _dollar_dollar.returns_delta,) - unwrapped_fields1437 = fields1436 + _t1764 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) + _t1765 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) + fields1441 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1764, _t1765, _dollar_dollar.returns_delta,) + unwrapped_fields1442 = fields1441 write(pp, "(iceberg_data") indent_sexp!(pp) newline(pp) - field1438 = unwrapped_fields1437[1] - pretty_iceberg_locator(pp, field1438) + field1443 = unwrapped_fields1442[1] + pretty_iceberg_locator(pp, field1443) newline(pp) - field1439 = unwrapped_fields1437[2] - pretty_iceberg_catalog_config(pp, field1439) + field1444 = unwrapped_fields1442[2] + pretty_iceberg_catalog_config(pp, field1444) newline(pp) - field1440 = unwrapped_fields1437[3] - pretty_gnf_columns(pp, field1440) - field1441 = unwrapped_fields1437[4] - if !isnothing(field1441) + field1445 = unwrapped_fields1442[3] + pretty_gnf_columns(pp, field1445) + field1446 = unwrapped_fields1442[4] + if !isnothing(field1446) newline(pp) - opt_val1442 = field1441 - pretty_iceberg_from_snapshot(pp, opt_val1442) + opt_val1447 = field1446 + pretty_iceberg_from_snapshot(pp, opt_val1447) end - field1443 = unwrapped_fields1437[5] - if !isnothing(field1443) + field1448 = unwrapped_fields1442[5] + if !isnothing(field1448) newline(pp) - opt_val1444 = field1443 - pretty_iceberg_to_snapshot(pp, opt_val1444) + opt_val1449 = field1448 + pretty_iceberg_to_snapshot(pp, opt_val1449) end newline(pp) - field1445 = unwrapped_fields1437[6] - pretty_boolean_value(pp, field1445) + field1450 = unwrapped_fields1442[6] + pretty_boolean_value(pp, field1450) dedent!(pp) write(pp, ")") end @@ -4205,25 +4209,25 @@ function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) end function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) - flat1452 = try_flat(pp, msg, pretty_iceberg_locator) - if !isnothing(flat1452) - write(pp, flat1452) + flat1457 = try_flat(pp, msg, pretty_iceberg_locator) + if !isnothing(flat1457) + write(pp, flat1457) return nothing else _dollar_dollar = msg - fields1447 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - unwrapped_fields1448 = fields1447 + fields1452 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + unwrapped_fields1453 = fields1452 write(pp, "(iceberg_locator") indent_sexp!(pp) newline(pp) - field1449 = unwrapped_fields1448[1] - pretty_iceberg_locator_table_name(pp, field1449) + field1454 = unwrapped_fields1453[1] + pretty_iceberg_locator_table_name(pp, field1454) newline(pp) - field1450 = unwrapped_fields1448[2] - pretty_iceberg_locator_namespace(pp, field1450) + field1455 = unwrapped_fields1453[2] + pretty_iceberg_locator_namespace(pp, field1455) newline(pp) - field1451 = unwrapped_fields1448[3] - pretty_iceberg_locator_warehouse(pp, field1451) + field1456 = unwrapped_fields1453[3] + pretty_iceberg_locator_warehouse(pp, field1456) dedent!(pp) write(pp, ")") end @@ -4231,16 +4235,16 @@ function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) end function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) - flat1454 = try_flat(pp, msg, pretty_iceberg_locator_table_name) - if !isnothing(flat1454) - write(pp, flat1454) + flat1459 = try_flat(pp, msg, pretty_iceberg_locator_table_name) + if !isnothing(flat1459) + write(pp, flat1459) return nothing else - fields1453 = msg + fields1458 = msg write(pp, "(table_name") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1453)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1458)) dedent!(pp) write(pp, ")") end @@ -4248,22 +4252,22 @@ function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) end function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String}) - flat1458 = try_flat(pp, msg, pretty_iceberg_locator_namespace) - if !isnothing(flat1458) - write(pp, flat1458) + flat1463 = try_flat(pp, msg, pretty_iceberg_locator_namespace) + if !isnothing(flat1463) + write(pp, flat1463) return nothing else - fields1455 = msg + fields1460 = msg write(pp, "(namespace") indent_sexp!(pp) - if !isempty(fields1455) + if !isempty(fields1460) newline(pp) - for (i1756, elem1456) in enumerate(fields1455) - i1457 = i1756 - 1 - if (i1457 > 0) + for (i1766, elem1461) in enumerate(fields1460) + i1462 = i1766 - 1 + if (i1462 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1456)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1461)) end end dedent!(pp) @@ -4273,16 +4277,16 @@ function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String} end function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) - flat1460 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) - if !isnothing(flat1460) - write(pp, flat1460) + flat1465 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) + if !isnothing(flat1465) + write(pp, flat1465) return nothing else - fields1459 = msg + fields1464 = msg write(pp, "(warehouse") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1459)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1464)) dedent!(pp) write(pp, ")") end @@ -4290,32 +4294,32 @@ function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCatalogConfig) - flat1468 = try_flat(pp, msg, pretty_iceberg_catalog_config) - if !isnothing(flat1468) - write(pp, flat1468) + flat1473 = try_flat(pp, msg, pretty_iceberg_catalog_config) + if !isnothing(flat1473) + write(pp, flat1473) return nothing else _dollar_dollar = msg - _t1757 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) - fields1461 = (_dollar_dollar.catalog_uri, _t1757, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) - unwrapped_fields1462 = fields1461 + _t1767 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) + fields1466 = (_dollar_dollar.catalog_uri, _t1767, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) + unwrapped_fields1467 = fields1466 write(pp, "(iceberg_catalog_config") indent_sexp!(pp) newline(pp) - field1463 = unwrapped_fields1462[1] - pretty_iceberg_catalog_uri(pp, field1463) - field1464 = unwrapped_fields1462[2] - if !isnothing(field1464) + field1468 = unwrapped_fields1467[1] + pretty_iceberg_catalog_uri(pp, field1468) + field1469 = unwrapped_fields1467[2] + if !isnothing(field1469) newline(pp) - opt_val1465 = field1464 - pretty_iceberg_catalog_config_scope(pp, opt_val1465) + opt_val1470 = field1469 + pretty_iceberg_catalog_config_scope(pp, opt_val1470) end newline(pp) - field1466 = unwrapped_fields1462[3] - pretty_iceberg_properties(pp, field1466) + field1471 = unwrapped_fields1467[3] + pretty_iceberg_properties(pp, field1471) newline(pp) - field1467 = unwrapped_fields1462[4] - pretty_iceberg_auth_properties(pp, field1467) + field1472 = unwrapped_fields1467[4] + pretty_iceberg_auth_properties(pp, field1472) dedent!(pp) write(pp, ")") end @@ -4323,16 +4327,16 @@ function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCata end function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) - flat1470 = try_flat(pp, msg, pretty_iceberg_catalog_uri) - if !isnothing(flat1470) - write(pp, flat1470) + flat1475 = try_flat(pp, msg, pretty_iceberg_catalog_uri) + if !isnothing(flat1475) + write(pp, flat1475) return nothing else - fields1469 = msg + fields1474 = msg write(pp, "(catalog_uri") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1469)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1474)) dedent!(pp) write(pp, ")") end @@ -4340,16 +4344,16 @@ function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) - flat1472 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) - if !isnothing(flat1472) - write(pp, flat1472) + flat1477 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) + if !isnothing(flat1477) + write(pp, flat1477) return nothing else - fields1471 = msg + fields1476 = msg write(pp, "(scope") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1471)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1476)) dedent!(pp) write(pp, ")") end @@ -4357,22 +4361,22 @@ function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) end function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1476 = try_flat(pp, msg, pretty_iceberg_properties) - if !isnothing(flat1476) - write(pp, flat1476) + flat1481 = try_flat(pp, msg, pretty_iceberg_properties) + if !isnothing(flat1481) + write(pp, flat1481) return nothing else - fields1473 = msg + fields1478 = msg write(pp, "(properties") indent_sexp!(pp) - if !isempty(fields1473) + if !isempty(fields1478) newline(pp) - for (i1758, elem1474) in enumerate(fields1473) - i1475 = i1758 - 1 - if (i1475 > 0) + for (i1768, elem1479) in enumerate(fields1478) + i1480 = i1768 - 1 + if (i1480 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1474) + pretty_iceberg_property_entry(pp, elem1479) end end dedent!(pp) @@ -4382,22 +4386,22 @@ function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, end function pretty_iceberg_property_entry(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1481 = try_flat(pp, msg, pretty_iceberg_property_entry) - if !isnothing(flat1481) - write(pp, flat1481) + flat1486 = try_flat(pp, msg, pretty_iceberg_property_entry) + if !isnothing(flat1486) + write(pp, flat1486) return nothing else _dollar_dollar = msg - fields1477 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields1478 = fields1477 + fields1482 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields1483 = fields1482 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1479 = unwrapped_fields1478[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1479)) + field1484 = unwrapped_fields1483[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1484)) newline(pp) - field1480 = unwrapped_fields1478[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1480)) + field1485 = unwrapped_fields1483[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1485)) dedent!(pp) write(pp, ")") end @@ -4405,22 +4409,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}}) - flat1485 = try_flat(pp, msg, pretty_iceberg_auth_properties) - if !isnothing(flat1485) - write(pp, flat1485) + flat1490 = try_flat(pp, msg, pretty_iceberg_auth_properties) + if !isnothing(flat1490) + write(pp, flat1490) return nothing else - fields1482 = msg + fields1487 = msg write(pp, "(auth_properties") indent_sexp!(pp) - if !isempty(fields1482) + if !isempty(fields1487) newline(pp) - for (i1759, elem1483) in enumerate(fields1482) - i1484 = i1759 - 1 - if (i1484 > 0) + for (i1769, elem1488) in enumerate(fields1487) + i1489 = i1769 - 1 + if (i1489 > 0) newline(pp) end - pretty_iceberg_masked_property_entry(pp, elem1483) + pretty_iceberg_masked_property_entry(pp, elem1488) end end dedent!(pp) @@ -4430,23 +4434,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}) - flat1490 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) - if !isnothing(flat1490) - write(pp, flat1490) + flat1495 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) + if !isnothing(flat1495) + write(pp, flat1495) return nothing else _dollar_dollar = msg - _t1760 = mask_secret_value(pp, _dollar_dollar) - fields1486 = (_dollar_dollar[1], _t1760,) - unwrapped_fields1487 = fields1486 + _t1770 = mask_secret_value(pp, _dollar_dollar) + fields1491 = (_dollar_dollar[1], _t1770,) + unwrapped_fields1492 = fields1491 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1488 = unwrapped_fields1487[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1488)) + field1493 = unwrapped_fields1492[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1493)) newline(pp) - field1489 = unwrapped_fields1487[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1489)) + field1494 = unwrapped_fields1492[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1494)) dedent!(pp) write(pp, ")") end @@ -4454,16 +4458,16 @@ function pretty_iceberg_masked_property_entry(pp::PrettyPrinter, msg::Tuple{Stri end function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) - flat1492 = try_flat(pp, msg, pretty_iceberg_from_snapshot) - if !isnothing(flat1492) - write(pp, flat1492) + flat1497 = try_flat(pp, msg, pretty_iceberg_from_snapshot) + if !isnothing(flat1497) + write(pp, flat1497) return nothing else - fields1491 = msg + fields1496 = msg write(pp, "(from_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1491)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1496)) dedent!(pp) write(pp, ")") end @@ -4471,16 +4475,16 @@ function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) end function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) - flat1494 = try_flat(pp, msg, pretty_iceberg_to_snapshot) - if !isnothing(flat1494) - write(pp, flat1494) + flat1499 = try_flat(pp, msg, pretty_iceberg_to_snapshot) + if !isnothing(flat1499) + write(pp, flat1499) return nothing else - fields1493 = msg + fields1498 = msg write(pp, "(to_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1493)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1498)) dedent!(pp) write(pp, ")") end @@ -4488,18 +4492,18 @@ function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1497 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1497) - write(pp, flat1497) + flat1502 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1502) + write(pp, flat1502) return nothing else _dollar_dollar = msg - fields1495 = _dollar_dollar.fragment_id - unwrapped_fields1496 = fields1495 + fields1500 = _dollar_dollar.fragment_id + unwrapped_fields1501 = fields1500 write(pp, "(undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1496) + pretty_fragment_id(pp, unwrapped_fields1501) dedent!(pp) write(pp, ")") end @@ -4507,24 +4511,24 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1502 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1502) - write(pp, flat1502) + flat1507 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1507) + write(pp, flat1507) return nothing else _dollar_dollar = msg - fields1498 = _dollar_dollar.relations - unwrapped_fields1499 = fields1498 + fields1503 = _dollar_dollar.relations + unwrapped_fields1504 = fields1503 write(pp, "(context") indent_sexp!(pp) - if !isempty(unwrapped_fields1499) + if !isempty(unwrapped_fields1504) newline(pp) - for (i1761, elem1500) in enumerate(unwrapped_fields1499) - i1501 = i1761 - 1 - if (i1501 > 0) + for (i1771, elem1505) in enumerate(unwrapped_fields1504) + i1506 = i1771 - 1 + if (i1506 > 0) newline(pp) end - pretty_relation_id(pp, elem1500) + pretty_relation_id(pp, elem1505) end end dedent!(pp) @@ -4534,28 +4538,28 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1509 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1509) - write(pp, flat1509) + flat1514 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1514) + write(pp, flat1514) return nothing else _dollar_dollar = msg - fields1503 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - unwrapped_fields1504 = fields1503 + fields1508 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + unwrapped_fields1509 = fields1508 write(pp, "(snapshot") indent_sexp!(pp) newline(pp) - field1505 = unwrapped_fields1504[1] - pretty_edb_path(pp, field1505) - field1506 = unwrapped_fields1504[2] - if !isempty(field1506) + field1510 = unwrapped_fields1509[1] + pretty_edb_path(pp, field1510) + field1511 = unwrapped_fields1509[2] + if !isempty(field1511) newline(pp) - for (i1762, elem1507) in enumerate(field1506) - i1508 = i1762 - 1 - if (i1508 > 0) + for (i1772, elem1512) in enumerate(field1511) + i1513 = i1772 - 1 + if (i1513 > 0) newline(pp) end - pretty_snapshot_mapping(pp, elem1507) + pretty_snapshot_mapping(pp, elem1512) end end dedent!(pp) @@ -4565,40 +4569,40 @@ function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) end function pretty_snapshot_mapping(pp::PrettyPrinter, msg::Proto.SnapshotMapping) - flat1514 = try_flat(pp, msg, pretty_snapshot_mapping) - if !isnothing(flat1514) - write(pp, flat1514) + flat1519 = try_flat(pp, msg, pretty_snapshot_mapping) + if !isnothing(flat1519) + write(pp, flat1519) return nothing else _dollar_dollar = msg - fields1510 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - unwrapped_fields1511 = fields1510 - field1512 = unwrapped_fields1511[1] - pretty_edb_path(pp, field1512) + fields1515 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + unwrapped_fields1516 = fields1515 + field1517 = unwrapped_fields1516[1] + pretty_edb_path(pp, field1517) write(pp, " ") - field1513 = unwrapped_fields1511[2] - pretty_relation_id(pp, field1513) + field1518 = unwrapped_fields1516[2] + pretty_relation_id(pp, field1518) end return nothing end function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1518 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1518) - write(pp, flat1518) + flat1523 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1523) + write(pp, flat1523) return nothing else - fields1515 = msg + fields1520 = msg write(pp, "(reads") indent_sexp!(pp) - if !isempty(fields1515) + if !isempty(fields1520) newline(pp) - for (i1763, elem1516) in enumerate(fields1515) - i1517 = i1763 - 1 - if (i1517 > 0) + for (i1773, elem1521) in enumerate(fields1520) + i1522 = i1773 - 1 + if (i1522 > 0) newline(pp) end - pretty_read(pp, elem1516) + pretty_read(pp, elem1521) end end dedent!(pp) @@ -4608,65 +4612,65 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1529 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1529) - write(pp, flat1529) + flat1534 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1534) + write(pp, flat1534) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1764 = _get_oneof_field(_dollar_dollar, :demand) + _t1774 = _get_oneof_field(_dollar_dollar, :demand) else - _t1764 = nothing + _t1774 = nothing end - deconstruct_result1527 = _t1764 - if !isnothing(deconstruct_result1527) - unwrapped1528 = deconstruct_result1527 - pretty_demand(pp, unwrapped1528) + deconstruct_result1532 = _t1774 + if !isnothing(deconstruct_result1532) + unwrapped1533 = deconstruct_result1532 + pretty_demand(pp, unwrapped1533) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1765 = _get_oneof_field(_dollar_dollar, :output) + _t1775 = _get_oneof_field(_dollar_dollar, :output) else - _t1765 = nothing + _t1775 = nothing end - deconstruct_result1525 = _t1765 - if !isnothing(deconstruct_result1525) - unwrapped1526 = deconstruct_result1525 - pretty_output(pp, unwrapped1526) + deconstruct_result1530 = _t1775 + if !isnothing(deconstruct_result1530) + unwrapped1531 = deconstruct_result1530 + pretty_output(pp, unwrapped1531) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1766 = _get_oneof_field(_dollar_dollar, :what_if) + _t1776 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1766 = nothing + _t1776 = nothing end - deconstruct_result1523 = _t1766 - if !isnothing(deconstruct_result1523) - unwrapped1524 = deconstruct_result1523 - pretty_what_if(pp, unwrapped1524) + deconstruct_result1528 = _t1776 + if !isnothing(deconstruct_result1528) + unwrapped1529 = deconstruct_result1528 + pretty_what_if(pp, unwrapped1529) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1767 = _get_oneof_field(_dollar_dollar, :abort) + _t1777 = _get_oneof_field(_dollar_dollar, :abort) else - _t1767 = nothing + _t1777 = nothing end - deconstruct_result1521 = _t1767 - if !isnothing(deconstruct_result1521) - unwrapped1522 = deconstruct_result1521 - pretty_abort(pp, unwrapped1522) + deconstruct_result1526 = _t1777 + if !isnothing(deconstruct_result1526) + unwrapped1527 = deconstruct_result1526 + pretty_abort(pp, unwrapped1527) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1768 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1778 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1768 = nothing + _t1778 = nothing end - deconstruct_result1519 = _t1768 - if !isnothing(deconstruct_result1519) - unwrapped1520 = deconstruct_result1519 - pretty_export(pp, unwrapped1520) + deconstruct_result1524 = _t1778 + if !isnothing(deconstruct_result1524) + unwrapped1525 = deconstruct_result1524 + pretty_export(pp, unwrapped1525) else throw(ParseError("No matching rule for read")) end @@ -4679,18 +4683,18 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1532 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1532) - write(pp, flat1532) + flat1537 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1537) + write(pp, flat1537) return nothing else _dollar_dollar = msg - fields1530 = _dollar_dollar.relation_id - unwrapped_fields1531 = fields1530 + fields1535 = _dollar_dollar.relation_id + unwrapped_fields1536 = fields1535 write(pp, "(demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1531) + pretty_relation_id(pp, unwrapped_fields1536) dedent!(pp) write(pp, ")") end @@ -4698,22 +4702,22 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1537 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1537) - write(pp, flat1537) + flat1542 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1542) + write(pp, flat1542) return nothing else _dollar_dollar = msg - fields1533 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - unwrapped_fields1534 = fields1533 + fields1538 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + unwrapped_fields1539 = fields1538 write(pp, "(output") indent_sexp!(pp) newline(pp) - field1535 = unwrapped_fields1534[1] - pretty_name(pp, field1535) + field1540 = unwrapped_fields1539[1] + pretty_name(pp, field1540) newline(pp) - field1536 = unwrapped_fields1534[2] - pretty_relation_id(pp, field1536) + field1541 = unwrapped_fields1539[2] + pretty_relation_id(pp, field1541) dedent!(pp) write(pp, ")") end @@ -4721,22 +4725,22 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1542 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1542) - write(pp, flat1542) + flat1547 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1547) + write(pp, flat1547) return nothing else _dollar_dollar = msg - fields1538 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - unwrapped_fields1539 = fields1538 + fields1543 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + unwrapped_fields1544 = fields1543 write(pp, "(what_if") indent_sexp!(pp) newline(pp) - field1540 = unwrapped_fields1539[1] - pretty_name(pp, field1540) + field1545 = unwrapped_fields1544[1] + pretty_name(pp, field1545) newline(pp) - field1541 = unwrapped_fields1539[2] - pretty_epoch(pp, field1541) + field1546 = unwrapped_fields1544[2] + pretty_epoch(pp, field1546) dedent!(pp) write(pp, ")") end @@ -4744,30 +4748,30 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1548 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1548) - write(pp, flat1548) + flat1553 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1553) + write(pp, flat1553) return nothing else _dollar_dollar = msg if _dollar_dollar.name != "abort" - _t1769 = _dollar_dollar.name + _t1779 = _dollar_dollar.name else - _t1769 = nothing + _t1779 = nothing end - fields1543 = (_t1769, _dollar_dollar.relation_id,) - unwrapped_fields1544 = fields1543 + fields1548 = (_t1779, _dollar_dollar.relation_id,) + unwrapped_fields1549 = fields1548 write(pp, "(abort") indent_sexp!(pp) - field1545 = unwrapped_fields1544[1] - if !isnothing(field1545) + field1550 = unwrapped_fields1549[1] + if !isnothing(field1550) newline(pp) - opt_val1546 = field1545 - pretty_name(pp, opt_val1546) + opt_val1551 = field1550 + pretty_name(pp, opt_val1551) end newline(pp) - field1547 = unwrapped_fields1544[2] - pretty_relation_id(pp, field1547) + field1552 = unwrapped_fields1549[2] + pretty_relation_id(pp, field1552) dedent!(pp) write(pp, ")") end @@ -4775,40 +4779,40 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1553 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1553) - write(pp, flat1553) + flat1558 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1558) + write(pp, flat1558) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_config")) - _t1770 = _get_oneof_field(_dollar_dollar, :csv_config) + _t1780 = _get_oneof_field(_dollar_dollar, :csv_config) else - _t1770 = nothing + _t1780 = nothing end - deconstruct_result1551 = _t1770 - if !isnothing(deconstruct_result1551) - unwrapped1552 = deconstruct_result1551 + deconstruct_result1556 = _t1780 + if !isnothing(deconstruct_result1556) + unwrapped1557 = deconstruct_result1556 write(pp, "(export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped1552) + pretty_export_csv_config(pp, unwrapped1557) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_config")) - _t1771 = _get_oneof_field(_dollar_dollar, :iceberg_config) + _t1781 = _get_oneof_field(_dollar_dollar, :iceberg_config) else - _t1771 = nothing + _t1781 = nothing end - deconstruct_result1549 = _t1771 - if !isnothing(deconstruct_result1549) - unwrapped1550 = deconstruct_result1549 + deconstruct_result1554 = _t1781 + if !isnothing(deconstruct_result1554) + unwrapped1555 = deconstruct_result1554 write(pp, "(export_iceberg") indent_sexp!(pp) newline(pp) - pretty_export_iceberg_config(pp, unwrapped1550) + pretty_export_iceberg_config(pp, unwrapped1555) dedent!(pp) write(pp, ")") else @@ -4820,55 +4824,56 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1564 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1564) - write(pp, flat1564) + flat1569 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1569) + write(pp, flat1569) return nothing else _dollar_dollar = msg if length(_dollar_dollar.data_columns) == 0 - _t1772 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1783 = deconstruct_export_csv_output_location(pp, _dollar_dollar) + _t1782 = (_t1783, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else - _t1772 = nothing + _t1782 = nothing end - deconstruct_result1559 = _t1772 - if !isnothing(deconstruct_result1559) - unwrapped1560 = deconstruct_result1559 + deconstruct_result1564 = _t1782 + if !isnothing(deconstruct_result1564) + unwrapped1565 = deconstruct_result1564 write(pp, "(export_csv_config_v2") indent_sexp!(pp) newline(pp) - field1561 = unwrapped1560[1] - pretty_export_csv_path(pp, field1561) + field1566 = unwrapped1565[1] + pretty_export_csv_output_location(pp, field1566) newline(pp) - field1562 = unwrapped1560[2] - pretty_export_csv_source(pp, field1562) + field1567 = unwrapped1565[2] + pretty_export_csv_source(pp, field1567) newline(pp) - field1563 = unwrapped1560[3] - pretty_csv_config(pp, field1563) + field1568 = unwrapped1565[3] + pretty_csv_config(pp, field1568) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if length(_dollar_dollar.data_columns) != 0 - _t1774 = deconstruct_export_csv_config(pp, _dollar_dollar) - _t1773 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1774,) + _t1785 = deconstruct_export_csv_config(pp, _dollar_dollar) + _t1784 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1785,) else - _t1773 = nothing + _t1784 = nothing end - deconstruct_result1554 = _t1773 - if !isnothing(deconstruct_result1554) - unwrapped1555 = deconstruct_result1554 + deconstruct_result1559 = _t1784 + if !isnothing(deconstruct_result1559) + unwrapped1560 = deconstruct_result1559 write(pp, "(export_csv_config") indent_sexp!(pp) newline(pp) - field1556 = unwrapped1555[1] - pretty_export_csv_path(pp, field1556) + field1561 = unwrapped1560[1] + pretty_export_csv_path(pp, field1561) newline(pp) - field1557 = unwrapped1555[2] - pretty_export_csv_columns_list(pp, field1557) + field1562 = unwrapped1560[2] + pretty_export_csv_columns_list(pp, field1562) newline(pp) - field1558 = unwrapped1555[3] - pretty_config_dict(pp, field1558) + field1563 = unwrapped1560[3] + pretty_config_dict(pp, field1563) dedent!(pp) write(pp, ")") else @@ -4879,48 +4884,76 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) return nothing end -function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1566 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1566) - write(pp, flat1566) +function pretty_export_csv_output_location(pp::PrettyPrinter, msg::Tuple{String, String}) + flat1574 = try_flat(pp, msg, pretty_export_csv_output_location) + if !isnothing(flat1574) + write(pp, flat1574) return nothing else - fields1565 = msg - write(pp, "(path") - indent_sexp!(pp) - newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1565)) - dedent!(pp) - write(pp, ")") + _dollar_dollar = msg + if _dollar_dollar[1] != "" + _t1786 = _dollar_dollar[1] + else + _t1786 = nothing + end + deconstruct_result1572 = _t1786 + if !isnothing(deconstruct_result1572) + unwrapped1573 = deconstruct_result1572 + write(pp, "(path") + indent_sexp!(pp) + newline(pp) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1573)) + dedent!(pp) + write(pp, ")") + else + _dollar_dollar = msg + if _dollar_dollar[2] != "" + _t1787 = _dollar_dollar[2] + else + _t1787 = nothing + end + deconstruct_result1570 = _t1787 + if !isnothing(deconstruct_result1570) + unwrapped1571 = deconstruct_result1570 + write(pp, "(transaction_output_name") + indent_sexp!(pp) + newline(pp) + pretty_name(pp, unwrapped1571) + dedent!(pp) + write(pp, ")") + else + throw(ParseError("No matching rule for export_csv_output_location")) + end + end end return nothing end function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) - flat1573 = try_flat(pp, msg, pretty_export_csv_source) - if !isnothing(flat1573) - write(pp, flat1573) + flat1581 = try_flat(pp, msg, pretty_export_csv_source) + if !isnothing(flat1581) + write(pp, flat1581) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("gnf_columns")) - _t1775 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns + _t1788 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns else - _t1775 = nothing + _t1788 = nothing end - deconstruct_result1569 = _t1775 - if !isnothing(deconstruct_result1569) - unwrapped1570 = deconstruct_result1569 + deconstruct_result1577 = _t1788 + if !isnothing(deconstruct_result1577) + unwrapped1578 = deconstruct_result1577 write(pp, "(gnf_columns") indent_sexp!(pp) - if !isempty(unwrapped1570) + if !isempty(unwrapped1578) newline(pp) - for (i1776, elem1571) in enumerate(unwrapped1570) - i1572 = i1776 - 1 - if (i1572 > 0) + for (i1789, elem1579) in enumerate(unwrapped1578) + i1580 = i1789 - 1 + if (i1580 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1571) + pretty_export_csv_column(pp, elem1579) end end dedent!(pp) @@ -4928,17 +4961,17 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("table_def")) - _t1777 = _get_oneof_field(_dollar_dollar, :table_def) + _t1790 = _get_oneof_field(_dollar_dollar, :table_def) else - _t1777 = nothing + _t1790 = nothing end - deconstruct_result1567 = _t1777 - if !isnothing(deconstruct_result1567) - unwrapped1568 = deconstruct_result1567 + deconstruct_result1575 = _t1790 + if !isnothing(deconstruct_result1575) + unwrapped1576 = deconstruct_result1575 write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped1568) + pretty_relation_id(pp, unwrapped1576) dedent!(pp) write(pp, ")") else @@ -4950,22 +4983,39 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1578 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1578) - write(pp, flat1578) + flat1586 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1586) + write(pp, flat1586) return nothing else _dollar_dollar = msg - fields1574 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - unwrapped_fields1575 = fields1574 + fields1582 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + unwrapped_fields1583 = fields1582 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1576 = unwrapped_fields1575[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1576)) + field1584 = unwrapped_fields1583[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1584)) + newline(pp) + field1585 = unwrapped_fields1583[2] + pretty_relation_id(pp, field1585) + dedent!(pp) + write(pp, ")") + end + return nothing +end + +function pretty_export_csv_path(pp::PrettyPrinter, msg::String) + flat1588 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1588) + write(pp, flat1588) + return nothing + else + fields1587 = msg + write(pp, "(path") + indent_sexp!(pp) newline(pp) - field1577 = unwrapped_fields1575[2] - pretty_relation_id(pp, field1577) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1587)) dedent!(pp) write(pp, ")") end @@ -4973,22 +5023,22 @@ function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) end function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1582 = try_flat(pp, msg, pretty_export_csv_columns_list) - if !isnothing(flat1582) - write(pp, flat1582) + flat1592 = try_flat(pp, msg, pretty_export_csv_columns_list) + if !isnothing(flat1592) + write(pp, flat1592) return nothing else - fields1579 = msg + fields1589 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1579) + if !isempty(fields1589) newline(pp) - for (i1778, elem1580) in enumerate(fields1579) - i1581 = i1778 - 1 - if (i1581 > 0) + for (i1791, elem1590) in enumerate(fields1589) + i1591 = i1791 - 1 + if (i1591 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1580) + pretty_export_csv_column(pp, elem1590) end end dedent!(pp) @@ -4998,34 +5048,34 @@ function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.Exp end function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIcebergConfig) - flat1591 = try_flat(pp, msg, pretty_export_iceberg_config) - if !isnothing(flat1591) - write(pp, flat1591) + flat1601 = try_flat(pp, msg, pretty_export_iceberg_config) + if !isnothing(flat1601) + write(pp, flat1601) return nothing else _dollar_dollar = msg - _t1779 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) - fields1583 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1779,) - unwrapped_fields1584 = fields1583 + _t1792 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) + fields1593 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1792,) + unwrapped_fields1594 = fields1593 write(pp, "(export_iceberg_config") indent_sexp!(pp) newline(pp) - field1585 = unwrapped_fields1584[1] - pretty_iceberg_locator(pp, field1585) + field1595 = unwrapped_fields1594[1] + pretty_iceberg_locator(pp, field1595) newline(pp) - field1586 = unwrapped_fields1584[2] - pretty_iceberg_catalog_config(pp, field1586) + field1596 = unwrapped_fields1594[2] + pretty_iceberg_catalog_config(pp, field1596) newline(pp) - field1587 = unwrapped_fields1584[3] - pretty_export_iceberg_table_def(pp, field1587) + field1597 = unwrapped_fields1594[3] + pretty_export_iceberg_table_def(pp, field1597) newline(pp) - field1588 = unwrapped_fields1584[4] - pretty_iceberg_table_properties(pp, field1588) - field1589 = unwrapped_fields1584[5] - if !isnothing(field1589) + field1598 = unwrapped_fields1594[4] + pretty_iceberg_table_properties(pp, field1598) + field1599 = unwrapped_fields1594[5] + if !isnothing(field1599) newline(pp) - opt_val1590 = field1589 - pretty_config_dict(pp, opt_val1590) + opt_val1600 = field1599 + pretty_config_dict(pp, opt_val1600) end dedent!(pp) write(pp, ")") @@ -5034,16 +5084,16 @@ function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIceber end function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationId) - flat1593 = try_flat(pp, msg, pretty_export_iceberg_table_def) - if !isnothing(flat1593) - write(pp, flat1593) + flat1603 = try_flat(pp, msg, pretty_export_iceberg_table_def) + if !isnothing(flat1603) + write(pp, flat1603) return nothing else - fields1592 = msg + fields1602 = msg write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, fields1592) + pretty_relation_id(pp, fields1602) dedent!(pp) write(pp, ")") end @@ -5051,22 +5101,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}}) - flat1597 = try_flat(pp, msg, pretty_iceberg_table_properties) - if !isnothing(flat1597) - write(pp, flat1597) + flat1607 = try_flat(pp, msg, pretty_iceberg_table_properties) + if !isnothing(flat1607) + write(pp, flat1607) return nothing else - fields1594 = msg + fields1604 = msg write(pp, "(table_properties") indent_sexp!(pp) - if !isempty(fields1594) + if !isempty(fields1604) newline(pp) - for (i1780, elem1595) in enumerate(fields1594) - i1596 = i1780 - 1 - if (i1596 > 0) + for (i1793, elem1605) in enumerate(fields1604) + i1606 = i1793 - 1 + if (i1606 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1595) + pretty_iceberg_property_entry(pp, elem1605) end end dedent!(pp) @@ -5081,12 +5131,12 @@ end function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1832, _rid) in enumerate(msg.ids) - _idx = i1832 - 1 + for (i1845, _rid) in enumerate(msg.ids) + _idx = i1845 - 1 newline(pp) write(pp, "(") - _t1833 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1833) + _t1846 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1846) write(pp, " ") write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -5158,8 +5208,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe _pprint_dispatch(pp, msg.guard) newline(pp) write(pp, ":keys (") - for (i1834, _elem) in enumerate(msg.keys) - _idx = i1834 - 1 + for (i1847, _elem) in enumerate(msg.keys) + _idx = i1847 - 1 if (_idx > 0) write(pp, " ") end @@ -5168,8 +5218,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe write(pp, ")") newline(pp) write(pp, ":values (") - for (i1835, _elem) in enumerate(msg.values) - _idx = i1835 - 1 + for (i1848, _elem) in enumerate(msg.values) + _idx = i1848 - 1 if (_idx > 0) write(pp, " ") end @@ -5223,8 +5273,8 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Proto.ExportCSVColumn indent_sexp!(pp) newline(pp) write(pp, ":columns (") - for (i1836, _elem) in enumerate(msg.columns) - _idx = i1836 - 1 + for (i1849, _elem) in enumerate(msg.columns) + _idx = i1849 - 1 if (_idx > 0) write(pp, " ") end diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index 3aa748e1..4bed2f96 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -424,196 +424,196 @@ def relation_id_to_uint128(self, msg): def _extract_value_int32(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None - _t2088 = value.HasField("int32_value") + _t2100 = value.HasField("int32_value") else: - _t2088 = False - if _t2088: + _t2100 = False + if _t2100: assert value is not None return value.int32_value else: - _t2089 = None + _t2101 = None return int(default) def _extract_value_int64(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None - _t2090 = value.HasField("int_value") + _t2102 = value.HasField("int_value") else: - _t2090 = False - if _t2090: + _t2102 = False + if _t2102: assert value is not None return value.int_value else: - _t2091 = None + _t2103 = 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 - _t2092 = value.HasField("string_value") + _t2104 = value.HasField("string_value") else: - _t2092 = False - if _t2092: + _t2104 = False + if _t2104: assert value is not None return value.string_value else: - _t2093 = None + _t2105 = 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 - _t2094 = value.HasField("boolean_value") + _t2106 = value.HasField("boolean_value") else: - _t2094 = False - if _t2094: + _t2106 = False + if _t2106: assert value is not None return value.boolean_value else: - _t2095 = None + _t2107 = 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 - _t2096 = value.HasField("string_value") + _t2108 = value.HasField("string_value") else: - _t2096 = False - if _t2096: + _t2108 = False + if _t2108: assert value is not None return [value.string_value] else: - _t2097 = None + _t2109 = 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 - _t2098 = value.HasField("int_value") + _t2110 = value.HasField("int_value") else: - _t2098 = False - if _t2098: + _t2110 = False + if _t2110: assert value is not None return value.int_value else: - _t2099 = None + _t2111 = 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 - _t2100 = value.HasField("float_value") + _t2112 = value.HasField("float_value") else: - _t2100 = False - if _t2100: + _t2112 = False + if _t2112: assert value is not None return value.float_value else: - _t2101 = None + _t2113 = 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 - _t2102 = value.HasField("string_value") + _t2114 = value.HasField("string_value") else: - _t2102 = False - if _t2102: + _t2114 = False + if _t2114: assert value is not None return value.string_value.encode() else: - _t2103 = None + _t2115 = 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 - _t2104 = value.HasField("uint128_value") + _t2116 = value.HasField("uint128_value") else: - _t2104 = False - if _t2104: + _t2116 = False + if _t2116: assert value is not None return value.uint128_value else: - _t2105 = None + _t2117 = None return None 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) - _t2106 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2106 - _t2107 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2107 - _t2108 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2108 - _t2109 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2109 - _t2110 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2110 - _t2111 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2111 - _t2112 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2112 - _t2113 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2113 - _t2114 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2114 - _t2115 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2115 - _t2116 = self._extract_value_string(config.get("csv_compression"), "") - compression = _t2116 - _t2117 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2117 - _t2118 = self.construct_csv_storage_integration(storage_integration_opt) - storage_integration = _t2118 - _t2119 = 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 _t2119 + _t2118 = self._extract_value_int32(config.get("csv_header_row"), 1) + header_row = _t2118 + _t2119 = self._extract_value_int64(config.get("csv_skip"), 0) + skip = _t2119 + _t2120 = self._extract_value_string(config.get("csv_new_line"), "") + new_line = _t2120 + _t2121 = self._extract_value_string(config.get("csv_delimiter"), ",") + delimiter = _t2121 + _t2122 = self._extract_value_string(config.get("csv_quotechar"), '"') + quotechar = _t2122 + _t2123 = self._extract_value_string(config.get("csv_escapechar"), '"') + escapechar = _t2123 + _t2124 = self._extract_value_string(config.get("csv_comment"), "") + comment = _t2124 + _t2125 = self._extract_value_string_list(config.get("csv_missing_strings"), []) + missing_strings = _t2125 + _t2126 = self._extract_value_string(config.get("csv_decimal_separator"), ".") + decimal_separator = _t2126 + _t2127 = self._extract_value_string(config.get("csv_encoding"), "utf-8") + encoding = _t2127 + _t2128 = self._extract_value_string(config.get("csv_compression"), "") + compression = _t2128 + _t2129 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) + partition_size_mb = _t2129 + _t2130 = self.construct_csv_storage_integration(storage_integration_opt) + storage_integration = _t2130 + _t2131 = 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 _t2131 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: - _t2120 = None + _t2132 = None assert storage_integration_opt is not None config = dict(storage_integration_opt) - _t2121 = self._extract_value_string(config.get("provider"), "") - _t2122 = self._extract_value_string(config.get("azure_sas_token"), "") - _t2123 = self._extract_value_string(config.get("s3_region"), "") - _t2124 = self._extract_value_string(config.get("s3_access_key_id"), "") - _t2125 = self._extract_value_string(config.get("s3_secret_access_key"), "") - _t2126 = logic_pb2.StorageIntegration(provider=_t2121, azure_sas_token=_t2122, s3_region=_t2123, s3_access_key_id=_t2124, s3_secret_access_key=_t2125) - return _t2126 + _t2133 = self._extract_value_string(config.get("provider"), "") + _t2134 = self._extract_value_string(config.get("azure_sas_token"), "") + _t2135 = self._extract_value_string(config.get("s3_region"), "") + _t2136 = self._extract_value_string(config.get("s3_access_key_id"), "") + _t2137 = self._extract_value_string(config.get("s3_secret_access_key"), "") + _t2138 = logic_pb2.StorageIntegration(provider=_t2133, azure_sas_token=_t2134, s3_region=_t2135, s3_access_key_id=_t2136, s3_secret_access_key=_t2137) + return _t2138 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) - _t2127 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2127 - _t2128 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2128 - _t2129 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2129 - _t2130 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2130 - _t2131 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2131 - _t2132 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2132 - _t2133 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2133 - _t2134 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2134 - _t2135 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2135 - _t2136 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2136 - _t2137 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2137 + _t2139 = self._try_extract_value_float64(config.get("betree_config_epsilon")) + epsilon = _t2139 + _t2140 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) + max_pivots = _t2140 + _t2141 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) + max_deltas = _t2141 + _t2142 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) + max_leaf = _t2142 + _t2143 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2143 + _t2144 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) + root_pageid = _t2144 + _t2145 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) + inline_data = _t2145 + _t2146 = self._try_extract_value_int64(config.get("betree_locator_element_count")) + element_count = _t2146 + _t2147 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) + tree_height = _t2147 + _t2148 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) + relation_locator = _t2148 + _t2149 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2149 def default_configure(self) -> transactions_pb2.Configure: - _t2138 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2138 - _t2139 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2139 + _t2150 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2150 + _t2151 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2151 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -630,3376 +630,3409 @@ 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 - _t2140 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2140 - _t2141 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2141 - _t2142 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2142 + _t2152 = transactions_pb2.IVMConfig(level=maintenance_level) + ivm_config = _t2152 + _t2153 = self._extract_value_int64(config.get("semantics_version"), 0) + semantics_version = _t2153 + _t2154 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2154 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) - _t2143 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2143 - _t2144 = self._extract_value_string(config.get("compression"), "") - compression = _t2144 - _t2145 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2145 - _t2146 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2146 - _t2147 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2147 - _t2148 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2148 - _t2149 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2149 - _t2150 = 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 _t2150 - - def construct_export_csv_config_with_source(self, path: str, csv_source: transactions_pb2.ExportCSVSource, csv_config: logic_pb2.CSVConfig) -> transactions_pb2.ExportCSVConfig: - _t2151 = transactions_pb2.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2151 + _t2155 = self._extract_value_int64(config.get("partition_size"), 0) + partition_size = _t2155 + _t2156 = self._extract_value_string(config.get("compression"), "") + compression = _t2156 + _t2157 = self._extract_value_boolean(config.get("syntax_header_row"), True) + syntax_header_row = _t2157 + _t2158 = self._extract_value_string(config.get("syntax_missing_string"), "") + syntax_missing_string = _t2158 + _t2159 = self._extract_value_string(config.get("syntax_delim"), ",") + syntax_delim = _t2159 + _t2160 = self._extract_value_string(config.get("syntax_quotechar"), '"') + syntax_quotechar = _t2160 + _t2161 = self._extract_value_string(config.get("syntax_escapechar"), "\\") + syntax_escapechar = _t2161 + _t2162 = 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 _t2162 + + 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: + _t2163 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) + return _t2163 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) - _t2152 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2152 + _t2164 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) + return _t2164 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: - _t2153 = 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 _t2153 + _t2165 = 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 _t2165 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 [])) - _t2154 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2154 - _t2155 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2155 - _t2156 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2156 + _t2166 = self._extract_value_string(cfg.get("prefix"), "") + prefix = _t2166 + _t2167 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) + target_file_size_bytes = _t2167 + _t2168 = self._extract_value_string(cfg.get("compression"), "") + compression = _t2168 table_props = dict(table_property_pairs) - _t2157 = 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 _t2157 + _t2169 = 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 _t2169 # --- Parse methods --- def parse_transaction(self) -> transactions_pb2.Transaction: - span_start673 = self.span_start() + span_start676 = self.span_start() self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t1335 = self.parse_configure() - _t1334 = _t1335 + _t1341 = self.parse_configure() + _t1340 = _t1341 else: - _t1334 = None - configure667 = _t1334 + _t1340 = None + configure670 = _t1340 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t1337 = self.parse_sync() - _t1336 = _t1337 - else: - _t1336 = None - sync668 = _t1336 - xs669 = [] - cond670 = self.match_lookahead_literal("(", 0) - while cond670: - _t1338 = self.parse_epoch() - item671 = _t1338 - xs669.append(item671) - cond670 = self.match_lookahead_literal("(", 0) - epochs672 = xs669 - self.consume_literal(")") - _t1339 = self.default_configure() - _t1340 = transactions_pb2.Transaction(epochs=epochs672, configure=(configure667 if configure667 is not None else _t1339), sync=sync668) - result674 = _t1340 - self.record_span(span_start673, "Transaction") - return result674 + _t1343 = self.parse_sync() + _t1342 = _t1343 + else: + _t1342 = None + sync671 = _t1342 + xs672 = [] + cond673 = self.match_lookahead_literal("(", 0) + while cond673: + _t1344 = self.parse_epoch() + item674 = _t1344 + xs672.append(item674) + cond673 = self.match_lookahead_literal("(", 0) + epochs675 = xs672 + self.consume_literal(")") + _t1345 = self.default_configure() + _t1346 = transactions_pb2.Transaction(epochs=epochs675, configure=(configure670 if configure670 is not None else _t1345), sync=sync671) + result677 = _t1346 + self.record_span(span_start676, "Transaction") + return result677 def parse_configure(self) -> transactions_pb2.Configure: - span_start676 = self.span_start() + span_start679 = self.span_start() self.consume_literal("(") self.consume_literal("configure") - _t1341 = self.parse_config_dict() - config_dict675 = _t1341 + _t1347 = self.parse_config_dict() + config_dict678 = _t1347 self.consume_literal(")") - _t1342 = self.construct_configure(config_dict675) - result677 = _t1342 - self.record_span(span_start676, "Configure") - return result677 + _t1348 = self.construct_configure(config_dict678) + result680 = _t1348 + self.record_span(span_start679, "Configure") + return result680 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs678 = [] - cond679 = self.match_lookahead_literal(":", 0) - while cond679: - _t1343 = self.parse_config_key_value() - item680 = _t1343 - xs678.append(item680) - cond679 = self.match_lookahead_literal(":", 0) - config_key_values681 = xs678 + xs681 = [] + cond682 = self.match_lookahead_literal(":", 0) + while cond682: + _t1349 = self.parse_config_key_value() + item683 = _t1349 + xs681.append(item683) + cond682 = self.match_lookahead_literal(":", 0) + config_key_values684 = xs681 self.consume_literal("}") - return config_key_values681 + return config_key_values684 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol682 = self.consume_terminal("SYMBOL") - _t1344 = self.parse_raw_value() - raw_value683 = _t1344 - return (symbol682, raw_value683,) + symbol685 = self.consume_terminal("SYMBOL") + _t1350 = self.parse_raw_value() + raw_value686 = _t1350 + return (symbol685, raw_value686,) def parse_raw_value(self) -> logic_pb2.Value: - span_start697 = self.span_start() + span_start700 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1345 = 12 + _t1351 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1346 = 11 + _t1352 = 11 else: if self.match_lookahead_literal("false", 0): - _t1347 = 12 + _t1353 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1349 = 1 + _t1355 = 1 else: if self.match_lookahead_literal("date", 1): - _t1350 = 0 + _t1356 = 0 else: - _t1350 = -1 - _t1349 = _t1350 - _t1348 = _t1349 + _t1356 = -1 + _t1355 = _t1356 + _t1354 = _t1355 else: if self.match_lookahead_terminal("UINT32", 0): - _t1351 = 7 + _t1357 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1352 = 8 + _t1358 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1353 = 2 + _t1359 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1354 = 3 + _t1360 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1355 = 9 + _t1361 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1356 = 4 + _t1362 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1357 = 5 + _t1363 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1358 = 6 + _t1364 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1359 = 10 + _t1365 = 10 else: - _t1359 = -1 - _t1358 = _t1359 - _t1357 = _t1358 - _t1356 = _t1357 - _t1355 = _t1356 - _t1354 = _t1355 - _t1353 = _t1354 - _t1352 = _t1353 - _t1351 = _t1352 - _t1348 = _t1351 - _t1347 = _t1348 - _t1346 = _t1347 - _t1345 = _t1346 - prediction684 = _t1345 - if prediction684 == 12: - _t1361 = self.parse_boolean_value() - boolean_value696 = _t1361 - _t1362 = logic_pb2.Value(boolean_value=boolean_value696) - _t1360 = _t1362 - else: - if prediction684 == 11: + _t1365 = -1 + _t1364 = _t1365 + _t1363 = _t1364 + _t1362 = _t1363 + _t1361 = _t1362 + _t1360 = _t1361 + _t1359 = _t1360 + _t1358 = _t1359 + _t1357 = _t1358 + _t1354 = _t1357 + _t1353 = _t1354 + _t1352 = _t1353 + _t1351 = _t1352 + prediction687 = _t1351 + if prediction687 == 12: + _t1367 = self.parse_boolean_value() + boolean_value699 = _t1367 + _t1368 = logic_pb2.Value(boolean_value=boolean_value699) + _t1366 = _t1368 + else: + if prediction687 == 11: self.consume_literal("missing") - _t1364 = logic_pb2.MissingValue() - _t1365 = logic_pb2.Value(missing_value=_t1364) - _t1363 = _t1365 + _t1370 = logic_pb2.MissingValue() + _t1371 = logic_pb2.Value(missing_value=_t1370) + _t1369 = _t1371 else: - if prediction684 == 10: - decimal695 = self.consume_terminal("DECIMAL") - _t1367 = logic_pb2.Value(decimal_value=decimal695) - _t1366 = _t1367 + if prediction687 == 10: + decimal698 = self.consume_terminal("DECIMAL") + _t1373 = logic_pb2.Value(decimal_value=decimal698) + _t1372 = _t1373 else: - if prediction684 == 9: - int128694 = self.consume_terminal("INT128") - _t1369 = logic_pb2.Value(int128_value=int128694) - _t1368 = _t1369 + if prediction687 == 9: + int128697 = self.consume_terminal("INT128") + _t1375 = logic_pb2.Value(int128_value=int128697) + _t1374 = _t1375 else: - if prediction684 == 8: - uint128693 = self.consume_terminal("UINT128") - _t1371 = logic_pb2.Value(uint128_value=uint128693) - _t1370 = _t1371 + if prediction687 == 8: + uint128696 = self.consume_terminal("UINT128") + _t1377 = logic_pb2.Value(uint128_value=uint128696) + _t1376 = _t1377 else: - if prediction684 == 7: - uint32692 = self.consume_terminal("UINT32") - _t1373 = logic_pb2.Value(uint32_value=uint32692) - _t1372 = _t1373 + if prediction687 == 7: + uint32695 = self.consume_terminal("UINT32") + _t1379 = logic_pb2.Value(uint32_value=uint32695) + _t1378 = _t1379 else: - if prediction684 == 6: - float691 = self.consume_terminal("FLOAT") - _t1375 = logic_pb2.Value(float_value=float691) - _t1374 = _t1375 + if prediction687 == 6: + float694 = self.consume_terminal("FLOAT") + _t1381 = logic_pb2.Value(float_value=float694) + _t1380 = _t1381 else: - if prediction684 == 5: - float32690 = self.consume_terminal("FLOAT32") - _t1377 = logic_pb2.Value(float32_value=float32690) - _t1376 = _t1377 + if prediction687 == 5: + float32693 = self.consume_terminal("FLOAT32") + _t1383 = logic_pb2.Value(float32_value=float32693) + _t1382 = _t1383 else: - if prediction684 == 4: - int689 = self.consume_terminal("INT") - _t1379 = logic_pb2.Value(int_value=int689) - _t1378 = _t1379 + if prediction687 == 4: + int692 = self.consume_terminal("INT") + _t1385 = logic_pb2.Value(int_value=int692) + _t1384 = _t1385 else: - if prediction684 == 3: - int32688 = self.consume_terminal("INT32") - _t1381 = logic_pb2.Value(int32_value=int32688) - _t1380 = _t1381 + if prediction687 == 3: + int32691 = self.consume_terminal("INT32") + _t1387 = logic_pb2.Value(int32_value=int32691) + _t1386 = _t1387 else: - if prediction684 == 2: - string687 = self.consume_terminal("STRING") - _t1383 = logic_pb2.Value(string_value=string687) - _t1382 = _t1383 + if prediction687 == 2: + string690 = self.consume_terminal("STRING") + _t1389 = logic_pb2.Value(string_value=string690) + _t1388 = _t1389 else: - if prediction684 == 1: - _t1385 = self.parse_raw_datetime() - raw_datetime686 = _t1385 - _t1386 = logic_pb2.Value(datetime_value=raw_datetime686) - _t1384 = _t1386 + if prediction687 == 1: + _t1391 = self.parse_raw_datetime() + raw_datetime689 = _t1391 + _t1392 = logic_pb2.Value(datetime_value=raw_datetime689) + _t1390 = _t1392 else: - if prediction684 == 0: - _t1388 = self.parse_raw_date() - raw_date685 = _t1388 - _t1389 = logic_pb2.Value(date_value=raw_date685) - _t1387 = _t1389 + if prediction687 == 0: + _t1394 = self.parse_raw_date() + raw_date688 = _t1394 + _t1395 = logic_pb2.Value(date_value=raw_date688) + _t1393 = _t1395 else: raise ParseError("Unexpected token in raw_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1384 = _t1387 - _t1382 = _t1384 - _t1380 = _t1382 - _t1378 = _t1380 - _t1376 = _t1378 - _t1374 = _t1376 - _t1372 = _t1374 - _t1370 = _t1372 - _t1368 = _t1370 - _t1366 = _t1368 - _t1363 = _t1366 - _t1360 = _t1363 - result698 = _t1360 - self.record_span(span_start697, "Value") - return result698 + _t1390 = _t1393 + _t1388 = _t1390 + _t1386 = _t1388 + _t1384 = _t1386 + _t1382 = _t1384 + _t1380 = _t1382 + _t1378 = _t1380 + _t1376 = _t1378 + _t1374 = _t1376 + _t1372 = _t1374 + _t1369 = _t1372 + _t1366 = _t1369 + result701 = _t1366 + self.record_span(span_start700, "Value") + return result701 def parse_raw_date(self) -> logic_pb2.DateValue: - span_start702 = self.span_start() + span_start705 = self.span_start() self.consume_literal("(") self.consume_literal("date") - int699 = self.consume_terminal("INT") - int_3700 = self.consume_terminal("INT") - int_4701 = self.consume_terminal("INT") + int702 = self.consume_terminal("INT") + int_3703 = self.consume_terminal("INT") + int_4704 = self.consume_terminal("INT") self.consume_literal(")") - _t1390 = logic_pb2.DateValue(year=int(int699), month=int(int_3700), day=int(int_4701)) - result703 = _t1390 - self.record_span(span_start702, "DateValue") - return result703 + _t1396 = logic_pb2.DateValue(year=int(int702), month=int(int_3703), day=int(int_4704)) + result706 = _t1396 + self.record_span(span_start705, "DateValue") + return result706 def parse_raw_datetime(self) -> logic_pb2.DateTimeValue: - span_start711 = self.span_start() + span_start714 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - int704 = self.consume_terminal("INT") - int_3705 = self.consume_terminal("INT") - int_4706 = self.consume_terminal("INT") - int_5707 = self.consume_terminal("INT") - int_6708 = self.consume_terminal("INT") - int_7709 = self.consume_terminal("INT") + int707 = self.consume_terminal("INT") + int_3708 = self.consume_terminal("INT") + int_4709 = self.consume_terminal("INT") + int_5710 = self.consume_terminal("INT") + int_6711 = self.consume_terminal("INT") + int_7712 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1391 = self.consume_terminal("INT") + _t1397 = self.consume_terminal("INT") else: - _t1391 = None - int_8710 = _t1391 + _t1397 = None + int_8713 = _t1397 self.consume_literal(")") - _t1392 = logic_pb2.DateTimeValue(year=int(int704), month=int(int_3705), day=int(int_4706), hour=int(int_5707), minute=int(int_6708), second=int(int_7709), microsecond=int((int_8710 if int_8710 is not None else 0))) - result712 = _t1392 - self.record_span(span_start711, "DateTimeValue") - return result712 + _t1398 = logic_pb2.DateTimeValue(year=int(int707), month=int(int_3708), day=int(int_4709), hour=int(int_5710), minute=int(int_6711), second=int(int_7712), microsecond=int((int_8713 if int_8713 is not None else 0))) + result715 = _t1398 + self.record_span(span_start714, "DateTimeValue") + return result715 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t1393 = 0 + _t1399 = 0 else: if self.match_lookahead_literal("false", 0): - _t1394 = 1 + _t1400 = 1 else: - _t1394 = -1 - _t1393 = _t1394 - prediction713 = _t1393 - if prediction713 == 1: + _t1400 = -1 + _t1399 = _t1400 + prediction716 = _t1399 + if prediction716 == 1: self.consume_literal("false") - _t1395 = False + _t1401 = False else: - if prediction713 == 0: + if prediction716 == 0: self.consume_literal("true") - _t1396 = True + _t1402 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1395 = _t1396 - return _t1395 + _t1401 = _t1402 + return _t1401 def parse_sync(self) -> transactions_pb2.Sync: - span_start718 = self.span_start() + span_start721 = self.span_start() self.consume_literal("(") self.consume_literal("sync") - xs714 = [] - cond715 = self.match_lookahead_literal(":", 0) - while cond715: - _t1397 = self.parse_fragment_id() - item716 = _t1397 - xs714.append(item716) - cond715 = self.match_lookahead_literal(":", 0) - fragment_ids717 = xs714 - self.consume_literal(")") - _t1398 = transactions_pb2.Sync(fragments=fragment_ids717) - result719 = _t1398 - self.record_span(span_start718, "Sync") - return result719 + xs717 = [] + cond718 = self.match_lookahead_literal(":", 0) + while cond718: + _t1403 = self.parse_fragment_id() + item719 = _t1403 + xs717.append(item719) + cond718 = self.match_lookahead_literal(":", 0) + fragment_ids720 = xs717 + self.consume_literal(")") + _t1404 = transactions_pb2.Sync(fragments=fragment_ids720) + result722 = _t1404 + self.record_span(span_start721, "Sync") + return result722 def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start721 = self.span_start() + span_start724 = self.span_start() self.consume_literal(":") - symbol720 = self.consume_terminal("SYMBOL") - result722 = fragments_pb2.FragmentId(id=symbol720.encode()) - self.record_span(span_start721, "FragmentId") - return result722 + symbol723 = self.consume_terminal("SYMBOL") + result725 = fragments_pb2.FragmentId(id=symbol723.encode()) + self.record_span(span_start724, "FragmentId") + return result725 def parse_epoch(self) -> transactions_pb2.Epoch: - span_start725 = self.span_start() + span_start728 = self.span_start() self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t1400 = self.parse_epoch_writes() - _t1399 = _t1400 + _t1406 = self.parse_epoch_writes() + _t1405 = _t1406 else: - _t1399 = None - epoch_writes723 = _t1399 + _t1405 = None + epoch_writes726 = _t1405 if self.match_lookahead_literal("(", 0): - _t1402 = self.parse_epoch_reads() - _t1401 = _t1402 + _t1408 = self.parse_epoch_reads() + _t1407 = _t1408 else: - _t1401 = None - epoch_reads724 = _t1401 + _t1407 = None + epoch_reads727 = _t1407 self.consume_literal(")") - _t1403 = transactions_pb2.Epoch(writes=(epoch_writes723 if epoch_writes723 is not None else []), reads=(epoch_reads724 if epoch_reads724 is not None else [])) - result726 = _t1403 - self.record_span(span_start725, "Epoch") - return result726 + _t1409 = transactions_pb2.Epoch(writes=(epoch_writes726 if epoch_writes726 is not None else []), reads=(epoch_reads727 if epoch_reads727 is not None else [])) + result729 = _t1409 + self.record_span(span_start728, "Epoch") + return result729 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") - xs727 = [] - cond728 = self.match_lookahead_literal("(", 0) - while cond728: - _t1404 = self.parse_write() - item729 = _t1404 - xs727.append(item729) - cond728 = self.match_lookahead_literal("(", 0) - writes730 = xs727 + xs730 = [] + cond731 = self.match_lookahead_literal("(", 0) + while cond731: + _t1410 = self.parse_write() + item732 = _t1410 + xs730.append(item732) + cond731 = self.match_lookahead_literal("(", 0) + writes733 = xs730 self.consume_literal(")") - return writes730 + return writes733 def parse_write(self) -> transactions_pb2.Write: - span_start736 = self.span_start() + span_start739 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t1406 = 1 + _t1412 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t1407 = 3 + _t1413 = 3 else: if self.match_lookahead_literal("define", 1): - _t1408 = 0 + _t1414 = 0 else: if self.match_lookahead_literal("context", 1): - _t1409 = 2 + _t1415 = 2 else: - _t1409 = -1 - _t1408 = _t1409 - _t1407 = _t1408 - _t1406 = _t1407 - _t1405 = _t1406 - else: - _t1405 = -1 - prediction731 = _t1405 - if prediction731 == 3: - _t1411 = self.parse_snapshot() - snapshot735 = _t1411 - _t1412 = transactions_pb2.Write(snapshot=snapshot735) - _t1410 = _t1412 - else: - if prediction731 == 2: - _t1414 = self.parse_context() - context734 = _t1414 - _t1415 = transactions_pb2.Write(context=context734) - _t1413 = _t1415 + _t1415 = -1 + _t1414 = _t1415 + _t1413 = _t1414 + _t1412 = _t1413 + _t1411 = _t1412 + else: + _t1411 = -1 + prediction734 = _t1411 + if prediction734 == 3: + _t1417 = self.parse_snapshot() + snapshot738 = _t1417 + _t1418 = transactions_pb2.Write(snapshot=snapshot738) + _t1416 = _t1418 + else: + if prediction734 == 2: + _t1420 = self.parse_context() + context737 = _t1420 + _t1421 = transactions_pb2.Write(context=context737) + _t1419 = _t1421 else: - if prediction731 == 1: - _t1417 = self.parse_undefine() - undefine733 = _t1417 - _t1418 = transactions_pb2.Write(undefine=undefine733) - _t1416 = _t1418 + if prediction734 == 1: + _t1423 = self.parse_undefine() + undefine736 = _t1423 + _t1424 = transactions_pb2.Write(undefine=undefine736) + _t1422 = _t1424 else: - if prediction731 == 0: - _t1420 = self.parse_define() - define732 = _t1420 - _t1421 = transactions_pb2.Write(define=define732) - _t1419 = _t1421 + if prediction734 == 0: + _t1426 = self.parse_define() + define735 = _t1426 + _t1427 = transactions_pb2.Write(define=define735) + _t1425 = _t1427 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1416 = _t1419 - _t1413 = _t1416 - _t1410 = _t1413 - result737 = _t1410 - self.record_span(span_start736, "Write") - return result737 + _t1422 = _t1425 + _t1419 = _t1422 + _t1416 = _t1419 + result740 = _t1416 + self.record_span(span_start739, "Write") + return result740 def parse_define(self) -> transactions_pb2.Define: - span_start739 = self.span_start() + span_start742 = self.span_start() self.consume_literal("(") self.consume_literal("define") - _t1422 = self.parse_fragment() - fragment738 = _t1422 + _t1428 = self.parse_fragment() + fragment741 = _t1428 self.consume_literal(")") - _t1423 = transactions_pb2.Define(fragment=fragment738) - result740 = _t1423 - self.record_span(span_start739, "Define") - return result740 + _t1429 = transactions_pb2.Define(fragment=fragment741) + result743 = _t1429 + self.record_span(span_start742, "Define") + return result743 def parse_fragment(self) -> fragments_pb2.Fragment: - span_start746 = self.span_start() + span_start749 = self.span_start() self.consume_literal("(") self.consume_literal("fragment") - _t1424 = self.parse_new_fragment_id() - new_fragment_id741 = _t1424 - xs742 = [] - cond743 = self.match_lookahead_literal("(", 0) - while cond743: - _t1425 = self.parse_declaration() - item744 = _t1425 - xs742.append(item744) - cond743 = self.match_lookahead_literal("(", 0) - declarations745 = xs742 - self.consume_literal(")") - result747 = self.construct_fragment(new_fragment_id741, declarations745) - self.record_span(span_start746, "Fragment") - return result747 + _t1430 = self.parse_new_fragment_id() + new_fragment_id744 = _t1430 + xs745 = [] + cond746 = self.match_lookahead_literal("(", 0) + while cond746: + _t1431 = self.parse_declaration() + item747 = _t1431 + xs745.append(item747) + cond746 = self.match_lookahead_literal("(", 0) + declarations748 = xs745 + self.consume_literal(")") + result750 = self.construct_fragment(new_fragment_id744, declarations748) + self.record_span(span_start749, "Fragment") + return result750 def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - span_start749 = self.span_start() - _t1426 = self.parse_fragment_id() - fragment_id748 = _t1426 - self.start_fragment(fragment_id748) - result750 = fragment_id748 - self.record_span(span_start749, "FragmentId") - return result750 + span_start752 = self.span_start() + _t1432 = self.parse_fragment_id() + fragment_id751 = _t1432 + self.start_fragment(fragment_id751) + result753 = fragment_id751 + self.record_span(span_start752, "FragmentId") + return result753 def parse_declaration(self) -> logic_pb2.Declaration: - span_start756 = self.span_start() + span_start759 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1428 = 3 + _t1434 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t1429 = 2 + _t1435 = 2 else: if self.match_lookahead_literal("edb", 1): - _t1430 = 3 + _t1436 = 3 else: if self.match_lookahead_literal("def", 1): - _t1431 = 0 + _t1437 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1432 = 3 + _t1438 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t1433 = 3 + _t1439 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t1434 = 1 + _t1440 = 1 else: - _t1434 = -1 - _t1433 = _t1434 - _t1432 = _t1433 - _t1431 = _t1432 - _t1430 = _t1431 - _t1429 = _t1430 - _t1428 = _t1429 - _t1427 = _t1428 - else: - _t1427 = -1 - prediction751 = _t1427 - if prediction751 == 3: - _t1436 = self.parse_data() - data755 = _t1436 - _t1437 = logic_pb2.Declaration(data=data755) - _t1435 = _t1437 - else: - if prediction751 == 2: - _t1439 = self.parse_constraint() - constraint754 = _t1439 - _t1440 = logic_pb2.Declaration(constraint=constraint754) - _t1438 = _t1440 + _t1440 = -1 + _t1439 = _t1440 + _t1438 = _t1439 + _t1437 = _t1438 + _t1436 = _t1437 + _t1435 = _t1436 + _t1434 = _t1435 + _t1433 = _t1434 + else: + _t1433 = -1 + prediction754 = _t1433 + if prediction754 == 3: + _t1442 = self.parse_data() + data758 = _t1442 + _t1443 = logic_pb2.Declaration(data=data758) + _t1441 = _t1443 + else: + if prediction754 == 2: + _t1445 = self.parse_constraint() + constraint757 = _t1445 + _t1446 = logic_pb2.Declaration(constraint=constraint757) + _t1444 = _t1446 else: - if prediction751 == 1: - _t1442 = self.parse_algorithm() - algorithm753 = _t1442 - _t1443 = logic_pb2.Declaration(algorithm=algorithm753) - _t1441 = _t1443 + if prediction754 == 1: + _t1448 = self.parse_algorithm() + algorithm756 = _t1448 + _t1449 = logic_pb2.Declaration(algorithm=algorithm756) + _t1447 = _t1449 else: - if prediction751 == 0: - _t1445 = self.parse_def() - def752 = _t1445 - _t1446 = logic_pb2.Declaration() - getattr(_t1446, 'def').CopyFrom(def752) - _t1444 = _t1446 + if prediction754 == 0: + _t1451 = self.parse_def() + def755 = _t1451 + _t1452 = logic_pb2.Declaration() + getattr(_t1452, 'def').CopyFrom(def755) + _t1450 = _t1452 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1441 = _t1444 - _t1438 = _t1441 - _t1435 = _t1438 - result757 = _t1435 - self.record_span(span_start756, "Declaration") - return result757 + _t1447 = _t1450 + _t1444 = _t1447 + _t1441 = _t1444 + result760 = _t1441 + self.record_span(span_start759, "Declaration") + return result760 def parse_def(self) -> logic_pb2.Def: - span_start761 = self.span_start() + span_start764 = self.span_start() self.consume_literal("(") self.consume_literal("def") - _t1447 = self.parse_relation_id() - relation_id758 = _t1447 - _t1448 = self.parse_abstraction() - abstraction759 = _t1448 + _t1453 = self.parse_relation_id() + relation_id761 = _t1453 + _t1454 = self.parse_abstraction() + abstraction762 = _t1454 if self.match_lookahead_literal("(", 0): - _t1450 = self.parse_attrs() - _t1449 = _t1450 + _t1456 = self.parse_attrs() + _t1455 = _t1456 else: - _t1449 = None - attrs760 = _t1449 + _t1455 = None + attrs763 = _t1455 self.consume_literal(")") - _t1451 = logic_pb2.Def(name=relation_id758, body=abstraction759, attrs=(attrs760 if attrs760 is not None else [])) - result762 = _t1451 - self.record_span(span_start761, "Def") - return result762 + _t1457 = logic_pb2.Def(name=relation_id761, body=abstraction762, attrs=(attrs763 if attrs763 is not None else [])) + result765 = _t1457 + self.record_span(span_start764, "Def") + return result765 def parse_relation_id(self) -> logic_pb2.RelationId: - span_start766 = self.span_start() + span_start769 = self.span_start() if self.match_lookahead_literal(":", 0): - _t1452 = 0 + _t1458 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1453 = 1 + _t1459 = 1 else: - _t1453 = -1 - _t1452 = _t1453 - prediction763 = _t1452 - if prediction763 == 1: - uint128765 = self.consume_terminal("UINT128") - _t1454 = logic_pb2.RelationId(id_low=uint128765.low, id_high=uint128765.high) - else: - if prediction763 == 0: + _t1459 = -1 + _t1458 = _t1459 + prediction766 = _t1458 + if prediction766 == 1: + uint128768 = self.consume_terminal("UINT128") + _t1460 = logic_pb2.RelationId(id_low=uint128768.low, id_high=uint128768.high) + else: + if prediction766 == 0: self.consume_literal(":") - symbol764 = self.consume_terminal("SYMBOL") - _t1455 = self.relation_id_from_string(symbol764) + symbol767 = self.consume_terminal("SYMBOL") + _t1461 = self.relation_id_from_string(symbol767) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1454 = _t1455 - result767 = _t1454 - self.record_span(span_start766, "RelationId") - return result767 + _t1460 = _t1461 + result770 = _t1460 + self.record_span(span_start769, "RelationId") + return result770 def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start770 = self.span_start() + span_start773 = self.span_start() self.consume_literal("(") - _t1456 = self.parse_bindings() - bindings768 = _t1456 - _t1457 = self.parse_formula() - formula769 = _t1457 + _t1462 = self.parse_bindings() + bindings771 = _t1462 + _t1463 = self.parse_formula() + formula772 = _t1463 self.consume_literal(")") - _t1458 = logic_pb2.Abstraction(vars=(list(bindings768[0]) + list(bindings768[1] if bindings768[1] is not None else [])), value=formula769) - result771 = _t1458 - self.record_span(span_start770, "Abstraction") - return result771 + _t1464 = logic_pb2.Abstraction(vars=(list(bindings771[0]) + list(bindings771[1] if bindings771[1] is not None else [])), value=formula772) + result774 = _t1464 + self.record_span(span_start773, "Abstraction") + return result774 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs772 = [] - cond773 = self.match_lookahead_terminal("SYMBOL", 0) - while cond773: - _t1459 = self.parse_binding() - item774 = _t1459 - xs772.append(item774) - cond773 = self.match_lookahead_terminal("SYMBOL", 0) - bindings775 = xs772 + xs775 = [] + cond776 = self.match_lookahead_terminal("SYMBOL", 0) + while cond776: + _t1465 = self.parse_binding() + item777 = _t1465 + xs775.append(item777) + cond776 = self.match_lookahead_terminal("SYMBOL", 0) + bindings778 = xs775 if self.match_lookahead_literal("|", 0): - _t1461 = self.parse_value_bindings() - _t1460 = _t1461 + _t1467 = self.parse_value_bindings() + _t1466 = _t1467 else: - _t1460 = None - value_bindings776 = _t1460 + _t1466 = None + value_bindings779 = _t1466 self.consume_literal("]") - return (bindings775, (value_bindings776 if value_bindings776 is not None else []),) + return (bindings778, (value_bindings779 if value_bindings779 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - span_start779 = self.span_start() - symbol777 = self.consume_terminal("SYMBOL") + span_start782 = self.span_start() + symbol780 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t1462 = self.parse_type() - type778 = _t1462 - _t1463 = logic_pb2.Var(name=symbol777) - _t1464 = logic_pb2.Binding(var=_t1463, type=type778) - result780 = _t1464 - self.record_span(span_start779, "Binding") - return result780 + _t1468 = self.parse_type() + type781 = _t1468 + _t1469 = logic_pb2.Var(name=symbol780) + _t1470 = logic_pb2.Binding(var=_t1469, type=type781) + result783 = _t1470 + self.record_span(span_start782, "Binding") + return result783 def parse_type(self) -> logic_pb2.Type: - span_start796 = self.span_start() + span_start799 = self.span_start() if self.match_lookahead_literal("UNKNOWN", 0): - _t1465 = 0 + _t1471 = 0 else: if self.match_lookahead_literal("UINT32", 0): - _t1466 = 13 + _t1472 = 13 else: if self.match_lookahead_literal("UINT128", 0): - _t1467 = 4 + _t1473 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t1468 = 1 + _t1474 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t1469 = 8 + _t1475 = 8 else: if self.match_lookahead_literal("INT32", 0): - _t1470 = 11 + _t1476 = 11 else: if self.match_lookahead_literal("INT128", 0): - _t1471 = 5 + _t1477 = 5 else: if self.match_lookahead_literal("INT", 0): - _t1472 = 2 + _t1478 = 2 else: if self.match_lookahead_literal("FLOAT32", 0): - _t1473 = 12 + _t1479 = 12 else: if self.match_lookahead_literal("FLOAT", 0): - _t1474 = 3 + _t1480 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t1475 = 7 + _t1481 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t1476 = 6 + _t1482 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t1477 = 10 + _t1483 = 10 else: if self.match_lookahead_literal("(", 0): - _t1478 = 9 + _t1484 = 9 else: - _t1478 = -1 - _t1477 = _t1478 - _t1476 = _t1477 - _t1475 = _t1476 - _t1474 = _t1475 - _t1473 = _t1474 - _t1472 = _t1473 - _t1471 = _t1472 - _t1470 = _t1471 - _t1469 = _t1470 - _t1468 = _t1469 - _t1467 = _t1468 - _t1466 = _t1467 - _t1465 = _t1466 - prediction781 = _t1465 - if prediction781 == 13: - _t1480 = self.parse_uint32_type() - uint32_type795 = _t1480 - _t1481 = logic_pb2.Type(uint32_type=uint32_type795) - _t1479 = _t1481 - else: - if prediction781 == 12: - _t1483 = self.parse_float32_type() - float32_type794 = _t1483 - _t1484 = logic_pb2.Type(float32_type=float32_type794) - _t1482 = _t1484 + _t1484 = -1 + _t1483 = _t1484 + _t1482 = _t1483 + _t1481 = _t1482 + _t1480 = _t1481 + _t1479 = _t1480 + _t1478 = _t1479 + _t1477 = _t1478 + _t1476 = _t1477 + _t1475 = _t1476 + _t1474 = _t1475 + _t1473 = _t1474 + _t1472 = _t1473 + _t1471 = _t1472 + prediction784 = _t1471 + if prediction784 == 13: + _t1486 = self.parse_uint32_type() + uint32_type798 = _t1486 + _t1487 = logic_pb2.Type(uint32_type=uint32_type798) + _t1485 = _t1487 + else: + if prediction784 == 12: + _t1489 = self.parse_float32_type() + float32_type797 = _t1489 + _t1490 = logic_pb2.Type(float32_type=float32_type797) + _t1488 = _t1490 else: - if prediction781 == 11: - _t1486 = self.parse_int32_type() - int32_type793 = _t1486 - _t1487 = logic_pb2.Type(int32_type=int32_type793) - _t1485 = _t1487 + if prediction784 == 11: + _t1492 = self.parse_int32_type() + int32_type796 = _t1492 + _t1493 = logic_pb2.Type(int32_type=int32_type796) + _t1491 = _t1493 else: - if prediction781 == 10: - _t1489 = self.parse_boolean_type() - boolean_type792 = _t1489 - _t1490 = logic_pb2.Type(boolean_type=boolean_type792) - _t1488 = _t1490 + if prediction784 == 10: + _t1495 = self.parse_boolean_type() + boolean_type795 = _t1495 + _t1496 = logic_pb2.Type(boolean_type=boolean_type795) + _t1494 = _t1496 else: - if prediction781 == 9: - _t1492 = self.parse_decimal_type() - decimal_type791 = _t1492 - _t1493 = logic_pb2.Type(decimal_type=decimal_type791) - _t1491 = _t1493 + if prediction784 == 9: + _t1498 = self.parse_decimal_type() + decimal_type794 = _t1498 + _t1499 = logic_pb2.Type(decimal_type=decimal_type794) + _t1497 = _t1499 else: - if prediction781 == 8: - _t1495 = self.parse_missing_type() - missing_type790 = _t1495 - _t1496 = logic_pb2.Type(missing_type=missing_type790) - _t1494 = _t1496 + if prediction784 == 8: + _t1501 = self.parse_missing_type() + missing_type793 = _t1501 + _t1502 = logic_pb2.Type(missing_type=missing_type793) + _t1500 = _t1502 else: - if prediction781 == 7: - _t1498 = self.parse_datetime_type() - datetime_type789 = _t1498 - _t1499 = logic_pb2.Type(datetime_type=datetime_type789) - _t1497 = _t1499 + if prediction784 == 7: + _t1504 = self.parse_datetime_type() + datetime_type792 = _t1504 + _t1505 = logic_pb2.Type(datetime_type=datetime_type792) + _t1503 = _t1505 else: - if prediction781 == 6: - _t1501 = self.parse_date_type() - date_type788 = _t1501 - _t1502 = logic_pb2.Type(date_type=date_type788) - _t1500 = _t1502 + if prediction784 == 6: + _t1507 = self.parse_date_type() + date_type791 = _t1507 + _t1508 = logic_pb2.Type(date_type=date_type791) + _t1506 = _t1508 else: - if prediction781 == 5: - _t1504 = self.parse_int128_type() - int128_type787 = _t1504 - _t1505 = logic_pb2.Type(int128_type=int128_type787) - _t1503 = _t1505 + if prediction784 == 5: + _t1510 = self.parse_int128_type() + int128_type790 = _t1510 + _t1511 = logic_pb2.Type(int128_type=int128_type790) + _t1509 = _t1511 else: - if prediction781 == 4: - _t1507 = self.parse_uint128_type() - uint128_type786 = _t1507 - _t1508 = logic_pb2.Type(uint128_type=uint128_type786) - _t1506 = _t1508 + if prediction784 == 4: + _t1513 = self.parse_uint128_type() + uint128_type789 = _t1513 + _t1514 = logic_pb2.Type(uint128_type=uint128_type789) + _t1512 = _t1514 else: - if prediction781 == 3: - _t1510 = self.parse_float_type() - float_type785 = _t1510 - _t1511 = logic_pb2.Type(float_type=float_type785) - _t1509 = _t1511 + if prediction784 == 3: + _t1516 = self.parse_float_type() + float_type788 = _t1516 + _t1517 = logic_pb2.Type(float_type=float_type788) + _t1515 = _t1517 else: - if prediction781 == 2: - _t1513 = self.parse_int_type() - int_type784 = _t1513 - _t1514 = logic_pb2.Type(int_type=int_type784) - _t1512 = _t1514 + if prediction784 == 2: + _t1519 = self.parse_int_type() + int_type787 = _t1519 + _t1520 = logic_pb2.Type(int_type=int_type787) + _t1518 = _t1520 else: - if prediction781 == 1: - _t1516 = self.parse_string_type() - string_type783 = _t1516 - _t1517 = logic_pb2.Type(string_type=string_type783) - _t1515 = _t1517 + if prediction784 == 1: + _t1522 = self.parse_string_type() + string_type786 = _t1522 + _t1523 = logic_pb2.Type(string_type=string_type786) + _t1521 = _t1523 else: - if prediction781 == 0: - _t1519 = self.parse_unspecified_type() - unspecified_type782 = _t1519 - _t1520 = logic_pb2.Type(unspecified_type=unspecified_type782) - _t1518 = _t1520 + if prediction784 == 0: + _t1525 = self.parse_unspecified_type() + unspecified_type785 = _t1525 + _t1526 = logic_pb2.Type(unspecified_type=unspecified_type785) + _t1524 = _t1526 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1515 = _t1518 - _t1512 = _t1515 - _t1509 = _t1512 - _t1506 = _t1509 - _t1503 = _t1506 - _t1500 = _t1503 - _t1497 = _t1500 - _t1494 = _t1497 - _t1491 = _t1494 - _t1488 = _t1491 - _t1485 = _t1488 - _t1482 = _t1485 - _t1479 = _t1482 - result797 = _t1479 - self.record_span(span_start796, "Type") - return result797 + _t1521 = _t1524 + _t1518 = _t1521 + _t1515 = _t1518 + _t1512 = _t1515 + _t1509 = _t1512 + _t1506 = _t1509 + _t1503 = _t1506 + _t1500 = _t1503 + _t1497 = _t1500 + _t1494 = _t1497 + _t1491 = _t1494 + _t1488 = _t1491 + _t1485 = _t1488 + result800 = _t1485 + self.record_span(span_start799, "Type") + return result800 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: - span_start798 = self.span_start() + span_start801 = self.span_start() self.consume_literal("UNKNOWN") - _t1521 = logic_pb2.UnspecifiedType() - result799 = _t1521 - self.record_span(span_start798, "UnspecifiedType") - return result799 + _t1527 = logic_pb2.UnspecifiedType() + result802 = _t1527 + self.record_span(span_start801, "UnspecifiedType") + return result802 def parse_string_type(self) -> logic_pb2.StringType: - span_start800 = self.span_start() + span_start803 = self.span_start() self.consume_literal("STRING") - _t1522 = logic_pb2.StringType() - result801 = _t1522 - self.record_span(span_start800, "StringType") - return result801 + _t1528 = logic_pb2.StringType() + result804 = _t1528 + self.record_span(span_start803, "StringType") + return result804 def parse_int_type(self) -> logic_pb2.IntType: - span_start802 = self.span_start() + span_start805 = self.span_start() self.consume_literal("INT") - _t1523 = logic_pb2.IntType() - result803 = _t1523 - self.record_span(span_start802, "IntType") - return result803 + _t1529 = logic_pb2.IntType() + result806 = _t1529 + self.record_span(span_start805, "IntType") + return result806 def parse_float_type(self) -> logic_pb2.FloatType: - span_start804 = self.span_start() + span_start807 = self.span_start() self.consume_literal("FLOAT") - _t1524 = logic_pb2.FloatType() - result805 = _t1524 - self.record_span(span_start804, "FloatType") - return result805 + _t1530 = logic_pb2.FloatType() + result808 = _t1530 + self.record_span(span_start807, "FloatType") + return result808 def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start806 = self.span_start() + span_start809 = self.span_start() self.consume_literal("UINT128") - _t1525 = logic_pb2.UInt128Type() - result807 = _t1525 - self.record_span(span_start806, "UInt128Type") - return result807 + _t1531 = logic_pb2.UInt128Type() + result810 = _t1531 + self.record_span(span_start809, "UInt128Type") + return result810 def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start808 = self.span_start() + span_start811 = self.span_start() self.consume_literal("INT128") - _t1526 = logic_pb2.Int128Type() - result809 = _t1526 - self.record_span(span_start808, "Int128Type") - return result809 + _t1532 = logic_pb2.Int128Type() + result812 = _t1532 + self.record_span(span_start811, "Int128Type") + return result812 def parse_date_type(self) -> logic_pb2.DateType: - span_start810 = self.span_start() + span_start813 = self.span_start() self.consume_literal("DATE") - _t1527 = logic_pb2.DateType() - result811 = _t1527 - self.record_span(span_start810, "DateType") - return result811 + _t1533 = logic_pb2.DateType() + result814 = _t1533 + self.record_span(span_start813, "DateType") + return result814 def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start812 = self.span_start() + span_start815 = self.span_start() self.consume_literal("DATETIME") - _t1528 = logic_pb2.DateTimeType() - result813 = _t1528 - self.record_span(span_start812, "DateTimeType") - return result813 + _t1534 = logic_pb2.DateTimeType() + result816 = _t1534 + self.record_span(span_start815, "DateTimeType") + return result816 def parse_missing_type(self) -> logic_pb2.MissingType: - span_start814 = self.span_start() + span_start817 = self.span_start() self.consume_literal("MISSING") - _t1529 = logic_pb2.MissingType() - result815 = _t1529 - self.record_span(span_start814, "MissingType") - return result815 + _t1535 = logic_pb2.MissingType() + result818 = _t1535 + self.record_span(span_start817, "MissingType") + return result818 def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start818 = self.span_start() + span_start821 = self.span_start() self.consume_literal("(") self.consume_literal("DECIMAL") - int816 = self.consume_terminal("INT") - int_3817 = self.consume_terminal("INT") + int819 = self.consume_terminal("INT") + int_3820 = self.consume_terminal("INT") self.consume_literal(")") - _t1530 = logic_pb2.DecimalType(precision=int(int816), scale=int(int_3817)) - result819 = _t1530 - self.record_span(span_start818, "DecimalType") - return result819 + _t1536 = logic_pb2.DecimalType(precision=int(int819), scale=int(int_3820)) + result822 = _t1536 + self.record_span(span_start821, "DecimalType") + return result822 def parse_boolean_type(self) -> logic_pb2.BooleanType: - span_start820 = self.span_start() + span_start823 = self.span_start() self.consume_literal("BOOLEAN") - _t1531 = logic_pb2.BooleanType() - result821 = _t1531 - self.record_span(span_start820, "BooleanType") - return result821 + _t1537 = logic_pb2.BooleanType() + result824 = _t1537 + self.record_span(span_start823, "BooleanType") + return result824 def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start822 = self.span_start() + span_start825 = self.span_start() self.consume_literal("INT32") - _t1532 = logic_pb2.Int32Type() - result823 = _t1532 - self.record_span(span_start822, "Int32Type") - return result823 + _t1538 = logic_pb2.Int32Type() + result826 = _t1538 + self.record_span(span_start825, "Int32Type") + return result826 def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start824 = self.span_start() + span_start827 = self.span_start() self.consume_literal("FLOAT32") - _t1533 = logic_pb2.Float32Type() - result825 = _t1533 - self.record_span(span_start824, "Float32Type") - return result825 + _t1539 = logic_pb2.Float32Type() + result828 = _t1539 + self.record_span(span_start827, "Float32Type") + return result828 def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start826 = self.span_start() + span_start829 = self.span_start() self.consume_literal("UINT32") - _t1534 = logic_pb2.UInt32Type() - result827 = _t1534 - self.record_span(span_start826, "UInt32Type") - return result827 + _t1540 = logic_pb2.UInt32Type() + result830 = _t1540 + self.record_span(span_start829, "UInt32Type") + return result830 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs828 = [] - cond829 = self.match_lookahead_terminal("SYMBOL", 0) - while cond829: - _t1535 = self.parse_binding() - item830 = _t1535 - xs828.append(item830) - cond829 = self.match_lookahead_terminal("SYMBOL", 0) - bindings831 = xs828 - return bindings831 + xs831 = [] + cond832 = self.match_lookahead_terminal("SYMBOL", 0) + while cond832: + _t1541 = self.parse_binding() + item833 = _t1541 + xs831.append(item833) + cond832 = self.match_lookahead_terminal("SYMBOL", 0) + bindings834 = xs831 + return bindings834 def parse_formula(self) -> logic_pb2.Formula: - span_start846 = self.span_start() + span_start849 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t1537 = 0 + _t1543 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t1538 = 11 + _t1544 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t1539 = 3 + _t1545 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t1540 = 10 + _t1546 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t1541 = 9 + _t1547 = 9 else: if self.match_lookahead_literal("or", 1): - _t1542 = 5 + _t1548 = 5 else: if self.match_lookahead_literal("not", 1): - _t1543 = 6 + _t1549 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t1544 = 7 + _t1550 = 7 else: if self.match_lookahead_literal("false", 1): - _t1545 = 1 + _t1551 = 1 else: if self.match_lookahead_literal("exists", 1): - _t1546 = 2 + _t1552 = 2 else: if self.match_lookahead_literal("cast", 1): - _t1547 = 12 + _t1553 = 12 else: if self.match_lookahead_literal("atom", 1): - _t1548 = 8 + _t1554 = 8 else: if self.match_lookahead_literal("and", 1): - _t1549 = 4 + _t1555 = 4 else: if self.match_lookahead_literal(">=", 1): - _t1550 = 10 + _t1556 = 10 else: if self.match_lookahead_literal(">", 1): - _t1551 = 10 + _t1557 = 10 else: if self.match_lookahead_literal("=", 1): - _t1552 = 10 + _t1558 = 10 else: if self.match_lookahead_literal("<=", 1): - _t1553 = 10 + _t1559 = 10 else: if self.match_lookahead_literal("<", 1): - _t1554 = 10 + _t1560 = 10 else: if self.match_lookahead_literal("/", 1): - _t1555 = 10 + _t1561 = 10 else: if self.match_lookahead_literal("-", 1): - _t1556 = 10 + _t1562 = 10 else: if self.match_lookahead_literal("+", 1): - _t1557 = 10 + _t1563 = 10 else: if self.match_lookahead_literal("*", 1): - _t1558 = 10 + _t1564 = 10 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 - _t1544 = _t1545 - _t1543 = _t1544 - _t1542 = _t1543 - _t1541 = _t1542 - _t1540 = _t1541 - _t1539 = _t1540 - _t1538 = _t1539 - _t1537 = _t1538 - _t1536 = _t1537 - else: - _t1536 = -1 - prediction832 = _t1536 - if prediction832 == 12: - _t1560 = self.parse_cast() - cast845 = _t1560 - _t1561 = logic_pb2.Formula(cast=cast845) - _t1559 = _t1561 - else: - if prediction832 == 11: - _t1563 = self.parse_rel_atom() - rel_atom844 = _t1563 - _t1564 = logic_pb2.Formula(rel_atom=rel_atom844) - _t1562 = _t1564 + _t1564 = -1 + _t1563 = _t1564 + _t1562 = _t1563 + _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 + _t1548 = _t1549 + _t1547 = _t1548 + _t1546 = _t1547 + _t1545 = _t1546 + _t1544 = _t1545 + _t1543 = _t1544 + _t1542 = _t1543 + else: + _t1542 = -1 + prediction835 = _t1542 + if prediction835 == 12: + _t1566 = self.parse_cast() + cast848 = _t1566 + _t1567 = logic_pb2.Formula(cast=cast848) + _t1565 = _t1567 + else: + if prediction835 == 11: + _t1569 = self.parse_rel_atom() + rel_atom847 = _t1569 + _t1570 = logic_pb2.Formula(rel_atom=rel_atom847) + _t1568 = _t1570 else: - if prediction832 == 10: - _t1566 = self.parse_primitive() - primitive843 = _t1566 - _t1567 = logic_pb2.Formula(primitive=primitive843) - _t1565 = _t1567 + if prediction835 == 10: + _t1572 = self.parse_primitive() + primitive846 = _t1572 + _t1573 = logic_pb2.Formula(primitive=primitive846) + _t1571 = _t1573 else: - if prediction832 == 9: - _t1569 = self.parse_pragma() - pragma842 = _t1569 - _t1570 = logic_pb2.Formula(pragma=pragma842) - _t1568 = _t1570 + if prediction835 == 9: + _t1575 = self.parse_pragma() + pragma845 = _t1575 + _t1576 = logic_pb2.Formula(pragma=pragma845) + _t1574 = _t1576 else: - if prediction832 == 8: - _t1572 = self.parse_atom() - atom841 = _t1572 - _t1573 = logic_pb2.Formula(atom=atom841) - _t1571 = _t1573 + if prediction835 == 8: + _t1578 = self.parse_atom() + atom844 = _t1578 + _t1579 = logic_pb2.Formula(atom=atom844) + _t1577 = _t1579 else: - if prediction832 == 7: - _t1575 = self.parse_ffi() - ffi840 = _t1575 - _t1576 = logic_pb2.Formula(ffi=ffi840) - _t1574 = _t1576 + if prediction835 == 7: + _t1581 = self.parse_ffi() + ffi843 = _t1581 + _t1582 = logic_pb2.Formula(ffi=ffi843) + _t1580 = _t1582 else: - if prediction832 == 6: - _t1578 = self.parse_not() - not839 = _t1578 - _t1579 = logic_pb2.Formula() - getattr(_t1579, 'not').CopyFrom(not839) - _t1577 = _t1579 + if prediction835 == 6: + _t1584 = self.parse_not() + not842 = _t1584 + _t1585 = logic_pb2.Formula() + getattr(_t1585, 'not').CopyFrom(not842) + _t1583 = _t1585 else: - if prediction832 == 5: - _t1581 = self.parse_disjunction() - disjunction838 = _t1581 - _t1582 = logic_pb2.Formula(disjunction=disjunction838) - _t1580 = _t1582 + if prediction835 == 5: + _t1587 = self.parse_disjunction() + disjunction841 = _t1587 + _t1588 = logic_pb2.Formula(disjunction=disjunction841) + _t1586 = _t1588 else: - if prediction832 == 4: - _t1584 = self.parse_conjunction() - conjunction837 = _t1584 - _t1585 = logic_pb2.Formula(conjunction=conjunction837) - _t1583 = _t1585 + if prediction835 == 4: + _t1590 = self.parse_conjunction() + conjunction840 = _t1590 + _t1591 = logic_pb2.Formula(conjunction=conjunction840) + _t1589 = _t1591 else: - if prediction832 == 3: - _t1587 = self.parse_reduce() - reduce836 = _t1587 - _t1588 = logic_pb2.Formula(reduce=reduce836) - _t1586 = _t1588 + if prediction835 == 3: + _t1593 = self.parse_reduce() + reduce839 = _t1593 + _t1594 = logic_pb2.Formula(reduce=reduce839) + _t1592 = _t1594 else: - if prediction832 == 2: - _t1590 = self.parse_exists() - exists835 = _t1590 - _t1591 = logic_pb2.Formula(exists=exists835) - _t1589 = _t1591 + if prediction835 == 2: + _t1596 = self.parse_exists() + exists838 = _t1596 + _t1597 = logic_pb2.Formula(exists=exists838) + _t1595 = _t1597 else: - if prediction832 == 1: - _t1593 = self.parse_false() - false834 = _t1593 - _t1594 = logic_pb2.Formula(disjunction=false834) - _t1592 = _t1594 + if prediction835 == 1: + _t1599 = self.parse_false() + false837 = _t1599 + _t1600 = logic_pb2.Formula(disjunction=false837) + _t1598 = _t1600 else: - if prediction832 == 0: - _t1596 = self.parse_true() - true833 = _t1596 - _t1597 = logic_pb2.Formula(conjunction=true833) - _t1595 = _t1597 + if prediction835 == 0: + _t1602 = self.parse_true() + true836 = _t1602 + _t1603 = logic_pb2.Formula(conjunction=true836) + _t1601 = _t1603 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1592 = _t1595 - _t1589 = _t1592 - _t1586 = _t1589 - _t1583 = _t1586 - _t1580 = _t1583 - _t1577 = _t1580 - _t1574 = _t1577 - _t1571 = _t1574 - _t1568 = _t1571 - _t1565 = _t1568 - _t1562 = _t1565 - _t1559 = _t1562 - result847 = _t1559 - self.record_span(span_start846, "Formula") - return result847 + _t1598 = _t1601 + _t1595 = _t1598 + _t1592 = _t1595 + _t1589 = _t1592 + _t1586 = _t1589 + _t1583 = _t1586 + _t1580 = _t1583 + _t1577 = _t1580 + _t1574 = _t1577 + _t1571 = _t1574 + _t1568 = _t1571 + _t1565 = _t1568 + result850 = _t1565 + self.record_span(span_start849, "Formula") + return result850 def parse_true(self) -> logic_pb2.Conjunction: - span_start848 = self.span_start() + span_start851 = self.span_start() self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t1598 = logic_pb2.Conjunction(args=[]) - result849 = _t1598 - self.record_span(span_start848, "Conjunction") - return result849 + _t1604 = logic_pb2.Conjunction(args=[]) + result852 = _t1604 + self.record_span(span_start851, "Conjunction") + return result852 def parse_false(self) -> logic_pb2.Disjunction: - span_start850 = self.span_start() + span_start853 = self.span_start() self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t1599 = logic_pb2.Disjunction(args=[]) - result851 = _t1599 - self.record_span(span_start850, "Disjunction") - return result851 + _t1605 = logic_pb2.Disjunction(args=[]) + result854 = _t1605 + self.record_span(span_start853, "Disjunction") + return result854 def parse_exists(self) -> logic_pb2.Exists: - span_start854 = self.span_start() + span_start857 = self.span_start() self.consume_literal("(") self.consume_literal("exists") - _t1600 = self.parse_bindings() - bindings852 = _t1600 - _t1601 = self.parse_formula() - formula853 = _t1601 + _t1606 = self.parse_bindings() + bindings855 = _t1606 + _t1607 = self.parse_formula() + formula856 = _t1607 self.consume_literal(")") - _t1602 = logic_pb2.Abstraction(vars=(list(bindings852[0]) + list(bindings852[1] if bindings852[1] is not None else [])), value=formula853) - _t1603 = logic_pb2.Exists(body=_t1602) - result855 = _t1603 - self.record_span(span_start854, "Exists") - return result855 + _t1608 = logic_pb2.Abstraction(vars=(list(bindings855[0]) + list(bindings855[1] if bindings855[1] is not None else [])), value=formula856) + _t1609 = logic_pb2.Exists(body=_t1608) + result858 = _t1609 + self.record_span(span_start857, "Exists") + return result858 def parse_reduce(self) -> logic_pb2.Reduce: - span_start859 = self.span_start() + span_start862 = self.span_start() self.consume_literal("(") self.consume_literal("reduce") - _t1604 = self.parse_abstraction() - abstraction856 = _t1604 - _t1605 = self.parse_abstraction() - abstraction_3857 = _t1605 - _t1606 = self.parse_terms() - terms858 = _t1606 - self.consume_literal(")") - _t1607 = logic_pb2.Reduce(op=abstraction856, body=abstraction_3857, terms=terms858) - result860 = _t1607 - self.record_span(span_start859, "Reduce") - return result860 + _t1610 = self.parse_abstraction() + abstraction859 = _t1610 + _t1611 = self.parse_abstraction() + abstraction_3860 = _t1611 + _t1612 = self.parse_terms() + terms861 = _t1612 + self.consume_literal(")") + _t1613 = logic_pb2.Reduce(op=abstraction859, body=abstraction_3860, terms=terms861) + result863 = _t1613 + self.record_span(span_start862, "Reduce") + return result863 def parse_terms(self) -> Sequence[logic_pb2.Term]: self.consume_literal("(") self.consume_literal("terms") - xs861 = [] - cond862 = (((((((((((((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 cond862: - _t1608 = self.parse_term() - item863 = _t1608 - xs861.append(item863) - cond862 = (((((((((((((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)) - terms864 = xs861 + xs864 = [] + cond865 = (((((((((((((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 cond865: + _t1614 = self.parse_term() + item866 = _t1614 + xs864.append(item866) + cond865 = (((((((((((((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)) + terms867 = xs864 self.consume_literal(")") - return terms864 + return terms867 def parse_term(self) -> logic_pb2.Term: - span_start868 = self.span_start() + span_start871 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1609 = 1 + _t1615 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1610 = 1 + _t1616 = 1 else: if self.match_lookahead_literal("false", 0): - _t1611 = 1 + _t1617 = 1 else: if self.match_lookahead_literal("(", 0): - _t1612 = 1 + _t1618 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1613 = 0 + _t1619 = 0 else: if self.match_lookahead_terminal("UINT32", 0): - _t1614 = 1 + _t1620 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1615 = 1 + _t1621 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1616 = 1 + _t1622 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1617 = 1 + _t1623 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1618 = 1 + _t1624 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1619 = 1 + _t1625 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1620 = 1 + _t1626 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1621 = 1 + _t1627 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1622 = 1 + _t1628 = 1 else: - _t1622 = -1 - _t1621 = _t1622 - _t1620 = _t1621 - _t1619 = _t1620 - _t1618 = _t1619 - _t1617 = _t1618 - _t1616 = _t1617 - _t1615 = _t1616 - _t1614 = _t1615 - _t1613 = _t1614 - _t1612 = _t1613 - _t1611 = _t1612 - _t1610 = _t1611 - _t1609 = _t1610 - prediction865 = _t1609 - if prediction865 == 1: - _t1624 = self.parse_value() - value867 = _t1624 - _t1625 = logic_pb2.Term(constant=value867) - _t1623 = _t1625 - else: - if prediction865 == 0: - _t1627 = self.parse_var() - var866 = _t1627 - _t1628 = logic_pb2.Term(var=var866) - _t1626 = _t1628 + _t1628 = -1 + _t1627 = _t1628 + _t1626 = _t1627 + _t1625 = _t1626 + _t1624 = _t1625 + _t1623 = _t1624 + _t1622 = _t1623 + _t1621 = _t1622 + _t1620 = _t1621 + _t1619 = _t1620 + _t1618 = _t1619 + _t1617 = _t1618 + _t1616 = _t1617 + _t1615 = _t1616 + prediction868 = _t1615 + if prediction868 == 1: + _t1630 = self.parse_value() + value870 = _t1630 + _t1631 = logic_pb2.Term(constant=value870) + _t1629 = _t1631 + else: + if prediction868 == 0: + _t1633 = self.parse_var() + var869 = _t1633 + _t1634 = logic_pb2.Term(var=var869) + _t1632 = _t1634 else: raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1623 = _t1626 - result869 = _t1623 - self.record_span(span_start868, "Term") - return result869 - - def parse_var(self) -> logic_pb2.Var: - span_start871 = self.span_start() - symbol870 = self.consume_terminal("SYMBOL") - _t1629 = logic_pb2.Var(name=symbol870) + _t1629 = _t1632 result872 = _t1629 - self.record_span(span_start871, "Var") + self.record_span(span_start871, "Term") return result872 + def parse_var(self) -> logic_pb2.Var: + span_start874 = self.span_start() + symbol873 = self.consume_terminal("SYMBOL") + _t1635 = logic_pb2.Var(name=symbol873) + result875 = _t1635 + self.record_span(span_start874, "Var") + return result875 + def parse_value(self) -> logic_pb2.Value: - span_start886 = self.span_start() + span_start889 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1630 = 12 + _t1636 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1631 = 11 + _t1637 = 11 else: if self.match_lookahead_literal("false", 0): - _t1632 = 12 + _t1638 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1634 = 1 + _t1640 = 1 else: if self.match_lookahead_literal("date", 1): - _t1635 = 0 + _t1641 = 0 else: - _t1635 = -1 - _t1634 = _t1635 - _t1633 = _t1634 + _t1641 = -1 + _t1640 = _t1641 + _t1639 = _t1640 else: if self.match_lookahead_terminal("UINT32", 0): - _t1636 = 7 + _t1642 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1637 = 8 + _t1643 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1638 = 2 + _t1644 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1639 = 3 + _t1645 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1640 = 9 + _t1646 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1641 = 4 + _t1647 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1642 = 5 + _t1648 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1643 = 6 + _t1649 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1644 = 10 + _t1650 = 10 else: - _t1644 = -1 - _t1643 = _t1644 - _t1642 = _t1643 - _t1641 = _t1642 - _t1640 = _t1641 - _t1639 = _t1640 - _t1638 = _t1639 - _t1637 = _t1638 - _t1636 = _t1637 - _t1633 = _t1636 - _t1632 = _t1633 - _t1631 = _t1632 - _t1630 = _t1631 - prediction873 = _t1630 - if prediction873 == 12: - _t1646 = self.parse_boolean_value() - boolean_value885 = _t1646 - _t1647 = logic_pb2.Value(boolean_value=boolean_value885) - _t1645 = _t1647 - else: - if prediction873 == 11: + _t1650 = -1 + _t1649 = _t1650 + _t1648 = _t1649 + _t1647 = _t1648 + _t1646 = _t1647 + _t1645 = _t1646 + _t1644 = _t1645 + _t1643 = _t1644 + _t1642 = _t1643 + _t1639 = _t1642 + _t1638 = _t1639 + _t1637 = _t1638 + _t1636 = _t1637 + prediction876 = _t1636 + if prediction876 == 12: + _t1652 = self.parse_boolean_value() + boolean_value888 = _t1652 + _t1653 = logic_pb2.Value(boolean_value=boolean_value888) + _t1651 = _t1653 + else: + if prediction876 == 11: self.consume_literal("missing") - _t1649 = logic_pb2.MissingValue() - _t1650 = logic_pb2.Value(missing_value=_t1649) - _t1648 = _t1650 + _t1655 = logic_pb2.MissingValue() + _t1656 = logic_pb2.Value(missing_value=_t1655) + _t1654 = _t1656 else: - if prediction873 == 10: - formatted_decimal884 = self.consume_terminal("DECIMAL") - _t1652 = logic_pb2.Value(decimal_value=formatted_decimal884) - _t1651 = _t1652 + if prediction876 == 10: + formatted_decimal887 = self.consume_terminal("DECIMAL") + _t1658 = logic_pb2.Value(decimal_value=formatted_decimal887) + _t1657 = _t1658 else: - if prediction873 == 9: - formatted_int128883 = self.consume_terminal("INT128") - _t1654 = logic_pb2.Value(int128_value=formatted_int128883) - _t1653 = _t1654 + if prediction876 == 9: + formatted_int128886 = self.consume_terminal("INT128") + _t1660 = logic_pb2.Value(int128_value=formatted_int128886) + _t1659 = _t1660 else: - if prediction873 == 8: - formatted_uint128882 = self.consume_terminal("UINT128") - _t1656 = logic_pb2.Value(uint128_value=formatted_uint128882) - _t1655 = _t1656 + if prediction876 == 8: + formatted_uint128885 = self.consume_terminal("UINT128") + _t1662 = logic_pb2.Value(uint128_value=formatted_uint128885) + _t1661 = _t1662 else: - if prediction873 == 7: - formatted_uint32881 = self.consume_terminal("UINT32") - _t1658 = logic_pb2.Value(uint32_value=formatted_uint32881) - _t1657 = _t1658 + if prediction876 == 7: + formatted_uint32884 = self.consume_terminal("UINT32") + _t1664 = logic_pb2.Value(uint32_value=formatted_uint32884) + _t1663 = _t1664 else: - if prediction873 == 6: - formatted_float880 = self.consume_terminal("FLOAT") - _t1660 = logic_pb2.Value(float_value=formatted_float880) - _t1659 = _t1660 + if prediction876 == 6: + formatted_float883 = self.consume_terminal("FLOAT") + _t1666 = logic_pb2.Value(float_value=formatted_float883) + _t1665 = _t1666 else: - if prediction873 == 5: - formatted_float32879 = self.consume_terminal("FLOAT32") - _t1662 = logic_pb2.Value(float32_value=formatted_float32879) - _t1661 = _t1662 + if prediction876 == 5: + formatted_float32882 = self.consume_terminal("FLOAT32") + _t1668 = logic_pb2.Value(float32_value=formatted_float32882) + _t1667 = _t1668 else: - if prediction873 == 4: - formatted_int878 = self.consume_terminal("INT") - _t1664 = logic_pb2.Value(int_value=formatted_int878) - _t1663 = _t1664 + if prediction876 == 4: + formatted_int881 = self.consume_terminal("INT") + _t1670 = logic_pb2.Value(int_value=formatted_int881) + _t1669 = _t1670 else: - if prediction873 == 3: - formatted_int32877 = self.consume_terminal("INT32") - _t1666 = logic_pb2.Value(int32_value=formatted_int32877) - _t1665 = _t1666 + if prediction876 == 3: + formatted_int32880 = self.consume_terminal("INT32") + _t1672 = logic_pb2.Value(int32_value=formatted_int32880) + _t1671 = _t1672 else: - if prediction873 == 2: - formatted_string876 = self.consume_terminal("STRING") - _t1668 = logic_pb2.Value(string_value=formatted_string876) - _t1667 = _t1668 + if prediction876 == 2: + formatted_string879 = self.consume_terminal("STRING") + _t1674 = logic_pb2.Value(string_value=formatted_string879) + _t1673 = _t1674 else: - if prediction873 == 1: - _t1670 = self.parse_datetime() - datetime875 = _t1670 - _t1671 = logic_pb2.Value(datetime_value=datetime875) - _t1669 = _t1671 + if prediction876 == 1: + _t1676 = self.parse_datetime() + datetime878 = _t1676 + _t1677 = logic_pb2.Value(datetime_value=datetime878) + _t1675 = _t1677 else: - if prediction873 == 0: - _t1673 = self.parse_date() - date874 = _t1673 - _t1674 = logic_pb2.Value(date_value=date874) - _t1672 = _t1674 + if prediction876 == 0: + _t1679 = self.parse_date() + date877 = _t1679 + _t1680 = logic_pb2.Value(date_value=date877) + _t1678 = _t1680 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1669 = _t1672 - _t1667 = _t1669 - _t1665 = _t1667 - _t1663 = _t1665 - _t1661 = _t1663 - _t1659 = _t1661 - _t1657 = _t1659 - _t1655 = _t1657 - _t1653 = _t1655 - _t1651 = _t1653 - _t1648 = _t1651 - _t1645 = _t1648 - result887 = _t1645 - self.record_span(span_start886, "Value") - return result887 + _t1675 = _t1678 + _t1673 = _t1675 + _t1671 = _t1673 + _t1669 = _t1671 + _t1667 = _t1669 + _t1665 = _t1667 + _t1663 = _t1665 + _t1661 = _t1663 + _t1659 = _t1661 + _t1657 = _t1659 + _t1654 = _t1657 + _t1651 = _t1654 + result890 = _t1651 + self.record_span(span_start889, "Value") + return result890 def parse_date(self) -> logic_pb2.DateValue: - span_start891 = self.span_start() + span_start894 = self.span_start() self.consume_literal("(") self.consume_literal("date") - formatted_int888 = self.consume_terminal("INT") - formatted_int_3889 = self.consume_terminal("INT") - formatted_int_4890 = self.consume_terminal("INT") + formatted_int891 = self.consume_terminal("INT") + formatted_int_3892 = self.consume_terminal("INT") + formatted_int_4893 = self.consume_terminal("INT") self.consume_literal(")") - _t1675 = logic_pb2.DateValue(year=int(formatted_int888), month=int(formatted_int_3889), day=int(formatted_int_4890)) - result892 = _t1675 - self.record_span(span_start891, "DateValue") - return result892 + _t1681 = logic_pb2.DateValue(year=int(formatted_int891), month=int(formatted_int_3892), day=int(formatted_int_4893)) + result895 = _t1681 + self.record_span(span_start894, "DateValue") + return result895 def parse_datetime(self) -> logic_pb2.DateTimeValue: - span_start900 = self.span_start() + span_start903 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - formatted_int893 = self.consume_terminal("INT") - formatted_int_3894 = self.consume_terminal("INT") - formatted_int_4895 = self.consume_terminal("INT") - formatted_int_5896 = self.consume_terminal("INT") - formatted_int_6897 = self.consume_terminal("INT") - formatted_int_7898 = self.consume_terminal("INT") + formatted_int896 = self.consume_terminal("INT") + formatted_int_3897 = self.consume_terminal("INT") + formatted_int_4898 = self.consume_terminal("INT") + formatted_int_5899 = self.consume_terminal("INT") + formatted_int_6900 = self.consume_terminal("INT") + formatted_int_7901 = self.consume_terminal("INT") if self.match_lookahead_terminal("INT", 0): - _t1676 = self.consume_terminal("INT") + _t1682 = self.consume_terminal("INT") else: - _t1676 = None - formatted_int_8899 = _t1676 + _t1682 = None + formatted_int_8902 = _t1682 self.consume_literal(")") - _t1677 = logic_pb2.DateTimeValue(year=int(formatted_int893), month=int(formatted_int_3894), day=int(formatted_int_4895), hour=int(formatted_int_5896), minute=int(formatted_int_6897), second=int(formatted_int_7898), microsecond=int((formatted_int_8899 if formatted_int_8899 is not None else 0))) - result901 = _t1677 - self.record_span(span_start900, "DateTimeValue") - return result901 + _t1683 = logic_pb2.DateTimeValue(year=int(formatted_int896), month=int(formatted_int_3897), day=int(formatted_int_4898), hour=int(formatted_int_5899), minute=int(formatted_int_6900), second=int(formatted_int_7901), microsecond=int((formatted_int_8902 if formatted_int_8902 is not None else 0))) + result904 = _t1683 + self.record_span(span_start903, "DateTimeValue") + return result904 def parse_conjunction(self) -> logic_pb2.Conjunction: - span_start906 = self.span_start() + span_start909 = self.span_start() self.consume_literal("(") self.consume_literal("and") - xs902 = [] - cond903 = self.match_lookahead_literal("(", 0) - while cond903: - _t1678 = self.parse_formula() - item904 = _t1678 - xs902.append(item904) - cond903 = self.match_lookahead_literal("(", 0) - formulas905 = xs902 - self.consume_literal(")") - _t1679 = logic_pb2.Conjunction(args=formulas905) - result907 = _t1679 - self.record_span(span_start906, "Conjunction") - return result907 + xs905 = [] + cond906 = self.match_lookahead_literal("(", 0) + while cond906: + _t1684 = self.parse_formula() + item907 = _t1684 + xs905.append(item907) + cond906 = self.match_lookahead_literal("(", 0) + formulas908 = xs905 + self.consume_literal(")") + _t1685 = logic_pb2.Conjunction(args=formulas908) + result910 = _t1685 + self.record_span(span_start909, "Conjunction") + return result910 def parse_disjunction(self) -> logic_pb2.Disjunction: - span_start912 = self.span_start() + span_start915 = self.span_start() self.consume_literal("(") self.consume_literal("or") - xs908 = [] - cond909 = self.match_lookahead_literal("(", 0) - while cond909: - _t1680 = self.parse_formula() - item910 = _t1680 - xs908.append(item910) - cond909 = self.match_lookahead_literal("(", 0) - formulas911 = xs908 - self.consume_literal(")") - _t1681 = logic_pb2.Disjunction(args=formulas911) - result913 = _t1681 - self.record_span(span_start912, "Disjunction") - return result913 + xs911 = [] + cond912 = self.match_lookahead_literal("(", 0) + while cond912: + _t1686 = self.parse_formula() + item913 = _t1686 + xs911.append(item913) + cond912 = self.match_lookahead_literal("(", 0) + formulas914 = xs911 + self.consume_literal(")") + _t1687 = logic_pb2.Disjunction(args=formulas914) + result916 = _t1687 + self.record_span(span_start915, "Disjunction") + return result916 def parse_not(self) -> logic_pb2.Not: - span_start915 = self.span_start() + span_start918 = self.span_start() self.consume_literal("(") self.consume_literal("not") - _t1682 = self.parse_formula() - formula914 = _t1682 + _t1688 = self.parse_formula() + formula917 = _t1688 self.consume_literal(")") - _t1683 = logic_pb2.Not(arg=formula914) - result916 = _t1683 - self.record_span(span_start915, "Not") - return result916 + _t1689 = logic_pb2.Not(arg=formula917) + result919 = _t1689 + self.record_span(span_start918, "Not") + return result919 def parse_ffi(self) -> logic_pb2.FFI: - span_start920 = self.span_start() + span_start923 = self.span_start() self.consume_literal("(") self.consume_literal("ffi") - _t1684 = self.parse_name() - name917 = _t1684 - _t1685 = self.parse_ffi_args() - ffi_args918 = _t1685 - _t1686 = self.parse_terms() - terms919 = _t1686 - self.consume_literal(")") - _t1687 = logic_pb2.FFI(name=name917, args=ffi_args918, terms=terms919) - result921 = _t1687 - self.record_span(span_start920, "FFI") - return result921 + _t1690 = self.parse_name() + name920 = _t1690 + _t1691 = self.parse_ffi_args() + ffi_args921 = _t1691 + _t1692 = self.parse_terms() + terms922 = _t1692 + self.consume_literal(")") + _t1693 = logic_pb2.FFI(name=name920, args=ffi_args921, terms=terms922) + result924 = _t1693 + self.record_span(span_start923, "FFI") + return result924 def parse_name(self) -> str: self.consume_literal(":") - symbol922 = self.consume_terminal("SYMBOL") - return symbol922 + symbol925 = self.consume_terminal("SYMBOL") + return symbol925 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - xs923 = [] - cond924 = self.match_lookahead_literal("(", 0) - while cond924: - _t1688 = self.parse_abstraction() - item925 = _t1688 - xs923.append(item925) - cond924 = self.match_lookahead_literal("(", 0) - abstractions926 = xs923 + xs926 = [] + cond927 = self.match_lookahead_literal("(", 0) + while cond927: + _t1694 = self.parse_abstraction() + item928 = _t1694 + xs926.append(item928) + cond927 = self.match_lookahead_literal("(", 0) + abstractions929 = xs926 self.consume_literal(")") - return abstractions926 + return abstractions929 def parse_atom(self) -> logic_pb2.Atom: - span_start932 = self.span_start() + span_start935 = self.span_start() self.consume_literal("(") self.consume_literal("atom") - _t1689 = self.parse_relation_id() - relation_id927 = _t1689 - xs928 = [] - cond929 = (((((((((((((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 cond929: - _t1690 = self.parse_term() - item930 = _t1690 - xs928.append(item930) - cond929 = (((((((((((((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)) - terms931 = xs928 - self.consume_literal(")") - _t1691 = logic_pb2.Atom(name=relation_id927, terms=terms931) - result933 = _t1691 - self.record_span(span_start932, "Atom") - return result933 + _t1695 = self.parse_relation_id() + relation_id930 = _t1695 + xs931 = [] + cond932 = (((((((((((((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 cond932: + _t1696 = self.parse_term() + item933 = _t1696 + xs931.append(item933) + cond932 = (((((((((((((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)) + terms934 = xs931 + self.consume_literal(")") + _t1697 = logic_pb2.Atom(name=relation_id930, terms=terms934) + result936 = _t1697 + self.record_span(span_start935, "Atom") + return result936 def parse_pragma(self) -> logic_pb2.Pragma: - span_start939 = self.span_start() + span_start942 = self.span_start() self.consume_literal("(") self.consume_literal("pragma") - _t1692 = self.parse_name() - name934 = _t1692 - xs935 = [] - cond936 = (((((((((((((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 cond936: - _t1693 = self.parse_term() - item937 = _t1693 - xs935.append(item937) - cond936 = (((((((((((((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)) - terms938 = xs935 - self.consume_literal(")") - _t1694 = logic_pb2.Pragma(name=name934, terms=terms938) - result940 = _t1694 - self.record_span(span_start939, "Pragma") - return result940 + _t1698 = self.parse_name() + name937 = _t1698 + xs938 = [] + cond939 = (((((((((((((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 cond939: + _t1699 = self.parse_term() + item940 = _t1699 + xs938.append(item940) + cond939 = (((((((((((((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)) + terms941 = xs938 + self.consume_literal(")") + _t1700 = logic_pb2.Pragma(name=name937, terms=terms941) + result943 = _t1700 + self.record_span(span_start942, "Pragma") + return result943 def parse_primitive(self) -> logic_pb2.Primitive: - span_start956 = self.span_start() + span_start959 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1696 = 9 + _t1702 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1697 = 4 + _t1703 = 4 else: if self.match_lookahead_literal(">", 1): - _t1698 = 3 + _t1704 = 3 else: if self.match_lookahead_literal("=", 1): - _t1699 = 0 + _t1705 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1700 = 2 + _t1706 = 2 else: if self.match_lookahead_literal("<", 1): - _t1701 = 1 + _t1707 = 1 else: if self.match_lookahead_literal("/", 1): - _t1702 = 8 + _t1708 = 8 else: if self.match_lookahead_literal("-", 1): - _t1703 = 6 + _t1709 = 6 else: if self.match_lookahead_literal("+", 1): - _t1704 = 5 + _t1710 = 5 else: if self.match_lookahead_literal("*", 1): - _t1705 = 7 + _t1711 = 7 else: - _t1705 = -1 - _t1704 = _t1705 - _t1703 = _t1704 - _t1702 = _t1703 - _t1701 = _t1702 - _t1700 = _t1701 - _t1699 = _t1700 - _t1698 = _t1699 - _t1697 = _t1698 - _t1696 = _t1697 - _t1695 = _t1696 - else: - _t1695 = -1 - prediction941 = _t1695 - if prediction941 == 9: + _t1711 = -1 + _t1710 = _t1711 + _t1709 = _t1710 + _t1708 = _t1709 + _t1707 = _t1708 + _t1706 = _t1707 + _t1705 = _t1706 + _t1704 = _t1705 + _t1703 = _t1704 + _t1702 = _t1703 + _t1701 = _t1702 + else: + _t1701 = -1 + prediction944 = _t1701 + if prediction944 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1707 = self.parse_name() - name951 = _t1707 - xs952 = [] - cond953 = ((((((((((((((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 cond953: - _t1708 = self.parse_rel_term() - item954 = _t1708 - xs952.append(item954) - cond953 = ((((((((((((((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_terms955 = xs952 + _t1713 = self.parse_name() + name954 = _t1713 + xs955 = [] + cond956 = ((((((((((((((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 cond956: + _t1714 = self.parse_rel_term() + item957 = _t1714 + xs955.append(item957) + cond956 = ((((((((((((((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_terms958 = xs955 self.consume_literal(")") - _t1709 = logic_pb2.Primitive(name=name951, terms=rel_terms955) - _t1706 = _t1709 + _t1715 = logic_pb2.Primitive(name=name954, terms=rel_terms958) + _t1712 = _t1715 else: - if prediction941 == 8: - _t1711 = self.parse_divide() - divide950 = _t1711 - _t1710 = divide950 + if prediction944 == 8: + _t1717 = self.parse_divide() + divide953 = _t1717 + _t1716 = divide953 else: - if prediction941 == 7: - _t1713 = self.parse_multiply() - multiply949 = _t1713 - _t1712 = multiply949 + if prediction944 == 7: + _t1719 = self.parse_multiply() + multiply952 = _t1719 + _t1718 = multiply952 else: - if prediction941 == 6: - _t1715 = self.parse_minus() - minus948 = _t1715 - _t1714 = minus948 + if prediction944 == 6: + _t1721 = self.parse_minus() + minus951 = _t1721 + _t1720 = minus951 else: - if prediction941 == 5: - _t1717 = self.parse_add() - add947 = _t1717 - _t1716 = add947 + if prediction944 == 5: + _t1723 = self.parse_add() + add950 = _t1723 + _t1722 = add950 else: - if prediction941 == 4: - _t1719 = self.parse_gt_eq() - gt_eq946 = _t1719 - _t1718 = gt_eq946 + if prediction944 == 4: + _t1725 = self.parse_gt_eq() + gt_eq949 = _t1725 + _t1724 = gt_eq949 else: - if prediction941 == 3: - _t1721 = self.parse_gt() - gt945 = _t1721 - _t1720 = gt945 + if prediction944 == 3: + _t1727 = self.parse_gt() + gt948 = _t1727 + _t1726 = gt948 else: - if prediction941 == 2: - _t1723 = self.parse_lt_eq() - lt_eq944 = _t1723 - _t1722 = lt_eq944 + if prediction944 == 2: + _t1729 = self.parse_lt_eq() + lt_eq947 = _t1729 + _t1728 = lt_eq947 else: - if prediction941 == 1: - _t1725 = self.parse_lt() - lt943 = _t1725 - _t1724 = lt943 + if prediction944 == 1: + _t1731 = self.parse_lt() + lt946 = _t1731 + _t1730 = lt946 else: - if prediction941 == 0: - _t1727 = self.parse_eq() - eq942 = _t1727 - _t1726 = eq942 + if prediction944 == 0: + _t1733 = self.parse_eq() + eq945 = _t1733 + _t1732 = eq945 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1724 = _t1726 - _t1722 = _t1724 - _t1720 = _t1722 - _t1718 = _t1720 - _t1716 = _t1718 - _t1714 = _t1716 - _t1712 = _t1714 - _t1710 = _t1712 - _t1706 = _t1710 - result957 = _t1706 - self.record_span(span_start956, "Primitive") - return result957 + _t1730 = _t1732 + _t1728 = _t1730 + _t1726 = _t1728 + _t1724 = _t1726 + _t1722 = _t1724 + _t1720 = _t1722 + _t1718 = _t1720 + _t1716 = _t1718 + _t1712 = _t1716 + result960 = _t1712 + self.record_span(span_start959, "Primitive") + return result960 def parse_eq(self) -> logic_pb2.Primitive: - span_start960 = self.span_start() + span_start963 = self.span_start() self.consume_literal("(") self.consume_literal("=") - _t1728 = self.parse_term() - term958 = _t1728 - _t1729 = self.parse_term() - term_3959 = _t1729 - self.consume_literal(")") - _t1730 = logic_pb2.RelTerm(term=term958) - _t1731 = logic_pb2.RelTerm(term=term_3959) - _t1732 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1730, _t1731]) - result961 = _t1732 - self.record_span(span_start960, "Primitive") - return result961 + _t1734 = self.parse_term() + term961 = _t1734 + _t1735 = self.parse_term() + term_3962 = _t1735 + self.consume_literal(")") + _t1736 = logic_pb2.RelTerm(term=term961) + _t1737 = logic_pb2.RelTerm(term=term_3962) + _t1738 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1736, _t1737]) + result964 = _t1738 + self.record_span(span_start963, "Primitive") + return result964 def parse_lt(self) -> logic_pb2.Primitive: - span_start964 = self.span_start() + span_start967 = self.span_start() self.consume_literal("(") self.consume_literal("<") - _t1733 = self.parse_term() - term962 = _t1733 - _t1734 = self.parse_term() - term_3963 = _t1734 + _t1739 = self.parse_term() + term965 = _t1739 + _t1740 = self.parse_term() + term_3966 = _t1740 self.consume_literal(")") - _t1735 = logic_pb2.RelTerm(term=term962) - _t1736 = logic_pb2.RelTerm(term=term_3963) - _t1737 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1735, _t1736]) - result965 = _t1737 - self.record_span(span_start964, "Primitive") - return result965 + _t1741 = logic_pb2.RelTerm(term=term965) + _t1742 = logic_pb2.RelTerm(term=term_3966) + _t1743 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1741, _t1742]) + result968 = _t1743 + self.record_span(span_start967, "Primitive") + return result968 def parse_lt_eq(self) -> logic_pb2.Primitive: - span_start968 = self.span_start() + span_start971 = self.span_start() self.consume_literal("(") self.consume_literal("<=") - _t1738 = self.parse_term() - term966 = _t1738 - _t1739 = self.parse_term() - term_3967 = _t1739 + _t1744 = self.parse_term() + term969 = _t1744 + _t1745 = self.parse_term() + term_3970 = _t1745 self.consume_literal(")") - _t1740 = logic_pb2.RelTerm(term=term966) - _t1741 = logic_pb2.RelTerm(term=term_3967) - _t1742 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1740, _t1741]) - result969 = _t1742 - self.record_span(span_start968, "Primitive") - return result969 + _t1746 = logic_pb2.RelTerm(term=term969) + _t1747 = logic_pb2.RelTerm(term=term_3970) + _t1748 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1746, _t1747]) + result972 = _t1748 + self.record_span(span_start971, "Primitive") + return result972 def parse_gt(self) -> logic_pb2.Primitive: - span_start972 = self.span_start() + span_start975 = self.span_start() self.consume_literal("(") self.consume_literal(">") - _t1743 = self.parse_term() - term970 = _t1743 - _t1744 = self.parse_term() - term_3971 = _t1744 + _t1749 = self.parse_term() + term973 = _t1749 + _t1750 = self.parse_term() + term_3974 = _t1750 self.consume_literal(")") - _t1745 = logic_pb2.RelTerm(term=term970) - _t1746 = logic_pb2.RelTerm(term=term_3971) - _t1747 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1745, _t1746]) - result973 = _t1747 - self.record_span(span_start972, "Primitive") - return result973 + _t1751 = logic_pb2.RelTerm(term=term973) + _t1752 = logic_pb2.RelTerm(term=term_3974) + _t1753 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1751, _t1752]) + result976 = _t1753 + self.record_span(span_start975, "Primitive") + return result976 def parse_gt_eq(self) -> logic_pb2.Primitive: - span_start976 = self.span_start() + span_start979 = self.span_start() self.consume_literal("(") self.consume_literal(">=") - _t1748 = self.parse_term() - term974 = _t1748 - _t1749 = self.parse_term() - term_3975 = _t1749 + _t1754 = self.parse_term() + term977 = _t1754 + _t1755 = self.parse_term() + term_3978 = _t1755 self.consume_literal(")") - _t1750 = logic_pb2.RelTerm(term=term974) - _t1751 = logic_pb2.RelTerm(term=term_3975) - _t1752 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1750, _t1751]) - result977 = _t1752 - self.record_span(span_start976, "Primitive") - return result977 + _t1756 = logic_pb2.RelTerm(term=term977) + _t1757 = logic_pb2.RelTerm(term=term_3978) + _t1758 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1756, _t1757]) + result980 = _t1758 + self.record_span(span_start979, "Primitive") + return result980 def parse_add(self) -> logic_pb2.Primitive: - span_start981 = self.span_start() + span_start984 = self.span_start() self.consume_literal("(") self.consume_literal("+") - _t1753 = self.parse_term() - term978 = _t1753 - _t1754 = self.parse_term() - term_3979 = _t1754 - _t1755 = self.parse_term() - term_4980 = _t1755 + _t1759 = self.parse_term() + term981 = _t1759 + _t1760 = self.parse_term() + term_3982 = _t1760 + _t1761 = self.parse_term() + term_4983 = _t1761 self.consume_literal(")") - _t1756 = logic_pb2.RelTerm(term=term978) - _t1757 = logic_pb2.RelTerm(term=term_3979) - _t1758 = logic_pb2.RelTerm(term=term_4980) - _t1759 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1756, _t1757, _t1758]) - result982 = _t1759 - self.record_span(span_start981, "Primitive") - return result982 + _t1762 = logic_pb2.RelTerm(term=term981) + _t1763 = logic_pb2.RelTerm(term=term_3982) + _t1764 = logic_pb2.RelTerm(term=term_4983) + _t1765 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1762, _t1763, _t1764]) + result985 = _t1765 + self.record_span(span_start984, "Primitive") + return result985 def parse_minus(self) -> logic_pb2.Primitive: - span_start986 = self.span_start() + span_start989 = self.span_start() self.consume_literal("(") self.consume_literal("-") - _t1760 = self.parse_term() - term983 = _t1760 - _t1761 = self.parse_term() - term_3984 = _t1761 - _t1762 = self.parse_term() - term_4985 = _t1762 - self.consume_literal(")") - _t1763 = logic_pb2.RelTerm(term=term983) - _t1764 = logic_pb2.RelTerm(term=term_3984) - _t1765 = logic_pb2.RelTerm(term=term_4985) - _t1766 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1763, _t1764, _t1765]) - result987 = _t1766 - self.record_span(span_start986, "Primitive") - return result987 + _t1766 = self.parse_term() + term986 = _t1766 + _t1767 = self.parse_term() + term_3987 = _t1767 + _t1768 = self.parse_term() + term_4988 = _t1768 + self.consume_literal(")") + _t1769 = logic_pb2.RelTerm(term=term986) + _t1770 = logic_pb2.RelTerm(term=term_3987) + _t1771 = logic_pb2.RelTerm(term=term_4988) + _t1772 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1769, _t1770, _t1771]) + result990 = _t1772 + self.record_span(span_start989, "Primitive") + return result990 def parse_multiply(self) -> logic_pb2.Primitive: - span_start991 = self.span_start() + span_start994 = self.span_start() self.consume_literal("(") self.consume_literal("*") - _t1767 = self.parse_term() - term988 = _t1767 - _t1768 = self.parse_term() - term_3989 = _t1768 - _t1769 = self.parse_term() - term_4990 = _t1769 - self.consume_literal(")") - _t1770 = logic_pb2.RelTerm(term=term988) - _t1771 = logic_pb2.RelTerm(term=term_3989) - _t1772 = logic_pb2.RelTerm(term=term_4990) - _t1773 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1770, _t1771, _t1772]) - result992 = _t1773 - self.record_span(span_start991, "Primitive") - return result992 + _t1773 = self.parse_term() + term991 = _t1773 + _t1774 = self.parse_term() + term_3992 = _t1774 + _t1775 = self.parse_term() + term_4993 = _t1775 + self.consume_literal(")") + _t1776 = logic_pb2.RelTerm(term=term991) + _t1777 = logic_pb2.RelTerm(term=term_3992) + _t1778 = logic_pb2.RelTerm(term=term_4993) + _t1779 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1776, _t1777, _t1778]) + result995 = _t1779 + self.record_span(span_start994, "Primitive") + return result995 def parse_divide(self) -> logic_pb2.Primitive: - span_start996 = self.span_start() + span_start999 = self.span_start() self.consume_literal("(") self.consume_literal("/") - _t1774 = self.parse_term() - term993 = _t1774 - _t1775 = self.parse_term() - term_3994 = _t1775 - _t1776 = self.parse_term() - term_4995 = _t1776 - self.consume_literal(")") - _t1777 = logic_pb2.RelTerm(term=term993) - _t1778 = logic_pb2.RelTerm(term=term_3994) - _t1779 = logic_pb2.RelTerm(term=term_4995) - _t1780 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1777, _t1778, _t1779]) - result997 = _t1780 - self.record_span(span_start996, "Primitive") - return result997 + _t1780 = self.parse_term() + term996 = _t1780 + _t1781 = self.parse_term() + term_3997 = _t1781 + _t1782 = self.parse_term() + term_4998 = _t1782 + self.consume_literal(")") + _t1783 = logic_pb2.RelTerm(term=term996) + _t1784 = logic_pb2.RelTerm(term=term_3997) + _t1785 = logic_pb2.RelTerm(term=term_4998) + _t1786 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1783, _t1784, _t1785]) + result1000 = _t1786 + self.record_span(span_start999, "Primitive") + return result1000 def parse_rel_term(self) -> logic_pb2.RelTerm: - span_start1001 = self.span_start() + span_start1004 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1781 = 1 + _t1787 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1782 = 1 + _t1788 = 1 else: if self.match_lookahead_literal("false", 0): - _t1783 = 1 + _t1789 = 1 else: if self.match_lookahead_literal("(", 0): - _t1784 = 1 + _t1790 = 1 else: if self.match_lookahead_literal("#", 0): - _t1785 = 0 + _t1791 = 0 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1786 = 1 + _t1792 = 1 else: if self.match_lookahead_terminal("UINT32", 0): - _t1787 = 1 + _t1793 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1788 = 1 + _t1794 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1789 = 1 + _t1795 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1790 = 1 + _t1796 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1791 = 1 + _t1797 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1792 = 1 + _t1798 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1793 = 1 + _t1799 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1794 = 1 + _t1800 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1795 = 1 + _t1801 = 1 else: - _t1795 = -1 - _t1794 = _t1795 - _t1793 = _t1794 - _t1792 = _t1793 - _t1791 = _t1792 - _t1790 = _t1791 - _t1789 = _t1790 - _t1788 = _t1789 - _t1787 = _t1788 - _t1786 = _t1787 - _t1785 = _t1786 - _t1784 = _t1785 - _t1783 = _t1784 - _t1782 = _t1783 - _t1781 = _t1782 - prediction998 = _t1781 - if prediction998 == 1: - _t1797 = self.parse_term() - term1000 = _t1797 - _t1798 = logic_pb2.RelTerm(term=term1000) - _t1796 = _t1798 - else: - if prediction998 == 0: - _t1800 = self.parse_specialized_value() - specialized_value999 = _t1800 - _t1801 = logic_pb2.RelTerm(specialized_value=specialized_value999) - _t1799 = _t1801 + _t1801 = -1 + _t1800 = _t1801 + _t1799 = _t1800 + _t1798 = _t1799 + _t1797 = _t1798 + _t1796 = _t1797 + _t1795 = _t1796 + _t1794 = _t1795 + _t1793 = _t1794 + _t1792 = _t1793 + _t1791 = _t1792 + _t1790 = _t1791 + _t1789 = _t1790 + _t1788 = _t1789 + _t1787 = _t1788 + prediction1001 = _t1787 + if prediction1001 == 1: + _t1803 = self.parse_term() + term1003 = _t1803 + _t1804 = logic_pb2.RelTerm(term=term1003) + _t1802 = _t1804 + else: + if prediction1001 == 0: + _t1806 = self.parse_specialized_value() + specialized_value1002 = _t1806 + _t1807 = logic_pb2.RelTerm(specialized_value=specialized_value1002) + _t1805 = _t1807 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1796 = _t1799 - result1002 = _t1796 - self.record_span(span_start1001, "RelTerm") - return result1002 + _t1802 = _t1805 + result1005 = _t1802 + self.record_span(span_start1004, "RelTerm") + return result1005 def parse_specialized_value(self) -> logic_pb2.Value: - span_start1004 = self.span_start() + span_start1007 = self.span_start() self.consume_literal("#") - _t1802 = self.parse_raw_value() - raw_value1003 = _t1802 - result1005 = raw_value1003 - self.record_span(span_start1004, "Value") - return result1005 + _t1808 = self.parse_raw_value() + raw_value1006 = _t1808 + result1008 = raw_value1006 + self.record_span(span_start1007, "Value") + return result1008 def parse_rel_atom(self) -> logic_pb2.RelAtom: - span_start1011 = self.span_start() + span_start1014 = self.span_start() self.consume_literal("(") self.consume_literal("relatom") - _t1803 = self.parse_name() - name1006 = _t1803 - xs1007 = [] - cond1008 = ((((((((((((((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 cond1008: - _t1804 = self.parse_rel_term() - item1009 = _t1804 - xs1007.append(item1009) - cond1008 = ((((((((((((((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_terms1010 = xs1007 - self.consume_literal(")") - _t1805 = logic_pb2.RelAtom(name=name1006, terms=rel_terms1010) - result1012 = _t1805 - self.record_span(span_start1011, "RelAtom") - return result1012 + _t1809 = self.parse_name() + name1009 = _t1809 + xs1010 = [] + cond1011 = ((((((((((((((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 cond1011: + _t1810 = self.parse_rel_term() + item1012 = _t1810 + xs1010.append(item1012) + cond1011 = ((((((((((((((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_terms1013 = xs1010 + self.consume_literal(")") + _t1811 = logic_pb2.RelAtom(name=name1009, terms=rel_terms1013) + result1015 = _t1811 + self.record_span(span_start1014, "RelAtom") + return result1015 def parse_cast(self) -> logic_pb2.Cast: - span_start1015 = self.span_start() + span_start1018 = self.span_start() self.consume_literal("(") self.consume_literal("cast") - _t1806 = self.parse_term() - term1013 = _t1806 - _t1807 = self.parse_term() - term_31014 = _t1807 + _t1812 = self.parse_term() + term1016 = _t1812 + _t1813 = self.parse_term() + term_31017 = _t1813 self.consume_literal(")") - _t1808 = logic_pb2.Cast(input=term1013, result=term_31014) - result1016 = _t1808 - self.record_span(span_start1015, "Cast") - return result1016 + _t1814 = logic_pb2.Cast(input=term1016, result=term_31017) + result1019 = _t1814 + self.record_span(span_start1018, "Cast") + return result1019 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") - xs1017 = [] - cond1018 = self.match_lookahead_literal("(", 0) - while cond1018: - _t1809 = self.parse_attribute() - item1019 = _t1809 - xs1017.append(item1019) - cond1018 = self.match_lookahead_literal("(", 0) - attributes1020 = xs1017 + xs1020 = [] + cond1021 = self.match_lookahead_literal("(", 0) + while cond1021: + _t1815 = self.parse_attribute() + item1022 = _t1815 + xs1020.append(item1022) + cond1021 = self.match_lookahead_literal("(", 0) + attributes1023 = xs1020 self.consume_literal(")") - return attributes1020 + return attributes1023 def parse_attribute(self) -> logic_pb2.Attribute: - span_start1026 = self.span_start() + span_start1029 = self.span_start() self.consume_literal("(") self.consume_literal("attribute") - _t1810 = self.parse_name() - name1021 = _t1810 - xs1022 = [] - cond1023 = ((((((((((((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 cond1023: - _t1811 = self.parse_raw_value() - item1024 = _t1811 - xs1022.append(item1024) - cond1023 = ((((((((((((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_values1025 = xs1022 - self.consume_literal(")") - _t1812 = logic_pb2.Attribute(name=name1021, args=raw_values1025) - result1027 = _t1812 - self.record_span(span_start1026, "Attribute") - return result1027 + _t1816 = self.parse_name() + name1024 = _t1816 + xs1025 = [] + cond1026 = ((((((((((((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 cond1026: + _t1817 = self.parse_raw_value() + item1027 = _t1817 + xs1025.append(item1027) + cond1026 = ((((((((((((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_values1028 = xs1025 + self.consume_literal(")") + _t1818 = logic_pb2.Attribute(name=name1024, args=raw_values1028) + result1030 = _t1818 + self.record_span(span_start1029, "Attribute") + return result1030 def parse_algorithm(self) -> logic_pb2.Algorithm: - span_start1034 = self.span_start() + span_start1037 = self.span_start() self.consume_literal("(") self.consume_literal("algorithm") - xs1028 = [] - cond1029 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1029: - _t1813 = self.parse_relation_id() - item1030 = _t1813 - xs1028.append(item1030) - cond1029 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1031 = xs1028 - _t1814 = self.parse_script() - script1032 = _t1814 + xs1031 = [] + cond1032 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1032: + _t1819 = self.parse_relation_id() + item1033 = _t1819 + xs1031.append(item1033) + cond1032 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1034 = xs1031 + _t1820 = self.parse_script() + script1035 = _t1820 if self.match_lookahead_literal("(", 0): - _t1816 = self.parse_attrs() - _t1815 = _t1816 + _t1822 = self.parse_attrs() + _t1821 = _t1822 else: - _t1815 = None - attrs1033 = _t1815 + _t1821 = None + attrs1036 = _t1821 self.consume_literal(")") - _t1817 = logic_pb2.Algorithm(body=script1032, attrs=(attrs1033 if attrs1033 is not None else [])) - getattr(_t1817, 'global').extend(relation_ids1031) - result1035 = _t1817 - self.record_span(span_start1034, "Algorithm") - return result1035 + _t1823 = logic_pb2.Algorithm(body=script1035, attrs=(attrs1036 if attrs1036 is not None else [])) + getattr(_t1823, 'global').extend(relation_ids1034) + result1038 = _t1823 + self.record_span(span_start1037, "Algorithm") + return result1038 def parse_script(self) -> logic_pb2.Script: - span_start1040 = self.span_start() + span_start1043 = self.span_start() self.consume_literal("(") self.consume_literal("script") - xs1036 = [] - cond1037 = self.match_lookahead_literal("(", 0) - while cond1037: - _t1818 = self.parse_construct() - item1038 = _t1818 - xs1036.append(item1038) - cond1037 = self.match_lookahead_literal("(", 0) - constructs1039 = xs1036 - self.consume_literal(")") - _t1819 = logic_pb2.Script(constructs=constructs1039) - result1041 = _t1819 - self.record_span(span_start1040, "Script") - return result1041 + xs1039 = [] + cond1040 = self.match_lookahead_literal("(", 0) + while cond1040: + _t1824 = self.parse_construct() + item1041 = _t1824 + xs1039.append(item1041) + cond1040 = self.match_lookahead_literal("(", 0) + constructs1042 = xs1039 + self.consume_literal(")") + _t1825 = logic_pb2.Script(constructs=constructs1042) + result1044 = _t1825 + self.record_span(span_start1043, "Script") + return result1044 def parse_construct(self) -> logic_pb2.Construct: - span_start1045 = self.span_start() + span_start1048 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1821 = 1 + _t1827 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1822 = 1 + _t1828 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1823 = 1 + _t1829 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1824 = 0 + _t1830 = 0 else: if self.match_lookahead_literal("break", 1): - _t1825 = 1 + _t1831 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1826 = 1 + _t1832 = 1 else: - _t1826 = -1 - _t1825 = _t1826 - _t1824 = _t1825 - _t1823 = _t1824 - _t1822 = _t1823 - _t1821 = _t1822 - _t1820 = _t1821 - else: - _t1820 = -1 - prediction1042 = _t1820 - if prediction1042 == 1: - _t1828 = self.parse_instruction() - instruction1044 = _t1828 - _t1829 = logic_pb2.Construct(instruction=instruction1044) - _t1827 = _t1829 - else: - if prediction1042 == 0: - _t1831 = self.parse_loop() - loop1043 = _t1831 - _t1832 = logic_pb2.Construct(loop=loop1043) - _t1830 = _t1832 + _t1832 = -1 + _t1831 = _t1832 + _t1830 = _t1831 + _t1829 = _t1830 + _t1828 = _t1829 + _t1827 = _t1828 + _t1826 = _t1827 + else: + _t1826 = -1 + prediction1045 = _t1826 + if prediction1045 == 1: + _t1834 = self.parse_instruction() + instruction1047 = _t1834 + _t1835 = logic_pb2.Construct(instruction=instruction1047) + _t1833 = _t1835 + else: + if prediction1045 == 0: + _t1837 = self.parse_loop() + loop1046 = _t1837 + _t1838 = logic_pb2.Construct(loop=loop1046) + _t1836 = _t1838 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1827 = _t1830 - result1046 = _t1827 - self.record_span(span_start1045, "Construct") - return result1046 + _t1833 = _t1836 + result1049 = _t1833 + self.record_span(span_start1048, "Construct") + return result1049 def parse_loop(self) -> logic_pb2.Loop: - span_start1050 = self.span_start() + span_start1053 = self.span_start() self.consume_literal("(") self.consume_literal("loop") - _t1833 = self.parse_init() - init1047 = _t1833 - _t1834 = self.parse_script() - script1048 = _t1834 + _t1839 = self.parse_init() + init1050 = _t1839 + _t1840 = self.parse_script() + script1051 = _t1840 if self.match_lookahead_literal("(", 0): - _t1836 = self.parse_attrs() - _t1835 = _t1836 + _t1842 = self.parse_attrs() + _t1841 = _t1842 else: - _t1835 = None - attrs1049 = _t1835 + _t1841 = None + attrs1052 = _t1841 self.consume_literal(")") - _t1837 = logic_pb2.Loop(init=init1047, body=script1048, attrs=(attrs1049 if attrs1049 is not None else [])) - result1051 = _t1837 - self.record_span(span_start1050, "Loop") - return result1051 + _t1843 = logic_pb2.Loop(init=init1050, body=script1051, attrs=(attrs1052 if attrs1052 is not None else [])) + result1054 = _t1843 + self.record_span(span_start1053, "Loop") + return result1054 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") - xs1052 = [] - cond1053 = self.match_lookahead_literal("(", 0) - while cond1053: - _t1838 = self.parse_instruction() - item1054 = _t1838 - xs1052.append(item1054) - cond1053 = self.match_lookahead_literal("(", 0) - instructions1055 = xs1052 + xs1055 = [] + cond1056 = self.match_lookahead_literal("(", 0) + while cond1056: + _t1844 = self.parse_instruction() + item1057 = _t1844 + xs1055.append(item1057) + cond1056 = self.match_lookahead_literal("(", 0) + instructions1058 = xs1055 self.consume_literal(")") - return instructions1055 + return instructions1058 def parse_instruction(self) -> logic_pb2.Instruction: - span_start1062 = self.span_start() + span_start1065 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1840 = 1 + _t1846 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1841 = 4 + _t1847 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1842 = 3 + _t1848 = 3 else: if self.match_lookahead_literal("break", 1): - _t1843 = 2 + _t1849 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1844 = 0 + _t1850 = 0 else: - _t1844 = -1 - _t1843 = _t1844 - _t1842 = _t1843 - _t1841 = _t1842 - _t1840 = _t1841 - _t1839 = _t1840 - else: - _t1839 = -1 - prediction1056 = _t1839 - if prediction1056 == 4: - _t1846 = self.parse_monus_def() - monus_def1061 = _t1846 - _t1847 = logic_pb2.Instruction(monus_def=monus_def1061) - _t1845 = _t1847 - else: - if prediction1056 == 3: - _t1849 = self.parse_monoid_def() - monoid_def1060 = _t1849 - _t1850 = logic_pb2.Instruction(monoid_def=monoid_def1060) - _t1848 = _t1850 + _t1850 = -1 + _t1849 = _t1850 + _t1848 = _t1849 + _t1847 = _t1848 + _t1846 = _t1847 + _t1845 = _t1846 + else: + _t1845 = -1 + prediction1059 = _t1845 + if prediction1059 == 4: + _t1852 = self.parse_monus_def() + monus_def1064 = _t1852 + _t1853 = logic_pb2.Instruction(monus_def=monus_def1064) + _t1851 = _t1853 + else: + if prediction1059 == 3: + _t1855 = self.parse_monoid_def() + monoid_def1063 = _t1855 + _t1856 = logic_pb2.Instruction(monoid_def=monoid_def1063) + _t1854 = _t1856 else: - if prediction1056 == 2: - _t1852 = self.parse_break() - break1059 = _t1852 - _t1853 = logic_pb2.Instruction() - getattr(_t1853, 'break').CopyFrom(break1059) - _t1851 = _t1853 + if prediction1059 == 2: + _t1858 = self.parse_break() + break1062 = _t1858 + _t1859 = logic_pb2.Instruction() + getattr(_t1859, 'break').CopyFrom(break1062) + _t1857 = _t1859 else: - if prediction1056 == 1: - _t1855 = self.parse_upsert() - upsert1058 = _t1855 - _t1856 = logic_pb2.Instruction(upsert=upsert1058) - _t1854 = _t1856 + if prediction1059 == 1: + _t1861 = self.parse_upsert() + upsert1061 = _t1861 + _t1862 = logic_pb2.Instruction(upsert=upsert1061) + _t1860 = _t1862 else: - if prediction1056 == 0: - _t1858 = self.parse_assign() - assign1057 = _t1858 - _t1859 = logic_pb2.Instruction(assign=assign1057) - _t1857 = _t1859 + if prediction1059 == 0: + _t1864 = self.parse_assign() + assign1060 = _t1864 + _t1865 = logic_pb2.Instruction(assign=assign1060) + _t1863 = _t1865 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1854 = _t1857 - _t1851 = _t1854 - _t1848 = _t1851 - _t1845 = _t1848 - result1063 = _t1845 - self.record_span(span_start1062, "Instruction") - return result1063 + _t1860 = _t1863 + _t1857 = _t1860 + _t1854 = _t1857 + _t1851 = _t1854 + result1066 = _t1851 + self.record_span(span_start1065, "Instruction") + return result1066 def parse_assign(self) -> logic_pb2.Assign: - span_start1067 = self.span_start() + span_start1070 = self.span_start() self.consume_literal("(") self.consume_literal("assign") - _t1860 = self.parse_relation_id() - relation_id1064 = _t1860 - _t1861 = self.parse_abstraction() - abstraction1065 = _t1861 + _t1866 = self.parse_relation_id() + relation_id1067 = _t1866 + _t1867 = self.parse_abstraction() + abstraction1068 = _t1867 if self.match_lookahead_literal("(", 0): - _t1863 = self.parse_attrs() - _t1862 = _t1863 + _t1869 = self.parse_attrs() + _t1868 = _t1869 else: - _t1862 = None - attrs1066 = _t1862 + _t1868 = None + attrs1069 = _t1868 self.consume_literal(")") - _t1864 = logic_pb2.Assign(name=relation_id1064, body=abstraction1065, attrs=(attrs1066 if attrs1066 is not None else [])) - result1068 = _t1864 - self.record_span(span_start1067, "Assign") - return result1068 + _t1870 = logic_pb2.Assign(name=relation_id1067, body=abstraction1068, attrs=(attrs1069 if attrs1069 is not None else [])) + result1071 = _t1870 + self.record_span(span_start1070, "Assign") + return result1071 def parse_upsert(self) -> logic_pb2.Upsert: - span_start1072 = self.span_start() + span_start1075 = self.span_start() self.consume_literal("(") self.consume_literal("upsert") - _t1865 = self.parse_relation_id() - relation_id1069 = _t1865 - _t1866 = self.parse_abstraction_with_arity() - abstraction_with_arity1070 = _t1866 + _t1871 = self.parse_relation_id() + relation_id1072 = _t1871 + _t1872 = self.parse_abstraction_with_arity() + abstraction_with_arity1073 = _t1872 if self.match_lookahead_literal("(", 0): - _t1868 = self.parse_attrs() - _t1867 = _t1868 + _t1874 = self.parse_attrs() + _t1873 = _t1874 else: - _t1867 = None - attrs1071 = _t1867 + _t1873 = None + attrs1074 = _t1873 self.consume_literal(")") - _t1869 = logic_pb2.Upsert(name=relation_id1069, body=abstraction_with_arity1070[0], attrs=(attrs1071 if attrs1071 is not None else []), value_arity=abstraction_with_arity1070[1]) - result1073 = _t1869 - self.record_span(span_start1072, "Upsert") - return result1073 + _t1875 = logic_pb2.Upsert(name=relation_id1072, body=abstraction_with_arity1073[0], attrs=(attrs1074 if attrs1074 is not None else []), value_arity=abstraction_with_arity1073[1]) + result1076 = _t1875 + self.record_span(span_start1075, "Upsert") + return result1076 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1870 = self.parse_bindings() - bindings1074 = _t1870 - _t1871 = self.parse_formula() - formula1075 = _t1871 + _t1876 = self.parse_bindings() + bindings1077 = _t1876 + _t1877 = self.parse_formula() + formula1078 = _t1877 self.consume_literal(")") - _t1872 = logic_pb2.Abstraction(vars=(list(bindings1074[0]) + list(bindings1074[1] if bindings1074[1] is not None else [])), value=formula1075) - return (_t1872, len(bindings1074[1]),) + _t1878 = logic_pb2.Abstraction(vars=(list(bindings1077[0]) + list(bindings1077[1] if bindings1077[1] is not None else [])), value=formula1078) + return (_t1878, len(bindings1077[1]),) def parse_break(self) -> logic_pb2.Break: - span_start1079 = self.span_start() + span_start1082 = self.span_start() self.consume_literal("(") self.consume_literal("break") - _t1873 = self.parse_relation_id() - relation_id1076 = _t1873 - _t1874 = self.parse_abstraction() - abstraction1077 = _t1874 + _t1879 = self.parse_relation_id() + relation_id1079 = _t1879 + _t1880 = self.parse_abstraction() + abstraction1080 = _t1880 if self.match_lookahead_literal("(", 0): - _t1876 = self.parse_attrs() - _t1875 = _t1876 + _t1882 = self.parse_attrs() + _t1881 = _t1882 else: - _t1875 = None - attrs1078 = _t1875 + _t1881 = None + attrs1081 = _t1881 self.consume_literal(")") - _t1877 = logic_pb2.Break(name=relation_id1076, body=abstraction1077, attrs=(attrs1078 if attrs1078 is not None else [])) - result1080 = _t1877 - self.record_span(span_start1079, "Break") - return result1080 + _t1883 = logic_pb2.Break(name=relation_id1079, body=abstraction1080, attrs=(attrs1081 if attrs1081 is not None else [])) + result1083 = _t1883 + self.record_span(span_start1082, "Break") + return result1083 def parse_monoid_def(self) -> logic_pb2.MonoidDef: - span_start1085 = self.span_start() + span_start1088 = self.span_start() self.consume_literal("(") self.consume_literal("monoid") - _t1878 = self.parse_monoid() - monoid1081 = _t1878 - _t1879 = self.parse_relation_id() - relation_id1082 = _t1879 - _t1880 = self.parse_abstraction_with_arity() - abstraction_with_arity1083 = _t1880 + _t1884 = self.parse_monoid() + monoid1084 = _t1884 + _t1885 = self.parse_relation_id() + relation_id1085 = _t1885 + _t1886 = self.parse_abstraction_with_arity() + abstraction_with_arity1086 = _t1886 if self.match_lookahead_literal("(", 0): - _t1882 = self.parse_attrs() - _t1881 = _t1882 + _t1888 = self.parse_attrs() + _t1887 = _t1888 else: - _t1881 = None - attrs1084 = _t1881 + _t1887 = None + attrs1087 = _t1887 self.consume_literal(")") - _t1883 = logic_pb2.MonoidDef(monoid=monoid1081, name=relation_id1082, body=abstraction_with_arity1083[0], attrs=(attrs1084 if attrs1084 is not None else []), value_arity=abstraction_with_arity1083[1]) - result1086 = _t1883 - self.record_span(span_start1085, "MonoidDef") - return result1086 + _t1889 = logic_pb2.MonoidDef(monoid=monoid1084, name=relation_id1085, body=abstraction_with_arity1086[0], attrs=(attrs1087 if attrs1087 is not None else []), value_arity=abstraction_with_arity1086[1]) + result1089 = _t1889 + self.record_span(span_start1088, "MonoidDef") + return result1089 def parse_monoid(self) -> logic_pb2.Monoid: - span_start1092 = self.span_start() + span_start1095 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1885 = 3 + _t1891 = 3 else: if self.match_lookahead_literal("or", 1): - _t1886 = 0 + _t1892 = 0 else: if self.match_lookahead_literal("min", 1): - _t1887 = 1 + _t1893 = 1 else: if self.match_lookahead_literal("max", 1): - _t1888 = 2 + _t1894 = 2 else: - _t1888 = -1 - _t1887 = _t1888 - _t1886 = _t1887 - _t1885 = _t1886 - _t1884 = _t1885 - else: - _t1884 = -1 - prediction1087 = _t1884 - if prediction1087 == 3: - _t1890 = self.parse_sum_monoid() - sum_monoid1091 = _t1890 - _t1891 = logic_pb2.Monoid(sum_monoid=sum_monoid1091) - _t1889 = _t1891 - else: - if prediction1087 == 2: - _t1893 = self.parse_max_monoid() - max_monoid1090 = _t1893 - _t1894 = logic_pb2.Monoid(max_monoid=max_monoid1090) - _t1892 = _t1894 + _t1894 = -1 + _t1893 = _t1894 + _t1892 = _t1893 + _t1891 = _t1892 + _t1890 = _t1891 + else: + _t1890 = -1 + prediction1090 = _t1890 + if prediction1090 == 3: + _t1896 = self.parse_sum_monoid() + sum_monoid1094 = _t1896 + _t1897 = logic_pb2.Monoid(sum_monoid=sum_monoid1094) + _t1895 = _t1897 + else: + if prediction1090 == 2: + _t1899 = self.parse_max_monoid() + max_monoid1093 = _t1899 + _t1900 = logic_pb2.Monoid(max_monoid=max_monoid1093) + _t1898 = _t1900 else: - if prediction1087 == 1: - _t1896 = self.parse_min_monoid() - min_monoid1089 = _t1896 - _t1897 = logic_pb2.Monoid(min_monoid=min_monoid1089) - _t1895 = _t1897 + if prediction1090 == 1: + _t1902 = self.parse_min_monoid() + min_monoid1092 = _t1902 + _t1903 = logic_pb2.Monoid(min_monoid=min_monoid1092) + _t1901 = _t1903 else: - if prediction1087 == 0: - _t1899 = self.parse_or_monoid() - or_monoid1088 = _t1899 - _t1900 = logic_pb2.Monoid(or_monoid=or_monoid1088) - _t1898 = _t1900 + if prediction1090 == 0: + _t1905 = self.parse_or_monoid() + or_monoid1091 = _t1905 + _t1906 = logic_pb2.Monoid(or_monoid=or_monoid1091) + _t1904 = _t1906 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1895 = _t1898 - _t1892 = _t1895 - _t1889 = _t1892 - result1093 = _t1889 - self.record_span(span_start1092, "Monoid") - return result1093 + _t1901 = _t1904 + _t1898 = _t1901 + _t1895 = _t1898 + result1096 = _t1895 + self.record_span(span_start1095, "Monoid") + return result1096 def parse_or_monoid(self) -> logic_pb2.OrMonoid: - span_start1094 = self.span_start() + span_start1097 = self.span_start() self.consume_literal("(") self.consume_literal("or") self.consume_literal(")") - _t1901 = logic_pb2.OrMonoid() - result1095 = _t1901 - self.record_span(span_start1094, "OrMonoid") - return result1095 + _t1907 = logic_pb2.OrMonoid() + result1098 = _t1907 + self.record_span(span_start1097, "OrMonoid") + return result1098 def parse_min_monoid(self) -> logic_pb2.MinMonoid: - span_start1097 = self.span_start() + span_start1100 = self.span_start() self.consume_literal("(") self.consume_literal("min") - _t1902 = self.parse_type() - type1096 = _t1902 + _t1908 = self.parse_type() + type1099 = _t1908 self.consume_literal(")") - _t1903 = logic_pb2.MinMonoid(type=type1096) - result1098 = _t1903 - self.record_span(span_start1097, "MinMonoid") - return result1098 + _t1909 = logic_pb2.MinMonoid(type=type1099) + result1101 = _t1909 + self.record_span(span_start1100, "MinMonoid") + return result1101 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: - span_start1100 = self.span_start() + span_start1103 = self.span_start() self.consume_literal("(") self.consume_literal("max") - _t1904 = self.parse_type() - type1099 = _t1904 + _t1910 = self.parse_type() + type1102 = _t1910 self.consume_literal(")") - _t1905 = logic_pb2.MaxMonoid(type=type1099) - result1101 = _t1905 - self.record_span(span_start1100, "MaxMonoid") - return result1101 + _t1911 = logic_pb2.MaxMonoid(type=type1102) + result1104 = _t1911 + self.record_span(span_start1103, "MaxMonoid") + return result1104 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: - span_start1103 = self.span_start() + span_start1106 = self.span_start() self.consume_literal("(") self.consume_literal("sum") - _t1906 = self.parse_type() - type1102 = _t1906 + _t1912 = self.parse_type() + type1105 = _t1912 self.consume_literal(")") - _t1907 = logic_pb2.SumMonoid(type=type1102) - result1104 = _t1907 - self.record_span(span_start1103, "SumMonoid") - return result1104 + _t1913 = logic_pb2.SumMonoid(type=type1105) + result1107 = _t1913 + self.record_span(span_start1106, "SumMonoid") + return result1107 def parse_monus_def(self) -> logic_pb2.MonusDef: - span_start1109 = self.span_start() + span_start1112 = self.span_start() self.consume_literal("(") self.consume_literal("monus") - _t1908 = self.parse_monoid() - monoid1105 = _t1908 - _t1909 = self.parse_relation_id() - relation_id1106 = _t1909 - _t1910 = self.parse_abstraction_with_arity() - abstraction_with_arity1107 = _t1910 + _t1914 = self.parse_monoid() + monoid1108 = _t1914 + _t1915 = self.parse_relation_id() + relation_id1109 = _t1915 + _t1916 = self.parse_abstraction_with_arity() + abstraction_with_arity1110 = _t1916 if self.match_lookahead_literal("(", 0): - _t1912 = self.parse_attrs() - _t1911 = _t1912 + _t1918 = self.parse_attrs() + _t1917 = _t1918 else: - _t1911 = None - attrs1108 = _t1911 + _t1917 = None + attrs1111 = _t1917 self.consume_literal(")") - _t1913 = logic_pb2.MonusDef(monoid=monoid1105, name=relation_id1106, body=abstraction_with_arity1107[0], attrs=(attrs1108 if attrs1108 is not None else []), value_arity=abstraction_with_arity1107[1]) - result1110 = _t1913 - self.record_span(span_start1109, "MonusDef") - return result1110 + _t1919 = logic_pb2.MonusDef(monoid=monoid1108, name=relation_id1109, body=abstraction_with_arity1110[0], attrs=(attrs1111 if attrs1111 is not None else []), value_arity=abstraction_with_arity1110[1]) + result1113 = _t1919 + self.record_span(span_start1112, "MonusDef") + return result1113 def parse_constraint(self) -> logic_pb2.Constraint: - span_start1115 = self.span_start() + span_start1118 = self.span_start() self.consume_literal("(") self.consume_literal("functional_dependency") - _t1914 = self.parse_relation_id() - relation_id1111 = _t1914 - _t1915 = self.parse_abstraction() - abstraction1112 = _t1915 - _t1916 = self.parse_functional_dependency_keys() - functional_dependency_keys1113 = _t1916 - _t1917 = self.parse_functional_dependency_values() - functional_dependency_values1114 = _t1917 - self.consume_literal(")") - _t1918 = logic_pb2.FunctionalDependency(guard=abstraction1112, keys=functional_dependency_keys1113, values=functional_dependency_values1114) - _t1919 = logic_pb2.Constraint(name=relation_id1111, functional_dependency=_t1918) - result1116 = _t1919 - self.record_span(span_start1115, "Constraint") - return result1116 + _t1920 = self.parse_relation_id() + relation_id1114 = _t1920 + _t1921 = self.parse_abstraction() + abstraction1115 = _t1921 + _t1922 = self.parse_functional_dependency_keys() + functional_dependency_keys1116 = _t1922 + _t1923 = self.parse_functional_dependency_values() + functional_dependency_values1117 = _t1923 + self.consume_literal(")") + _t1924 = logic_pb2.FunctionalDependency(guard=abstraction1115, keys=functional_dependency_keys1116, values=functional_dependency_values1117) + _t1925 = logic_pb2.Constraint(name=relation_id1114, functional_dependency=_t1924) + result1119 = _t1925 + self.record_span(span_start1118, "Constraint") + return result1119 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") - xs1117 = [] - cond1118 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1118: - _t1920 = self.parse_var() - item1119 = _t1920 - xs1117.append(item1119) - cond1118 = self.match_lookahead_terminal("SYMBOL", 0) - vars1120 = xs1117 + xs1120 = [] + cond1121 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1121: + _t1926 = self.parse_var() + item1122 = _t1926 + xs1120.append(item1122) + cond1121 = self.match_lookahead_terminal("SYMBOL", 0) + vars1123 = xs1120 self.consume_literal(")") - return vars1120 + return vars1123 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - xs1121 = [] - cond1122 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1122: - _t1921 = self.parse_var() - item1123 = _t1921 - xs1121.append(item1123) - cond1122 = self.match_lookahead_terminal("SYMBOL", 0) - vars1124 = xs1121 + xs1124 = [] + cond1125 = self.match_lookahead_terminal("SYMBOL", 0) + while cond1125: + _t1927 = self.parse_var() + item1126 = _t1927 + xs1124.append(item1126) + cond1125 = self.match_lookahead_terminal("SYMBOL", 0) + vars1127 = xs1124 self.consume_literal(")") - return vars1124 + return vars1127 def parse_data(self) -> logic_pb2.Data: - span_start1130 = self.span_start() + span_start1133 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1923 = 3 + _t1929 = 3 else: if self.match_lookahead_literal("edb", 1): - _t1924 = 0 + _t1930 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1925 = 2 + _t1931 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t1926 = 1 + _t1932 = 1 else: - _t1926 = -1 - _t1925 = _t1926 - _t1924 = _t1925 - _t1923 = _t1924 - _t1922 = _t1923 - else: - _t1922 = -1 - prediction1125 = _t1922 - if prediction1125 == 3: - _t1928 = self.parse_iceberg_data() - iceberg_data1129 = _t1928 - _t1929 = logic_pb2.Data(iceberg_data=iceberg_data1129) - _t1927 = _t1929 - else: - if prediction1125 == 2: - _t1931 = self.parse_csv_data() - csv_data1128 = _t1931 - _t1932 = logic_pb2.Data(csv_data=csv_data1128) - _t1930 = _t1932 + _t1932 = -1 + _t1931 = _t1932 + _t1930 = _t1931 + _t1929 = _t1930 + _t1928 = _t1929 + else: + _t1928 = -1 + prediction1128 = _t1928 + if prediction1128 == 3: + _t1934 = self.parse_iceberg_data() + iceberg_data1132 = _t1934 + _t1935 = logic_pb2.Data(iceberg_data=iceberg_data1132) + _t1933 = _t1935 + else: + if prediction1128 == 2: + _t1937 = self.parse_csv_data() + csv_data1131 = _t1937 + _t1938 = logic_pb2.Data(csv_data=csv_data1131) + _t1936 = _t1938 else: - if prediction1125 == 1: - _t1934 = self.parse_betree_relation() - betree_relation1127 = _t1934 - _t1935 = logic_pb2.Data(betree_relation=betree_relation1127) - _t1933 = _t1935 + if prediction1128 == 1: + _t1940 = self.parse_betree_relation() + betree_relation1130 = _t1940 + _t1941 = logic_pb2.Data(betree_relation=betree_relation1130) + _t1939 = _t1941 else: - if prediction1125 == 0: - _t1937 = self.parse_edb() - edb1126 = _t1937 - _t1938 = logic_pb2.Data(edb=edb1126) - _t1936 = _t1938 + if prediction1128 == 0: + _t1943 = self.parse_edb() + edb1129 = _t1943 + _t1944 = logic_pb2.Data(edb=edb1129) + _t1942 = _t1944 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1933 = _t1936 - _t1930 = _t1933 - _t1927 = _t1930 - result1131 = _t1927 - self.record_span(span_start1130, "Data") - return result1131 + _t1939 = _t1942 + _t1936 = _t1939 + _t1933 = _t1936 + result1134 = _t1933 + self.record_span(span_start1133, "Data") + return result1134 def parse_edb(self) -> logic_pb2.EDB: - span_start1135 = self.span_start() + span_start1138 = self.span_start() self.consume_literal("(") self.consume_literal("edb") - _t1939 = self.parse_relation_id() - relation_id1132 = _t1939 - _t1940 = self.parse_edb_path() - edb_path1133 = _t1940 - _t1941 = self.parse_edb_types() - edb_types1134 = _t1941 - self.consume_literal(")") - _t1942 = logic_pb2.EDB(target_id=relation_id1132, path=edb_path1133, types=edb_types1134) - result1136 = _t1942 - self.record_span(span_start1135, "EDB") - return result1136 + _t1945 = self.parse_relation_id() + relation_id1135 = _t1945 + _t1946 = self.parse_edb_path() + edb_path1136 = _t1946 + _t1947 = self.parse_edb_types() + edb_types1137 = _t1947 + self.consume_literal(")") + _t1948 = logic_pb2.EDB(target_id=relation_id1135, path=edb_path1136, types=edb_types1137) + result1139 = _t1948 + self.record_span(span_start1138, "EDB") + return result1139 def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs1137 = [] - cond1138 = self.match_lookahead_terminal("STRING", 0) - while cond1138: - item1139 = self.consume_terminal("STRING") - xs1137.append(item1139) - cond1138 = self.match_lookahead_terminal("STRING", 0) - strings1140 = xs1137 + xs1140 = [] + cond1141 = self.match_lookahead_terminal("STRING", 0) + while cond1141: + item1142 = self.consume_terminal("STRING") + xs1140.append(item1142) + cond1141 = self.match_lookahead_terminal("STRING", 0) + strings1143 = xs1140 self.consume_literal("]") - return strings1140 + return strings1143 def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs1141 = [] - cond1142 = (((((((((((((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 cond1142: - _t1943 = self.parse_type() - item1143 = _t1943 - xs1141.append(item1143) - cond1142 = (((((((((((((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)) - types1144 = xs1141 + xs1144 = [] + cond1145 = (((((((((((((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 cond1145: + _t1949 = self.parse_type() + item1146 = _t1949 + xs1144.append(item1146) + cond1145 = (((((((((((((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)) + types1147 = xs1144 self.consume_literal("]") - return types1144 + return types1147 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: - span_start1147 = self.span_start() + span_start1150 = self.span_start() self.consume_literal("(") self.consume_literal("betree_relation") - _t1944 = self.parse_relation_id() - relation_id1145 = _t1944 - _t1945 = self.parse_betree_info() - betree_info1146 = _t1945 + _t1950 = self.parse_relation_id() + relation_id1148 = _t1950 + _t1951 = self.parse_betree_info() + betree_info1149 = _t1951 self.consume_literal(")") - _t1946 = logic_pb2.BeTreeRelation(name=relation_id1145, relation_info=betree_info1146) - result1148 = _t1946 - self.record_span(span_start1147, "BeTreeRelation") - return result1148 + _t1952 = logic_pb2.BeTreeRelation(name=relation_id1148, relation_info=betree_info1149) + result1151 = _t1952 + self.record_span(span_start1150, "BeTreeRelation") + return result1151 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1152 = self.span_start() + span_start1155 = self.span_start() self.consume_literal("(") self.consume_literal("betree_info") - _t1947 = self.parse_betree_info_key_types() - betree_info_key_types1149 = _t1947 - _t1948 = self.parse_betree_info_value_types() - betree_info_value_types1150 = _t1948 - _t1949 = self.parse_config_dict() - config_dict1151 = _t1949 - self.consume_literal(")") - _t1950 = self.construct_betree_info(betree_info_key_types1149, betree_info_value_types1150, config_dict1151) - result1153 = _t1950 - self.record_span(span_start1152, "BeTreeInfo") - return result1153 + _t1953 = self.parse_betree_info_key_types() + betree_info_key_types1152 = _t1953 + _t1954 = self.parse_betree_info_value_types() + betree_info_value_types1153 = _t1954 + _t1955 = self.parse_config_dict() + config_dict1154 = _t1955 + self.consume_literal(")") + _t1956 = self.construct_betree_info(betree_info_key_types1152, betree_info_value_types1153, config_dict1154) + result1156 = _t1956 + self.record_span(span_start1155, "BeTreeInfo") + return result1156 def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - xs1154 = [] - cond1155 = (((((((((((((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 cond1155: - _t1951 = self.parse_type() - item1156 = _t1951 - xs1154.append(item1156) - cond1155 = (((((((((((((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)) - types1157 = xs1154 + xs1157 = [] + cond1158 = (((((((((((((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 cond1158: + _t1957 = self.parse_type() + item1159 = _t1957 + xs1157.append(item1159) + cond1158 = (((((((((((((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)) + types1160 = xs1157 self.consume_literal(")") - return types1157 + return types1160 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - xs1158 = [] - cond1159 = (((((((((((((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 cond1159: - _t1952 = self.parse_type() - item1160 = _t1952 - xs1158.append(item1160) - cond1159 = (((((((((((((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)) - types1161 = xs1158 + xs1161 = [] + cond1162 = (((((((((((((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 cond1162: + _t1958 = self.parse_type() + item1163 = _t1958 + xs1161.append(item1163) + cond1162 = (((((((((((((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)) + types1164 = xs1161 self.consume_literal(")") - return types1161 + return types1164 def parse_csv_data(self) -> logic_pb2.CSVData: - span_start1166 = self.span_start() + span_start1169 = self.span_start() self.consume_literal("(") self.consume_literal("csv_data") - _t1953 = self.parse_csvlocator() - csvlocator1162 = _t1953 - _t1954 = self.parse_csv_config() - csv_config1163 = _t1954 - _t1955 = self.parse_gnf_columns() - gnf_columns1164 = _t1955 - _t1956 = self.parse_csv_asof() - csv_asof1165 = _t1956 - self.consume_literal(")") - _t1957 = logic_pb2.CSVData(locator=csvlocator1162, config=csv_config1163, columns=gnf_columns1164, asof=csv_asof1165) - result1167 = _t1957 - self.record_span(span_start1166, "CSVData") - return result1167 + _t1959 = self.parse_csvlocator() + csvlocator1165 = _t1959 + _t1960 = self.parse_csv_config() + csv_config1166 = _t1960 + _t1961 = self.parse_gnf_columns() + gnf_columns1167 = _t1961 + _t1962 = self.parse_csv_asof() + csv_asof1168 = _t1962 + self.consume_literal(")") + _t1963 = logic_pb2.CSVData(locator=csvlocator1165, config=csv_config1166, columns=gnf_columns1167, asof=csv_asof1168) + result1170 = _t1963 + self.record_span(span_start1169, "CSVData") + return result1170 def parse_csvlocator(self) -> logic_pb2.CSVLocator: - span_start1170 = self.span_start() + span_start1173 = self.span_start() self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t1959 = self.parse_csv_locator_paths() - _t1958 = _t1959 + _t1965 = self.parse_csv_locator_paths() + _t1964 = _t1965 else: - _t1958 = None - csv_locator_paths1168 = _t1958 + _t1964 = None + csv_locator_paths1171 = _t1964 if self.match_lookahead_literal("(", 0): - _t1961 = self.parse_csv_locator_inline_data() - _t1960 = _t1961 + _t1967 = self.parse_csv_locator_inline_data() + _t1966 = _t1967 else: - _t1960 = None - csv_locator_inline_data1169 = _t1960 + _t1966 = None + csv_locator_inline_data1172 = _t1966 self.consume_literal(")") - _t1962 = logic_pb2.CSVLocator(paths=(csv_locator_paths1168 if csv_locator_paths1168 is not None else []), inline_data=(csv_locator_inline_data1169 if csv_locator_inline_data1169 is not None else "").encode()) - result1171 = _t1962 - self.record_span(span_start1170, "CSVLocator") - return result1171 + _t1968 = logic_pb2.CSVLocator(paths=(csv_locator_paths1171 if csv_locator_paths1171 is not None else []), inline_data=(csv_locator_inline_data1172 if csv_locator_inline_data1172 is not None else "").encode()) + result1174 = _t1968 + self.record_span(span_start1173, "CSVLocator") + return result1174 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") - xs1172 = [] - cond1173 = self.match_lookahead_terminal("STRING", 0) - while cond1173: - item1174 = self.consume_terminal("STRING") - xs1172.append(item1174) - cond1173 = self.match_lookahead_terminal("STRING", 0) - strings1175 = xs1172 + xs1175 = [] + cond1176 = self.match_lookahead_terminal("STRING", 0) + while cond1176: + item1177 = self.consume_terminal("STRING") + xs1175.append(item1177) + cond1176 = self.match_lookahead_terminal("STRING", 0) + strings1178 = xs1175 self.consume_literal(")") - return strings1175 + return strings1178 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - formatted_string1176 = self.consume_terminal("STRING") + formatted_string1179 = self.consume_terminal("STRING") self.consume_literal(")") - return formatted_string1176 + return formatted_string1179 def parse_csv_config(self) -> logic_pb2.CSVConfig: - span_start1179 = self.span_start() + span_start1182 = self.span_start() self.consume_literal("(") self.consume_literal("csv_config") - _t1963 = self.parse_config_dict() - config_dict1177 = _t1963 + _t1969 = self.parse_config_dict() + config_dict1180 = _t1969 if self.match_lookahead_literal("(", 0): - _t1965 = self.parse__storage_integration() - _t1964 = _t1965 + _t1971 = self.parse__storage_integration() + _t1970 = _t1971 else: - _t1964 = None - _storage_integration1178 = _t1964 + _t1970 = None + _storage_integration1181 = _t1970 self.consume_literal(")") - _t1966 = self.construct_csv_config(config_dict1177, _storage_integration1178) - result1180 = _t1966 - self.record_span(span_start1179, "CSVConfig") - return result1180 + _t1972 = self.construct_csv_config(config_dict1180, _storage_integration1181) + result1183 = _t1972 + self.record_span(span_start1182, "CSVConfig") + return result1183 def parse__storage_integration(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("(") self.consume_literal("storage_integration") - _t1967 = self.parse_config_dict() - config_dict1181 = _t1967 + _t1973 = self.parse_config_dict() + config_dict1184 = _t1973 self.consume_literal(")") - return config_dict1181 + return config_dict1184 def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1182 = [] - cond1183 = self.match_lookahead_literal("(", 0) - while cond1183: - _t1968 = self.parse_gnf_column() - item1184 = _t1968 - xs1182.append(item1184) - cond1183 = self.match_lookahead_literal("(", 0) - gnf_columns1185 = xs1182 + xs1185 = [] + cond1186 = self.match_lookahead_literal("(", 0) + while cond1186: + _t1974 = self.parse_gnf_column() + item1187 = _t1974 + xs1185.append(item1187) + cond1186 = self.match_lookahead_literal("(", 0) + gnf_columns1188 = xs1185 self.consume_literal(")") - return gnf_columns1185 + return gnf_columns1188 def parse_gnf_column(self) -> logic_pb2.GNFColumn: - span_start1192 = self.span_start() + span_start1195 = self.span_start() self.consume_literal("(") self.consume_literal("column") - _t1969 = self.parse_gnf_column_path() - gnf_column_path1186 = _t1969 + _t1975 = self.parse_gnf_column_path() + gnf_column_path1189 = _t1975 if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t1971 = self.parse_relation_id() - _t1970 = _t1971 + _t1977 = self.parse_relation_id() + _t1976 = _t1977 else: - _t1970 = None - relation_id1187 = _t1970 + _t1976 = None + relation_id1190 = _t1976 self.consume_literal("[") - xs1188 = [] - cond1189 = (((((((((((((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 cond1189: - _t1972 = self.parse_type() - item1190 = _t1972 - xs1188.append(item1190) - cond1189 = (((((((((((((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)) - types1191 = xs1188 + xs1191 = [] + cond1192 = (((((((((((((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 cond1192: + _t1978 = self.parse_type() + item1193 = _t1978 + xs1191.append(item1193) + cond1192 = (((((((((((((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)) + types1194 = xs1191 self.consume_literal("]") self.consume_literal(")") - _t1973 = logic_pb2.GNFColumn(column_path=gnf_column_path1186, target_id=relation_id1187, types=types1191) - result1193 = _t1973 - self.record_span(span_start1192, "GNFColumn") - return result1193 + _t1979 = logic_pb2.GNFColumn(column_path=gnf_column_path1189, target_id=relation_id1190, types=types1194) + result1196 = _t1979 + self.record_span(span_start1195, "GNFColumn") + return result1196 def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t1974 = 1 + _t1980 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1975 = 0 + _t1981 = 0 else: - _t1975 = -1 - _t1974 = _t1975 - prediction1194 = _t1974 - if prediction1194 == 1: + _t1981 = -1 + _t1980 = _t1981 + prediction1197 = _t1980 + if prediction1197 == 1: self.consume_literal("[") - xs1196 = [] - cond1197 = self.match_lookahead_terminal("STRING", 0) - while cond1197: - item1198 = self.consume_terminal("STRING") - xs1196.append(item1198) - cond1197 = self.match_lookahead_terminal("STRING", 0) - strings1199 = xs1196 + xs1199 = [] + cond1200 = self.match_lookahead_terminal("STRING", 0) + while cond1200: + item1201 = self.consume_terminal("STRING") + xs1199.append(item1201) + cond1200 = self.match_lookahead_terminal("STRING", 0) + strings1202 = xs1199 self.consume_literal("]") - _t1976 = strings1199 + _t1982 = strings1202 else: - if prediction1194 == 0: - string1195 = self.consume_terminal("STRING") - _t1977 = [string1195] + if prediction1197 == 0: + string1198 = self.consume_terminal("STRING") + _t1983 = [string1198] else: raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1976 = _t1977 - return _t1976 + _t1982 = _t1983 + return _t1982 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - string1200 = self.consume_terminal("STRING") + string1203 = self.consume_terminal("STRING") self.consume_literal(")") - return string1200 + return string1203 def parse_iceberg_data(self) -> logic_pb2.IcebergData: - span_start1207 = self.span_start() + span_start1210 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_data") - _t1978 = self.parse_iceberg_locator() - iceberg_locator1201 = _t1978 - _t1979 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1202 = _t1979 - _t1980 = self.parse_gnf_columns() - gnf_columns1203 = _t1980 + _t1984 = self.parse_iceberg_locator() + iceberg_locator1204 = _t1984 + _t1985 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1205 = _t1985 + _t1986 = self.parse_gnf_columns() + gnf_columns1206 = _t1986 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("from_snapshot", 1)): - _t1982 = self.parse_iceberg_from_snapshot() - _t1981 = _t1982 + _t1988 = self.parse_iceberg_from_snapshot() + _t1987 = _t1988 else: - _t1981 = None - iceberg_from_snapshot1204 = _t1981 + _t1987 = None + iceberg_from_snapshot1207 = _t1987 if self.match_lookahead_literal("(", 0): - _t1984 = self.parse_iceberg_to_snapshot() - _t1983 = _t1984 + _t1990 = self.parse_iceberg_to_snapshot() + _t1989 = _t1990 else: - _t1983 = None - iceberg_to_snapshot1205 = _t1983 - _t1985 = self.parse_boolean_value() - boolean_value1206 = _t1985 + _t1989 = None + iceberg_to_snapshot1208 = _t1989 + _t1991 = self.parse_boolean_value() + boolean_value1209 = _t1991 self.consume_literal(")") - _t1986 = self.construct_iceberg_data(iceberg_locator1201, iceberg_catalog_config1202, gnf_columns1203, iceberg_from_snapshot1204, iceberg_to_snapshot1205, boolean_value1206) - result1208 = _t1986 - self.record_span(span_start1207, "IcebergData") - return result1208 + _t1992 = self.construct_iceberg_data(iceberg_locator1204, iceberg_catalog_config1205, gnf_columns1206, iceberg_from_snapshot1207, iceberg_to_snapshot1208, boolean_value1209) + result1211 = _t1992 + self.record_span(span_start1210, "IcebergData") + return result1211 def parse_iceberg_locator(self) -> logic_pb2.IcebergLocator: - span_start1212 = self.span_start() + span_start1215 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_locator") - _t1987 = self.parse_iceberg_locator_table_name() - iceberg_locator_table_name1209 = _t1987 - _t1988 = self.parse_iceberg_locator_namespace() - iceberg_locator_namespace1210 = _t1988 - _t1989 = self.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1211 = _t1989 - self.consume_literal(")") - _t1990 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1209, namespace=iceberg_locator_namespace1210, warehouse=iceberg_locator_warehouse1211) - result1213 = _t1990 - self.record_span(span_start1212, "IcebergLocator") - return result1213 + _t1993 = self.parse_iceberg_locator_table_name() + iceberg_locator_table_name1212 = _t1993 + _t1994 = self.parse_iceberg_locator_namespace() + iceberg_locator_namespace1213 = _t1994 + _t1995 = self.parse_iceberg_locator_warehouse() + iceberg_locator_warehouse1214 = _t1995 + self.consume_literal(")") + _t1996 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1212, namespace=iceberg_locator_namespace1213, warehouse=iceberg_locator_warehouse1214) + result1216 = _t1996 + self.record_span(span_start1215, "IcebergLocator") + return result1216 def parse_iceberg_locator_table_name(self) -> str: self.consume_literal("(") self.consume_literal("table_name") - string1214 = self.consume_terminal("STRING") + string1217 = self.consume_terminal("STRING") self.consume_literal(")") - return string1214 + return string1217 def parse_iceberg_locator_namespace(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("namespace") - 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 + xs1218 = [] + cond1219 = self.match_lookahead_terminal("STRING", 0) + while cond1219: + item1220 = self.consume_terminal("STRING") + xs1218.append(item1220) + cond1219 = self.match_lookahead_terminal("STRING", 0) + strings1221 = xs1218 self.consume_literal(")") - return strings1218 + return strings1221 def parse_iceberg_locator_warehouse(self) -> str: self.consume_literal("(") self.consume_literal("warehouse") - string1219 = self.consume_terminal("STRING") + string1222 = self.consume_terminal("STRING") self.consume_literal(")") - return string1219 + return string1222 def parse_iceberg_catalog_config(self) -> logic_pb2.IcebergCatalogConfig: - span_start1224 = self.span_start() + span_start1227 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_catalog_config") - _t1991 = self.parse_iceberg_catalog_uri() - iceberg_catalog_uri1220 = _t1991 + _t1997 = self.parse_iceberg_catalog_uri() + iceberg_catalog_uri1223 = _t1997 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("scope", 1)): - _t1993 = self.parse_iceberg_catalog_config_scope() - _t1992 = _t1993 + _t1999 = self.parse_iceberg_catalog_config_scope() + _t1998 = _t1999 else: - _t1992 = None - iceberg_catalog_config_scope1221 = _t1992 - _t1994 = self.parse_iceberg_properties() - iceberg_properties1222 = _t1994 - _t1995 = self.parse_iceberg_auth_properties() - iceberg_auth_properties1223 = _t1995 + _t1998 = None + iceberg_catalog_config_scope1224 = _t1998 + _t2000 = self.parse_iceberg_properties() + iceberg_properties1225 = _t2000 + _t2001 = self.parse_iceberg_auth_properties() + iceberg_auth_properties1226 = _t2001 self.consume_literal(")") - _t1996 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1220, iceberg_catalog_config_scope1221, iceberg_properties1222, iceberg_auth_properties1223) - result1225 = _t1996 - self.record_span(span_start1224, "IcebergCatalogConfig") - return result1225 + _t2002 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1223, iceberg_catalog_config_scope1224, iceberg_properties1225, iceberg_auth_properties1226) + result1228 = _t2002 + self.record_span(span_start1227, "IcebergCatalogConfig") + return result1228 def parse_iceberg_catalog_uri(self) -> str: self.consume_literal("(") self.consume_literal("catalog_uri") - string1226 = self.consume_terminal("STRING") + string1229 = self.consume_terminal("STRING") self.consume_literal(")") - return string1226 + return string1229 def parse_iceberg_catalog_config_scope(self) -> str: self.consume_literal("(") self.consume_literal("scope") - string1227 = self.consume_terminal("STRING") + string1230 = self.consume_terminal("STRING") self.consume_literal(")") - return string1227 + return string1230 def parse_iceberg_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("properties") - xs1228 = [] - cond1229 = self.match_lookahead_literal("(", 0) - while cond1229: - _t1997 = self.parse_iceberg_property_entry() - item1230 = _t1997 - xs1228.append(item1230) - cond1229 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1231 = xs1228 + xs1231 = [] + cond1232 = self.match_lookahead_literal("(", 0) + while cond1232: + _t2003 = self.parse_iceberg_property_entry() + item1233 = _t2003 + xs1231.append(item1233) + cond1232 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1234 = xs1231 self.consume_literal(")") - return iceberg_property_entrys1231 + return iceberg_property_entrys1234 def parse_iceberg_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1232 = self.consume_terminal("STRING") - string_31233 = self.consume_terminal("STRING") + string1235 = self.consume_terminal("STRING") + string_31236 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1232, string_31233,) + return (string1235, string_31236,) def parse_iceberg_auth_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("auth_properties") - xs1234 = [] - cond1235 = self.match_lookahead_literal("(", 0) - while cond1235: - _t1998 = self.parse_iceberg_masked_property_entry() - item1236 = _t1998 - xs1234.append(item1236) - cond1235 = self.match_lookahead_literal("(", 0) - iceberg_masked_property_entrys1237 = xs1234 + xs1237 = [] + cond1238 = self.match_lookahead_literal("(", 0) + while cond1238: + _t2004 = self.parse_iceberg_masked_property_entry() + item1239 = _t2004 + xs1237.append(item1239) + cond1238 = self.match_lookahead_literal("(", 0) + iceberg_masked_property_entrys1240 = xs1237 self.consume_literal(")") - return iceberg_masked_property_entrys1237 + return iceberg_masked_property_entrys1240 def parse_iceberg_masked_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1238 = self.consume_terminal("STRING") - string_31239 = self.consume_terminal("STRING") + string1241 = self.consume_terminal("STRING") + string_31242 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1238, string_31239,) + return (string1241, string_31242,) def parse_iceberg_from_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("from_snapshot") - string1240 = self.consume_terminal("STRING") + string1243 = self.consume_terminal("STRING") self.consume_literal(")") - return string1240 + return string1243 def parse_iceberg_to_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("to_snapshot") - string1241 = self.consume_terminal("STRING") + string1244 = self.consume_terminal("STRING") self.consume_literal(")") - return string1241 + return string1244 def parse_undefine(self) -> transactions_pb2.Undefine: - span_start1243 = self.span_start() + span_start1246 = self.span_start() self.consume_literal("(") self.consume_literal("undefine") - _t1999 = self.parse_fragment_id() - fragment_id1242 = _t1999 + _t2005 = self.parse_fragment_id() + fragment_id1245 = _t2005 self.consume_literal(")") - _t2000 = transactions_pb2.Undefine(fragment_id=fragment_id1242) - result1244 = _t2000 - self.record_span(span_start1243, "Undefine") - return result1244 + _t2006 = transactions_pb2.Undefine(fragment_id=fragment_id1245) + result1247 = _t2006 + self.record_span(span_start1246, "Undefine") + return result1247 def parse_context(self) -> transactions_pb2.Context: - span_start1249 = self.span_start() + span_start1252 = self.span_start() self.consume_literal("(") self.consume_literal("context") - xs1245 = [] - cond1246 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1246: - _t2001 = self.parse_relation_id() - item1247 = _t2001 - xs1245.append(item1247) - cond1246 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1248 = xs1245 - self.consume_literal(")") - _t2002 = transactions_pb2.Context(relations=relation_ids1248) - result1250 = _t2002 - self.record_span(span_start1249, "Context") - return result1250 + xs1248 = [] + cond1249 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + while cond1249: + _t2007 = self.parse_relation_id() + item1250 = _t2007 + xs1248.append(item1250) + cond1249 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) + relation_ids1251 = xs1248 + self.consume_literal(")") + _t2008 = transactions_pb2.Context(relations=relation_ids1251) + result1253 = _t2008 + self.record_span(span_start1252, "Context") + return result1253 def parse_snapshot(self) -> transactions_pb2.Snapshot: - span_start1256 = self.span_start() + span_start1259 = self.span_start() self.consume_literal("(") self.consume_literal("snapshot") - _t2003 = self.parse_edb_path() - edb_path1251 = _t2003 - xs1252 = [] - cond1253 = self.match_lookahead_literal("[", 0) - while cond1253: - _t2004 = self.parse_snapshot_mapping() - item1254 = _t2004 - xs1252.append(item1254) - cond1253 = self.match_lookahead_literal("[", 0) - snapshot_mappings1255 = xs1252 - self.consume_literal(")") - _t2005 = transactions_pb2.Snapshot(prefix=edb_path1251, mappings=snapshot_mappings1255) - result1257 = _t2005 - self.record_span(span_start1256, "Snapshot") - return result1257 + _t2009 = self.parse_edb_path() + edb_path1254 = _t2009 + xs1255 = [] + cond1256 = self.match_lookahead_literal("[", 0) + while cond1256: + _t2010 = self.parse_snapshot_mapping() + item1257 = _t2010 + xs1255.append(item1257) + cond1256 = self.match_lookahead_literal("[", 0) + snapshot_mappings1258 = xs1255 + self.consume_literal(")") + _t2011 = transactions_pb2.Snapshot(prefix=edb_path1254, mappings=snapshot_mappings1258) + result1260 = _t2011 + self.record_span(span_start1259, "Snapshot") + return result1260 def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: - span_start1260 = self.span_start() - _t2006 = self.parse_edb_path() - edb_path1258 = _t2006 - _t2007 = self.parse_relation_id() - relation_id1259 = _t2007 - _t2008 = transactions_pb2.SnapshotMapping(destination_path=edb_path1258, source_relation=relation_id1259) - result1261 = _t2008 - self.record_span(span_start1260, "SnapshotMapping") - return result1261 + span_start1263 = self.span_start() + _t2012 = self.parse_edb_path() + edb_path1261 = _t2012 + _t2013 = self.parse_relation_id() + relation_id1262 = _t2013 + _t2014 = transactions_pb2.SnapshotMapping(destination_path=edb_path1261, source_relation=relation_id1262) + result1264 = _t2014 + self.record_span(span_start1263, "SnapshotMapping") + return result1264 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") - xs1262 = [] - cond1263 = self.match_lookahead_literal("(", 0) - while cond1263: - _t2009 = self.parse_read() - item1264 = _t2009 - xs1262.append(item1264) - cond1263 = self.match_lookahead_literal("(", 0) - reads1265 = xs1262 + xs1265 = [] + cond1266 = self.match_lookahead_literal("(", 0) + while cond1266: + _t2015 = self.parse_read() + item1267 = _t2015 + xs1265.append(item1267) + cond1266 = self.match_lookahead_literal("(", 0) + reads1268 = xs1265 self.consume_literal(")") - return reads1265 + return reads1268 def parse_read(self) -> transactions_pb2.Read: - span_start1272 = self.span_start() + span_start1275 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t2011 = 2 + _t2017 = 2 else: if self.match_lookahead_literal("output", 1): - _t2012 = 1 + _t2018 = 1 else: if self.match_lookahead_literal("export_iceberg", 1): - _t2013 = 4 + _t2019 = 4 else: if self.match_lookahead_literal("export", 1): - _t2014 = 4 + _t2020 = 4 else: if self.match_lookahead_literal("demand", 1): - _t2015 = 0 + _t2021 = 0 else: if self.match_lookahead_literal("abort", 1): - _t2016 = 3 + _t2022 = 3 else: - _t2016 = -1 - _t2015 = _t2016 - _t2014 = _t2015 - _t2013 = _t2014 - _t2012 = _t2013 - _t2011 = _t2012 - _t2010 = _t2011 - else: - _t2010 = -1 - prediction1266 = _t2010 - if prediction1266 == 4: - _t2018 = self.parse_export() - export1271 = _t2018 - _t2019 = transactions_pb2.Read(export=export1271) - _t2017 = _t2019 - else: - if prediction1266 == 3: - _t2021 = self.parse_abort() - abort1270 = _t2021 - _t2022 = transactions_pb2.Read(abort=abort1270) - _t2020 = _t2022 + _t2022 = -1 + _t2021 = _t2022 + _t2020 = _t2021 + _t2019 = _t2020 + _t2018 = _t2019 + _t2017 = _t2018 + _t2016 = _t2017 + else: + _t2016 = -1 + prediction1269 = _t2016 + if prediction1269 == 4: + _t2024 = self.parse_export() + export1274 = _t2024 + _t2025 = transactions_pb2.Read(export=export1274) + _t2023 = _t2025 + else: + if prediction1269 == 3: + _t2027 = self.parse_abort() + abort1273 = _t2027 + _t2028 = transactions_pb2.Read(abort=abort1273) + _t2026 = _t2028 else: - if prediction1266 == 2: - _t2024 = self.parse_what_if() - what_if1269 = _t2024 - _t2025 = transactions_pb2.Read(what_if=what_if1269) - _t2023 = _t2025 + if prediction1269 == 2: + _t2030 = self.parse_what_if() + what_if1272 = _t2030 + _t2031 = transactions_pb2.Read(what_if=what_if1272) + _t2029 = _t2031 else: - if prediction1266 == 1: - _t2027 = self.parse_output() - output1268 = _t2027 - _t2028 = transactions_pb2.Read(output=output1268) - _t2026 = _t2028 + if prediction1269 == 1: + _t2033 = self.parse_output() + output1271 = _t2033 + _t2034 = transactions_pb2.Read(output=output1271) + _t2032 = _t2034 else: - if prediction1266 == 0: - _t2030 = self.parse_demand() - demand1267 = _t2030 - _t2031 = transactions_pb2.Read(demand=demand1267) - _t2029 = _t2031 + if prediction1269 == 0: + _t2036 = self.parse_demand() + demand1270 = _t2036 + _t2037 = transactions_pb2.Read(demand=demand1270) + _t2035 = _t2037 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2026 = _t2029 - _t2023 = _t2026 - _t2020 = _t2023 - _t2017 = _t2020 - result1273 = _t2017 - self.record_span(span_start1272, "Read") - return result1273 + _t2032 = _t2035 + _t2029 = _t2032 + _t2026 = _t2029 + _t2023 = _t2026 + result1276 = _t2023 + self.record_span(span_start1275, "Read") + return result1276 def parse_demand(self) -> transactions_pb2.Demand: - span_start1275 = self.span_start() + span_start1278 = self.span_start() self.consume_literal("(") self.consume_literal("demand") - _t2032 = self.parse_relation_id() - relation_id1274 = _t2032 + _t2038 = self.parse_relation_id() + relation_id1277 = _t2038 self.consume_literal(")") - _t2033 = transactions_pb2.Demand(relation_id=relation_id1274) - result1276 = _t2033 - self.record_span(span_start1275, "Demand") - return result1276 + _t2039 = transactions_pb2.Demand(relation_id=relation_id1277) + result1279 = _t2039 + self.record_span(span_start1278, "Demand") + return result1279 def parse_output(self) -> transactions_pb2.Output: - span_start1279 = self.span_start() + span_start1282 = self.span_start() self.consume_literal("(") self.consume_literal("output") - _t2034 = self.parse_name() - name1277 = _t2034 - _t2035 = self.parse_relation_id() - relation_id1278 = _t2035 + _t2040 = self.parse_name() + name1280 = _t2040 + _t2041 = self.parse_relation_id() + relation_id1281 = _t2041 self.consume_literal(")") - _t2036 = transactions_pb2.Output(name=name1277, relation_id=relation_id1278) - result1280 = _t2036 - self.record_span(span_start1279, "Output") - return result1280 + _t2042 = transactions_pb2.Output(name=name1280, relation_id=relation_id1281) + result1283 = _t2042 + self.record_span(span_start1282, "Output") + return result1283 def parse_what_if(self) -> transactions_pb2.WhatIf: - span_start1283 = self.span_start() + span_start1286 = self.span_start() self.consume_literal("(") self.consume_literal("what_if") - _t2037 = self.parse_name() - name1281 = _t2037 - _t2038 = self.parse_epoch() - epoch1282 = _t2038 + _t2043 = self.parse_name() + name1284 = _t2043 + _t2044 = self.parse_epoch() + epoch1285 = _t2044 self.consume_literal(")") - _t2039 = transactions_pb2.WhatIf(branch=name1281, epoch=epoch1282) - result1284 = _t2039 - self.record_span(span_start1283, "WhatIf") - return result1284 + _t2045 = transactions_pb2.WhatIf(branch=name1284, epoch=epoch1285) + result1287 = _t2045 + self.record_span(span_start1286, "WhatIf") + return result1287 def parse_abort(self) -> transactions_pb2.Abort: - span_start1287 = self.span_start() + span_start1290 = self.span_start() self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t2041 = self.parse_name() - _t2040 = _t2041 + _t2047 = self.parse_name() + _t2046 = _t2047 else: - _t2040 = None - name1285 = _t2040 - _t2042 = self.parse_relation_id() - relation_id1286 = _t2042 + _t2046 = None + name1288 = _t2046 + _t2048 = self.parse_relation_id() + relation_id1289 = _t2048 self.consume_literal(")") - _t2043 = transactions_pb2.Abort(name=(name1285 if name1285 is not None else "abort"), relation_id=relation_id1286) - result1288 = _t2043 - self.record_span(span_start1287, "Abort") - return result1288 + _t2049 = transactions_pb2.Abort(name=(name1288 if name1288 is not None else "abort"), relation_id=relation_id1289) + result1291 = _t2049 + self.record_span(span_start1290, "Abort") + return result1291 def parse_export(self) -> transactions_pb2.Export: - span_start1292 = self.span_start() + span_start1295 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_iceberg", 1): - _t2045 = 1 + _t2051 = 1 else: if self.match_lookahead_literal("export", 1): - _t2046 = 0 + _t2052 = 0 else: - _t2046 = -1 - _t2045 = _t2046 - _t2044 = _t2045 + _t2052 = -1 + _t2051 = _t2052 + _t2050 = _t2051 else: - _t2044 = -1 - prediction1289 = _t2044 - if prediction1289 == 1: + _t2050 = -1 + prediction1292 = _t2050 + if prediction1292 == 1: self.consume_literal("(") self.consume_literal("export_iceberg") - _t2048 = self.parse_export_iceberg_config() - export_iceberg_config1291 = _t2048 + _t2054 = self.parse_export_iceberg_config() + export_iceberg_config1294 = _t2054 self.consume_literal(")") - _t2049 = transactions_pb2.Export(iceberg_config=export_iceberg_config1291) - _t2047 = _t2049 + _t2055 = transactions_pb2.Export(iceberg_config=export_iceberg_config1294) + _t2053 = _t2055 else: - if prediction1289 == 0: + if prediction1292 == 0: self.consume_literal("(") self.consume_literal("export") - _t2051 = self.parse_export_csv_config() - export_csv_config1290 = _t2051 + _t2057 = self.parse_export_csv_config() + export_csv_config1293 = _t2057 self.consume_literal(")") - _t2052 = transactions_pb2.Export(csv_config=export_csv_config1290) - _t2050 = _t2052 + _t2058 = transactions_pb2.Export(csv_config=export_csv_config1293) + _t2056 = _t2058 else: raise ParseError("Unexpected token in export" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2047 = _t2050 - result1293 = _t2047 - self.record_span(span_start1292, "Export") - return result1293 + _t2053 = _t2056 + result1296 = _t2053 + self.record_span(span_start1295, "Export") + return result1296 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1301 = self.span_start() + span_start1304 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2054 = 0 + _t2060 = 0 else: if self.match_lookahead_literal("export_csv_config", 1): - _t2055 = 1 + _t2061 = 1 else: - _t2055 = -1 - _t2054 = _t2055 - _t2053 = _t2054 + _t2061 = -1 + _t2060 = _t2061 + _t2059 = _t2060 else: - _t2053 = -1 - prediction1294 = _t2053 - if prediction1294 == 1: + _t2059 = -1 + prediction1297 = _t2059 + if prediction1297 == 1: self.consume_literal("(") self.consume_literal("export_csv_config") - _t2057 = self.parse_export_csv_path() - export_csv_path1298 = _t2057 - _t2058 = self.parse_export_csv_columns_list() - export_csv_columns_list1299 = _t2058 - _t2059 = self.parse_config_dict() - config_dict1300 = _t2059 + _t2063 = self.parse_export_csv_path() + export_csv_path1301 = _t2063 + _t2064 = self.parse_export_csv_columns_list() + export_csv_columns_list1302 = _t2064 + _t2065 = self.parse_config_dict() + config_dict1303 = _t2065 self.consume_literal(")") - _t2060 = self.construct_export_csv_config(export_csv_path1298, export_csv_columns_list1299, config_dict1300) - _t2056 = _t2060 + _t2066 = self.construct_export_csv_config(export_csv_path1301, export_csv_columns_list1302, config_dict1303) + _t2062 = _t2066 else: - if prediction1294 == 0: + if prediction1297 == 0: self.consume_literal("(") self.consume_literal("export_csv_config_v2") - _t2062 = self.parse_export_csv_path() - export_csv_path1295 = _t2062 - _t2063 = self.parse_export_csv_source() - export_csv_source1296 = _t2063 - _t2064 = self.parse_csv_config() - csv_config1297 = _t2064 + _t2068 = self.parse_export_csv_output_location() + export_csv_output_location1298 = _t2068 + _t2069 = self.parse_export_csv_source() + export_csv_source1299 = _t2069 + _t2070 = self.parse_csv_config() + csv_config1300 = _t2070 self.consume_literal(")") - _t2065 = self.construct_export_csv_config_with_source(export_csv_path1295, export_csv_source1296, csv_config1297) - _t2061 = _t2065 + _t2071 = self.construct_export_csv_config_with_location(export_csv_output_location1298, export_csv_source1299, csv_config1300) + _t2067 = _t2071 else: raise ParseError("Unexpected token in export_csv_config" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2056 = _t2061 - result1302 = _t2056 - self.record_span(span_start1301, "ExportCSVConfig") - return result1302 + _t2062 = _t2067 + result1305 = _t2062 + self.record_span(span_start1304, "ExportCSVConfig") + return result1305 - def parse_export_csv_path(self) -> str: - self.consume_literal("(") - self.consume_literal("path") - string1303 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1303 + 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): + _t2073 = 1 + else: + if self.match_lookahead_literal("path", 1): + _t2074 = 0 + else: + _t2074 = -1 + _t2073 = _t2074 + _t2072 = _t2073 + else: + _t2072 = -1 + prediction1306 = _t2072 + if prediction1306 == 1: + self.consume_literal("(") + self.consume_literal("transaction_output_name") + _t2076 = self.parse_name() + name1308 = _t2076 + self.consume_literal(")") + _t2075 = ("", name1308,) + else: + if prediction1306 == 0: + self.consume_literal("(") + self.consume_literal("path") + string1307 = self.consume_terminal("STRING") + self.consume_literal(")") + _t2077 = (string1307, "",) + else: + raise ParseError("Unexpected token in export_csv_output_location" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") + _t2075 = _t2077 + return _t2075 def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1310 = self.span_start() + span_start1315 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("table_def", 1): - _t2067 = 1 + _t2079 = 1 else: if self.match_lookahead_literal("gnf_columns", 1): - _t2068 = 0 + _t2080 = 0 else: - _t2068 = -1 - _t2067 = _t2068 - _t2066 = _t2067 + _t2080 = -1 + _t2079 = _t2080 + _t2078 = _t2079 else: - _t2066 = -1 - prediction1304 = _t2066 - if prediction1304 == 1: + _t2078 = -1 + prediction1309 = _t2078 + if prediction1309 == 1: self.consume_literal("(") self.consume_literal("table_def") - _t2070 = self.parse_relation_id() - relation_id1309 = _t2070 + _t2082 = self.parse_relation_id() + relation_id1314 = _t2082 self.consume_literal(")") - _t2071 = transactions_pb2.ExportCSVSource(table_def=relation_id1309) - _t2069 = _t2071 + _t2083 = transactions_pb2.ExportCSVSource(table_def=relation_id1314) + _t2081 = _t2083 else: - if prediction1304 == 0: + if prediction1309 == 0: self.consume_literal("(") self.consume_literal("gnf_columns") - xs1305 = [] - cond1306 = self.match_lookahead_literal("(", 0) - while cond1306: - _t2073 = self.parse_export_csv_column() - item1307 = _t2073 - xs1305.append(item1307) - cond1306 = self.match_lookahead_literal("(", 0) - export_csv_columns1308 = xs1305 + xs1310 = [] + cond1311 = self.match_lookahead_literal("(", 0) + while cond1311: + _t2085 = self.parse_export_csv_column() + item1312 = _t2085 + xs1310.append(item1312) + cond1311 = self.match_lookahead_literal("(", 0) + export_csv_columns1313 = xs1310 self.consume_literal(")") - _t2074 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1308) - _t2075 = transactions_pb2.ExportCSVSource(gnf_columns=_t2074) - _t2072 = _t2075 + _t2086 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1313) + _t2087 = transactions_pb2.ExportCSVSource(gnf_columns=_t2086) + _t2084 = _t2087 else: raise ParseError("Unexpected token in export_csv_source" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2069 = _t2072 - result1311 = _t2069 - self.record_span(span_start1310, "ExportCSVSource") - return result1311 + _t2081 = _t2084 + result1316 = _t2081 + self.record_span(span_start1315, "ExportCSVSource") + return result1316 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1314 = self.span_start() + span_start1319 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1312 = self.consume_terminal("STRING") - _t2076 = self.parse_relation_id() - relation_id1313 = _t2076 + string1317 = self.consume_terminal("STRING") + _t2088 = self.parse_relation_id() + relation_id1318 = _t2088 self.consume_literal(")") - _t2077 = transactions_pb2.ExportCSVColumn(column_name=string1312, column_data=relation_id1313) - result1315 = _t2077 - self.record_span(span_start1314, "ExportCSVColumn") - return result1315 + _t2089 = transactions_pb2.ExportCSVColumn(column_name=string1317, column_data=relation_id1318) + result1320 = _t2089 + self.record_span(span_start1319, "ExportCSVColumn") + return result1320 + + def parse_export_csv_path(self) -> str: + self.consume_literal("(") + self.consume_literal("path") + string1321 = self.consume_terminal("STRING") + self.consume_literal(")") + return string1321 def parse_export_csv_columns_list(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - xs1316 = [] - cond1317 = self.match_lookahead_literal("(", 0) - while cond1317: - _t2078 = self.parse_export_csv_column() - item1318 = _t2078 - xs1316.append(item1318) - cond1317 = self.match_lookahead_literal("(", 0) - export_csv_columns1319 = xs1316 + xs1322 = [] + cond1323 = self.match_lookahead_literal("(", 0) + while cond1323: + _t2090 = self.parse_export_csv_column() + item1324 = _t2090 + xs1322.append(item1324) + cond1323 = self.match_lookahead_literal("(", 0) + export_csv_columns1325 = xs1322 self.consume_literal(")") - return export_csv_columns1319 + return export_csv_columns1325 def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1325 = self.span_start() + span_start1331 = self.span_start() self.consume_literal("(") self.consume_literal("export_iceberg_config") - _t2079 = self.parse_iceberg_locator() - iceberg_locator1320 = _t2079 - _t2080 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1321 = _t2080 - _t2081 = self.parse_export_iceberg_table_def() - export_iceberg_table_def1322 = _t2081 - _t2082 = self.parse_iceberg_table_properties() - iceberg_table_properties1323 = _t2082 + _t2091 = self.parse_iceberg_locator() + iceberg_locator1326 = _t2091 + _t2092 = self.parse_iceberg_catalog_config() + iceberg_catalog_config1327 = _t2092 + _t2093 = self.parse_export_iceberg_table_def() + export_iceberg_table_def1328 = _t2093 + _t2094 = self.parse_iceberg_table_properties() + iceberg_table_properties1329 = _t2094 if self.match_lookahead_literal("{", 0): - _t2084 = self.parse_config_dict() - _t2083 = _t2084 + _t2096 = self.parse_config_dict() + _t2095 = _t2096 else: - _t2083 = None - config_dict1324 = _t2083 + _t2095 = None + config_dict1330 = _t2095 self.consume_literal(")") - _t2085 = self.construct_export_iceberg_config_full(iceberg_locator1320, iceberg_catalog_config1321, export_iceberg_table_def1322, iceberg_table_properties1323, config_dict1324) - result1326 = _t2085 - self.record_span(span_start1325, "ExportIcebergConfig") - return result1326 + _t2097 = self.construct_export_iceberg_config_full(iceberg_locator1326, iceberg_catalog_config1327, export_iceberg_table_def1328, iceberg_table_properties1329, config_dict1330) + result1332 = _t2097 + self.record_span(span_start1331, "ExportIcebergConfig") + return result1332 def parse_export_iceberg_table_def(self) -> logic_pb2.RelationId: - span_start1328 = self.span_start() + span_start1334 = self.span_start() self.consume_literal("(") self.consume_literal("table_def") - _t2086 = self.parse_relation_id() - relation_id1327 = _t2086 + _t2098 = self.parse_relation_id() + relation_id1333 = _t2098 self.consume_literal(")") - result1329 = relation_id1327 - self.record_span(span_start1328, "RelationId") - return result1329 + result1335 = relation_id1333 + self.record_span(span_start1334, "RelationId") + return result1335 def parse_iceberg_table_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("table_properties") - xs1330 = [] - cond1331 = self.match_lookahead_literal("(", 0) - while cond1331: - _t2087 = self.parse_iceberg_property_entry() - item1332 = _t2087 - xs1330.append(item1332) - cond1331 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1333 = xs1330 - self.consume_literal(")") - return iceberg_property_entrys1333 + xs1336 = [] + cond1337 = self.match_lookahead_literal("(", 0) + while cond1337: + _t2099 = self.parse_iceberg_property_entry() + item1338 = _t2099 + xs1336.append(item1338) + cond1337 = self.match_lookahead_literal("(", 0) + iceberg_property_entrys1339 = xs1336 + self.consume_literal(")") + return iceberg_property_entrys1339 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 f0b28fa6..9f48620f 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -216,160 +216,163 @@ def write_debug_info(self) -> None: # --- Helper functions --- + 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: - _t1742 = logic_pb2.Value(int32_value=v) - return _t1742 + _t1755 = logic_pb2.Value(int32_value=v) + return _t1755 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1743 = logic_pb2.Value(int_value=v) - return _t1743 + _t1756 = logic_pb2.Value(int_value=v) + return _t1756 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1744 = logic_pb2.Value(float_value=v) - return _t1744 + _t1757 = logic_pb2.Value(float_value=v) + return _t1757 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1745 = logic_pb2.Value(string_value=v) - return _t1745 + _t1758 = logic_pb2.Value(string_value=v) + return _t1758 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1746 = logic_pb2.Value(boolean_value=v) - return _t1746 + _t1759 = logic_pb2.Value(boolean_value=v) + return _t1759 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1747 = logic_pb2.Value(uint128_value=v) - return _t1747 + _t1760 = logic_pb2.Value(uint128_value=v) + return _t1760 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: - _t1748 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1748,)) + _t1761 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1761,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1749 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1749,)) + _t1762 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1762,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1750 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1750,)) - _t1751 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1751,)) + _t1763 = self._make_value_string("off") + result.append(("ivm.maintenance_level", _t1763,)) + _t1764 = self._make_value_int64(msg.semantics_version) + result.append(("semantics_version", _t1764,)) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1752 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1752,)) - _t1753 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1753,)) + _t1765 = self._make_value_int32(msg.header_row) + result.append(("csv_header_row", _t1765,)) + _t1766 = self._make_value_int64(msg.skip) + result.append(("csv_skip", _t1766,)) if msg.new_line != "": - _t1754 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1754,)) - _t1755 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1755,)) - _t1756 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1756,)) - _t1757 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1757,)) + _t1767 = self._make_value_string(msg.new_line) + result.append(("csv_new_line", _t1767,)) + _t1768 = self._make_value_string(msg.delimiter) + result.append(("csv_delimiter", _t1768,)) + _t1769 = self._make_value_string(msg.quotechar) + result.append(("csv_quotechar", _t1769,)) + _t1770 = self._make_value_string(msg.escapechar) + result.append(("csv_escapechar", _t1770,)) if msg.comment != "": - _t1758 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1758,)) + _t1771 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1771,)) for missing_string in msg.missing_strings: - _t1759 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1759,)) - _t1760 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1760,)) - _t1761 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1761,)) - _t1762 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1762,)) + _t1772 = self._make_value_string(missing_string) + result.append(("csv_missing_strings", _t1772,)) + _t1773 = self._make_value_string(msg.decimal_separator) + result.append(("csv_decimal_separator", _t1773,)) + _t1774 = self._make_value_string(msg.encoding) + result.append(("csv_encoding", _t1774,)) + _t1775 = self._make_value_string(msg.compression) + result.append(("csv_compression", _t1775,)) if msg.partition_size_mb != 0: - _t1763 = self._make_value_int64(msg.partition_size_mb) - result.append(("csv_partition_size_mb", _t1763,)) + _t1776 = self._make_value_int64(msg.partition_size_mb) + result.append(("csv_partition_size_mb", _t1776,)) 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: - _t1764 = None + _t1777 = None assert msg.storage_integration is not None si = msg.storage_integration result = [] if si.provider != "": - _t1765 = self._make_value_string(si.provider) - result.append(("provider", _t1765,)) + _t1778 = self._make_value_string(si.provider) + result.append(("provider", _t1778,)) if si.azure_sas_token != "": - _t1766 = self._make_value_string("***") - result.append(("azure_sas_token", _t1766,)) + _t1779 = self._make_value_string("***") + result.append(("azure_sas_token", _t1779,)) if si.s3_region != "": - _t1767 = self._make_value_string(si.s3_region) - result.append(("s3_region", _t1767,)) + _t1780 = self._make_value_string(si.s3_region) + result.append(("s3_region", _t1780,)) if si.s3_access_key_id != "": - _t1768 = self._make_value_string("***") - result.append(("s3_access_key_id", _t1768,)) + _t1781 = self._make_value_string("***") + result.append(("s3_access_key_id", _t1781,)) if si.s3_secret_access_key != "": - _t1769 = self._make_value_string("***") - result.append(("s3_secret_access_key", _t1769,)) + _t1782 = self._make_value_string("***") + result.append(("s3_secret_access_key", _t1782,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] - _t1770 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1770,)) - _t1771 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1771,)) - _t1772 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1772,)) - _t1773 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1773,)) + _t1783 = self._make_value_float64(msg.storage_config.epsilon) + result.append(("betree_config_epsilon", _t1783,)) + _t1784 = self._make_value_int64(msg.storage_config.max_pivots) + result.append(("betree_config_max_pivots", _t1784,)) + _t1785 = self._make_value_int64(msg.storage_config.max_deltas) + result.append(("betree_config_max_deltas", _t1785,)) + _t1786 = self._make_value_int64(msg.storage_config.max_leaf) + result.append(("betree_config_max_leaf", _t1786,)) 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 - _t1774 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1774,)) + _t1787 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1787,)) 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 - _t1775 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1775,)) - _t1776 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1776,)) - _t1777 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1777,)) + _t1788 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) + result.append(("betree_locator_inline_data", _t1788,)) + _t1789 = self._make_value_int64(msg.relation_locator.element_count) + result.append(("betree_locator_element_count", _t1789,)) + _t1790 = self._make_value_int64(msg.relation_locator.tree_height) + result.append(("betree_locator_tree_height", _t1790,)) 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 - _t1778 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1778,)) + _t1791 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1791,)) if msg.compression is not None: assert msg.compression is not None - _t1779 = self._make_value_string(msg.compression) - result.append(("compression", _t1779,)) + _t1792 = self._make_value_string(msg.compression) + result.append(("compression", _t1792,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1780 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1780,)) + _t1793 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1793,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1781 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1781,)) + _t1794 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1794,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1782 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1782,)) + _t1795 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1795,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1783 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1783,)) + _t1796 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1796,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1784 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1784,)) + _t1797 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1797,)) return sorted(result) def mask_secret_value(self, pair: tuple[str, str]) -> str: @@ -381,7 +384,7 @@ def deconstruct_iceberg_catalog_config_scope_optional(self, msg: logic_pb2.Icebe assert msg.scope is not None return msg.scope else: - _t1785 = None + _t1798 = None return None def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -390,7 +393,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: - _t1786 = None + _t1799 = None return None def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -399,7 +402,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: - _t1787 = None + _t1800 = None return None def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.ExportIcebergConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: @@ -407,20 +410,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 - _t1788 = self._make_value_string(msg.prefix) - result.append(("prefix", _t1788,)) + _t1801 = self._make_value_string(msg.prefix) + result.append(("prefix", _t1801,)) 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 - _t1789 = self._make_value_int64(msg.target_file_size_bytes) - result.append(("target_file_size_bytes", _t1789,)) + _t1802 = self._make_value_int64(msg.target_file_size_bytes) + result.append(("target_file_size_bytes", _t1802,)) if msg.compression != "": - _t1790 = self._make_value_string(msg.compression) - result.append(("compression", _t1790,)) + _t1803 = self._make_value_string(msg.compression) + result.append(("compression", _t1803,)) if len(result) == 0: return None else: - _t1791 = None + _t1804 = None return sorted(result) def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: @@ -433,7 +436,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: - _t1792 = None + _t1805 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -448,1769 +451,1743 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat808 = self._try_flat(msg, self.pretty_transaction) - if flat808 is not None: - assert flat808 is not None - self.write(flat808) + flat813 = self._try_flat(msg, self.pretty_transaction) + if flat813 is not None: + assert flat813 is not None + self.write(flat813) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("configure"): - _t1598 = _dollar_dollar.configure + _t1608 = _dollar_dollar.configure else: - _t1598 = None + _t1608 = None if _dollar_dollar.HasField("sync"): - _t1599 = _dollar_dollar.sync + _t1609 = _dollar_dollar.sync else: - _t1599 = None - fields799 = (_t1598, _t1599, _dollar_dollar.epochs,) - assert fields799 is not None - unwrapped_fields800 = fields799 + _t1609 = None + fields804 = (_t1608, _t1609, _dollar_dollar.epochs,) + assert fields804 is not None + unwrapped_fields805 = fields804 self.write("(transaction") self.indent_sexp() - field801 = unwrapped_fields800[0] - if field801 is not None: + field806 = unwrapped_fields805[0] + if field806 is not None: self.newline() - assert field801 is not None - opt_val802 = field801 - self.pretty_configure(opt_val802) - field803 = unwrapped_fields800[1] - if field803 is not None: + assert field806 is not None + opt_val807 = field806 + self.pretty_configure(opt_val807) + field808 = unwrapped_fields805[1] + if field808 is not None: self.newline() - assert field803 is not None - opt_val804 = field803 - self.pretty_sync(opt_val804) - field805 = unwrapped_fields800[2] - if not len(field805) == 0: + assert field808 is not None + opt_val809 = field808 + self.pretty_sync(opt_val809) + field810 = unwrapped_fields805[2] + if not len(field810) == 0: self.newline() - for i807, elem806 in enumerate(field805): - if (i807 > 0): + for i812, elem811 in enumerate(field810): + if (i812 > 0): self.newline() - self.pretty_epoch(elem806) + self.pretty_epoch(elem811) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - flat811 = self._try_flat(msg, self.pretty_configure) - if flat811 is not None: - assert flat811 is not None - self.write(flat811) + flat816 = self._try_flat(msg, self.pretty_configure) + if flat816 is not None: + assert flat816 is not None + self.write(flat816) return None else: _dollar_dollar = msg - _t1600 = self.deconstruct_configure(_dollar_dollar) - fields809 = _t1600 - assert fields809 is not None - unwrapped_fields810 = fields809 + _t1610 = self.deconstruct_configure(_dollar_dollar) + fields814 = _t1610 + assert fields814 is not None + unwrapped_fields815 = fields814 self.write("(configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields810) + self.pretty_config_dict(unwrapped_fields815) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat815 = self._try_flat(msg, self.pretty_config_dict) - if flat815 is not None: - assert flat815 is not None - self.write(flat815) + flat820 = self._try_flat(msg, self.pretty_config_dict) + if flat820 is not None: + assert flat820 is not None + self.write(flat820) return None else: - fields812 = msg + fields817 = msg self.write("{") self.indent() - if not len(fields812) == 0: + if not len(fields817) == 0: self.newline() - for i814, elem813 in enumerate(fields812): - if (i814 > 0): + for i819, elem818 in enumerate(fields817): + if (i819 > 0): self.newline() - self.pretty_config_key_value(elem813) + self.pretty_config_key_value(elem818) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat820 = self._try_flat(msg, self.pretty_config_key_value) - if flat820 is not None: - assert flat820 is not None - self.write(flat820) + flat825 = self._try_flat(msg, self.pretty_config_key_value) + if flat825 is not None: + assert flat825 is not None + self.write(flat825) return None else: _dollar_dollar = msg - fields816 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields816 is not None - unwrapped_fields817 = fields816 + fields821 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields821 is not None + unwrapped_fields822 = fields821 self.write(":") - field818 = unwrapped_fields817[0] - self.write(field818) + field823 = unwrapped_fields822[0] + self.write(field823) self.write(" ") - field819 = unwrapped_fields817[1] - self.pretty_raw_value(field819) + field824 = unwrapped_fields822[1] + self.pretty_raw_value(field824) def pretty_raw_value(self, msg: logic_pb2.Value): - flat846 = self._try_flat(msg, self.pretty_raw_value) - if flat846 is not None: - assert flat846 is not None - self.write(flat846) + flat851 = self._try_flat(msg, self.pretty_raw_value) + if flat851 is not None: + assert flat851 is not None + self.write(flat851) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1601 = _dollar_dollar.date_value + _t1611 = _dollar_dollar.date_value else: - _t1601 = None - deconstruct_result844 = _t1601 - if deconstruct_result844 is not None: - assert deconstruct_result844 is not None - unwrapped845 = deconstruct_result844 - self.pretty_raw_date(unwrapped845) + _t1611 = None + deconstruct_result849 = _t1611 + if deconstruct_result849 is not None: + assert deconstruct_result849 is not None + unwrapped850 = deconstruct_result849 + self.pretty_raw_date(unwrapped850) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1602 = _dollar_dollar.datetime_value + _t1612 = _dollar_dollar.datetime_value else: - _t1602 = None - deconstruct_result842 = _t1602 - if deconstruct_result842 is not None: - assert deconstruct_result842 is not None - unwrapped843 = deconstruct_result842 - self.pretty_raw_datetime(unwrapped843) + _t1612 = None + deconstruct_result847 = _t1612 + if deconstruct_result847 is not None: + assert deconstruct_result847 is not None + unwrapped848 = deconstruct_result847 + self.pretty_raw_datetime(unwrapped848) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1603 = _dollar_dollar.string_value + _t1613 = _dollar_dollar.string_value else: - _t1603 = None - deconstruct_result840 = _t1603 - if deconstruct_result840 is not None: - assert deconstruct_result840 is not None - unwrapped841 = deconstruct_result840 - self.write(self.format_string_value(unwrapped841)) + _t1613 = None + deconstruct_result845 = _t1613 + if deconstruct_result845 is not None: + assert deconstruct_result845 is not None + unwrapped846 = deconstruct_result845 + self.write(self.format_string_value(unwrapped846)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1604 = _dollar_dollar.int32_value + _t1614 = _dollar_dollar.int32_value else: - _t1604 = None - deconstruct_result838 = _t1604 - if deconstruct_result838 is not None: - assert deconstruct_result838 is not None - unwrapped839 = deconstruct_result838 - self.write((str(unwrapped839) + 'i32')) + _t1614 = None + deconstruct_result843 = _t1614 + if deconstruct_result843 is not None: + assert deconstruct_result843 is not None + unwrapped844 = deconstruct_result843 + self.write((str(unwrapped844) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1605 = _dollar_dollar.int_value + _t1615 = _dollar_dollar.int_value else: - _t1605 = None - deconstruct_result836 = _t1605 - if deconstruct_result836 is not None: - assert deconstruct_result836 is not None - unwrapped837 = deconstruct_result836 - self.write(str(unwrapped837)) + _t1615 = None + deconstruct_result841 = _t1615 + if deconstruct_result841 is not None: + assert deconstruct_result841 is not None + unwrapped842 = deconstruct_result841 + self.write(str(unwrapped842)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1606 = _dollar_dollar.float32_value + _t1616 = _dollar_dollar.float32_value else: - _t1606 = None - deconstruct_result834 = _t1606 - if deconstruct_result834 is not None: - assert deconstruct_result834 is not None - unwrapped835 = deconstruct_result834 - self.write(self.format_float32_literal(unwrapped835)) + _t1616 = None + deconstruct_result839 = _t1616 + if deconstruct_result839 is not None: + assert deconstruct_result839 is not None + unwrapped840 = deconstruct_result839 + self.write(self.format_float32_literal(unwrapped840)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1607 = _dollar_dollar.float_value + _t1617 = _dollar_dollar.float_value else: - _t1607 = None - deconstruct_result832 = _t1607 - if deconstruct_result832 is not None: - assert deconstruct_result832 is not None - unwrapped833 = deconstruct_result832 - self.write(str(unwrapped833)) + _t1617 = None + deconstruct_result837 = _t1617 + if deconstruct_result837 is not None: + assert deconstruct_result837 is not None + unwrapped838 = deconstruct_result837 + self.write(str(unwrapped838)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1608 = _dollar_dollar.uint32_value + _t1618 = _dollar_dollar.uint32_value else: - _t1608 = None - deconstruct_result830 = _t1608 - if deconstruct_result830 is not None: - assert deconstruct_result830 is not None - unwrapped831 = deconstruct_result830 - self.write((str(unwrapped831) + 'u32')) + _t1618 = None + deconstruct_result835 = _t1618 + if deconstruct_result835 is not None: + assert deconstruct_result835 is not None + unwrapped836 = deconstruct_result835 + self.write((str(unwrapped836) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1609 = _dollar_dollar.uint128_value + _t1619 = _dollar_dollar.uint128_value else: - _t1609 = None - deconstruct_result828 = _t1609 - if deconstruct_result828 is not None: - assert deconstruct_result828 is not None - unwrapped829 = deconstruct_result828 - self.write(self.format_uint128(unwrapped829)) + _t1619 = None + deconstruct_result833 = _t1619 + if deconstruct_result833 is not None: + assert deconstruct_result833 is not None + unwrapped834 = deconstruct_result833 + self.write(self.format_uint128(unwrapped834)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1610 = _dollar_dollar.int128_value + _t1620 = _dollar_dollar.int128_value else: - _t1610 = None - deconstruct_result826 = _t1610 - if deconstruct_result826 is not None: - assert deconstruct_result826 is not None - unwrapped827 = deconstruct_result826 - self.write(self.format_int128(unwrapped827)) + _t1620 = None + deconstruct_result831 = _t1620 + if deconstruct_result831 is not None: + assert deconstruct_result831 is not None + unwrapped832 = deconstruct_result831 + self.write(self.format_int128(unwrapped832)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1611 = _dollar_dollar.decimal_value + _t1621 = _dollar_dollar.decimal_value else: - _t1611 = None - deconstruct_result824 = _t1611 - if deconstruct_result824 is not None: - assert deconstruct_result824 is not None - unwrapped825 = deconstruct_result824 - self.write(self.format_decimal(unwrapped825)) + _t1621 = None + deconstruct_result829 = _t1621 + if deconstruct_result829 is not None: + assert deconstruct_result829 is not None + unwrapped830 = deconstruct_result829 + self.write(self.format_decimal(unwrapped830)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1612 = _dollar_dollar.boolean_value + _t1622 = _dollar_dollar.boolean_value else: - _t1612 = None - deconstruct_result822 = _t1612 - if deconstruct_result822 is not None: - assert deconstruct_result822 is not None - unwrapped823 = deconstruct_result822 - self.pretty_boolean_value(unwrapped823) + _t1622 = None + deconstruct_result827 = _t1622 + if deconstruct_result827 is not None: + assert deconstruct_result827 is not None + unwrapped828 = deconstruct_result827 + self.pretty_boolean_value(unwrapped828) else: - fields821 = msg + fields826 = msg self.write("missing") def pretty_raw_date(self, msg: logic_pb2.DateValue): - flat852 = self._try_flat(msg, self.pretty_raw_date) - if flat852 is not None: - assert flat852 is not None - self.write(flat852) + flat857 = self._try_flat(msg, self.pretty_raw_date) + if flat857 is not None: + assert flat857 is not None + self.write(flat857) return None else: _dollar_dollar = msg - fields847 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields847 is not None - unwrapped_fields848 = fields847 + fields852 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields852 is not None + unwrapped_fields853 = fields852 self.write("(date") self.indent_sexp() self.newline() - field849 = unwrapped_fields848[0] - self.write(str(field849)) + field854 = unwrapped_fields853[0] + self.write(str(field854)) self.newline() - field850 = unwrapped_fields848[1] - self.write(str(field850)) + field855 = unwrapped_fields853[1] + self.write(str(field855)) self.newline() - field851 = unwrapped_fields848[2] - self.write(str(field851)) + field856 = unwrapped_fields853[2] + self.write(str(field856)) self.dedent() self.write(")") def pretty_raw_datetime(self, msg: logic_pb2.DateTimeValue): - flat863 = self._try_flat(msg, self.pretty_raw_datetime) - if flat863 is not None: - assert flat863 is not None - self.write(flat863) + flat868 = self._try_flat(msg, self.pretty_raw_datetime) + if flat868 is not None: + assert flat868 is not None + self.write(flat868) return None else: _dollar_dollar = msg - fields853 = (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 fields853 is not None - unwrapped_fields854 = fields853 + fields858 = (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 fields858 is not None + unwrapped_fields859 = fields858 self.write("(datetime") self.indent_sexp() self.newline() - field855 = unwrapped_fields854[0] - self.write(str(field855)) + field860 = unwrapped_fields859[0] + self.write(str(field860)) self.newline() - field856 = unwrapped_fields854[1] - self.write(str(field856)) + field861 = unwrapped_fields859[1] + self.write(str(field861)) self.newline() - field857 = unwrapped_fields854[2] - self.write(str(field857)) + field862 = unwrapped_fields859[2] + self.write(str(field862)) self.newline() - field858 = unwrapped_fields854[3] - self.write(str(field858)) + field863 = unwrapped_fields859[3] + self.write(str(field863)) self.newline() - field859 = unwrapped_fields854[4] - self.write(str(field859)) + field864 = unwrapped_fields859[4] + self.write(str(field864)) self.newline() - field860 = unwrapped_fields854[5] - self.write(str(field860)) - field861 = unwrapped_fields854[6] - if field861 is not None: + field865 = unwrapped_fields859[5] + self.write(str(field865)) + field866 = unwrapped_fields859[6] + if field866 is not None: self.newline() - assert field861 is not None - opt_val862 = field861 - self.write(str(opt_val862)) + assert field866 is not None + opt_val867 = field866 + self.write(str(opt_val867)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): _dollar_dollar = msg if _dollar_dollar: - _t1613 = () + _t1623 = () else: - _t1613 = None - deconstruct_result866 = _t1613 - if deconstruct_result866 is not None: - assert deconstruct_result866 is not None - unwrapped867 = deconstruct_result866 + _t1623 = None + deconstruct_result871 = _t1623 + if deconstruct_result871 is not None: + assert deconstruct_result871 is not None + unwrapped872 = deconstruct_result871 self.write("true") else: _dollar_dollar = msg if not _dollar_dollar: - _t1614 = () + _t1624 = () else: - _t1614 = None - deconstruct_result864 = _t1614 - if deconstruct_result864 is not None: - assert deconstruct_result864 is not None - unwrapped865 = deconstruct_result864 + _t1624 = None + deconstruct_result869 = _t1624 + if deconstruct_result869 is not None: + assert deconstruct_result869 is not None + unwrapped870 = deconstruct_result869 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat872 = self._try_flat(msg, self.pretty_sync) - if flat872 is not None: - assert flat872 is not None - self.write(flat872) + flat877 = self._try_flat(msg, self.pretty_sync) + if flat877 is not None: + assert flat877 is not None + self.write(flat877) return None else: _dollar_dollar = msg - fields868 = _dollar_dollar.fragments - assert fields868 is not None - unwrapped_fields869 = fields868 + fields873 = _dollar_dollar.fragments + assert fields873 is not None + unwrapped_fields874 = fields873 self.write("(sync") self.indent_sexp() - if not len(unwrapped_fields869) == 0: + if not len(unwrapped_fields874) == 0: self.newline() - for i871, elem870 in enumerate(unwrapped_fields869): - if (i871 > 0): + for i876, elem875 in enumerate(unwrapped_fields874): + if (i876 > 0): self.newline() - self.pretty_fragment_id(elem870) + self.pretty_fragment_id(elem875) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat875 = self._try_flat(msg, self.pretty_fragment_id) - if flat875 is not None: - assert flat875 is not None - self.write(flat875) + flat880 = self._try_flat(msg, self.pretty_fragment_id) + if flat880 is not None: + assert flat880 is not None + self.write(flat880) return None else: _dollar_dollar = msg - fields873 = self.fragment_id_to_string(_dollar_dollar) - assert fields873 is not None - unwrapped_fields874 = fields873 + fields878 = self.fragment_id_to_string(_dollar_dollar) + assert fields878 is not None + unwrapped_fields879 = fields878 self.write(":") - self.write(unwrapped_fields874) + self.write(unwrapped_fields879) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat882 = self._try_flat(msg, self.pretty_epoch) - if flat882 is not None: - assert flat882 is not None - self.write(flat882) + flat887 = self._try_flat(msg, self.pretty_epoch) + if flat887 is not None: + assert flat887 is not None + self.write(flat887) return None else: _dollar_dollar = msg if not len(_dollar_dollar.writes) == 0: - _t1615 = _dollar_dollar.writes + _t1625 = _dollar_dollar.writes else: - _t1615 = None + _t1625 = None if not len(_dollar_dollar.reads) == 0: - _t1616 = _dollar_dollar.reads + _t1626 = _dollar_dollar.reads else: - _t1616 = None - fields876 = (_t1615, _t1616,) - assert fields876 is not None - unwrapped_fields877 = fields876 + _t1626 = None + fields881 = (_t1625, _t1626,) + assert fields881 is not None + unwrapped_fields882 = fields881 self.write("(epoch") self.indent_sexp() - field878 = unwrapped_fields877[0] - if field878 is not None: + field883 = unwrapped_fields882[0] + if field883 is not None: self.newline() - assert field878 is not None - opt_val879 = field878 - self.pretty_epoch_writes(opt_val879) - field880 = unwrapped_fields877[1] - if field880 is not None: + assert field883 is not None + opt_val884 = field883 + self.pretty_epoch_writes(opt_val884) + field885 = unwrapped_fields882[1] + if field885 is not None: self.newline() - assert field880 is not None - opt_val881 = field880 - self.pretty_epoch_reads(opt_val881) + assert field885 is not None + opt_val886 = field885 + self.pretty_epoch_reads(opt_val886) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat886 = self._try_flat(msg, self.pretty_epoch_writes) - if flat886 is not None: - assert flat886 is not None - self.write(flat886) + flat891 = self._try_flat(msg, self.pretty_epoch_writes) + if flat891 is not None: + assert flat891 is not None + self.write(flat891) return None else: - fields883 = msg + fields888 = msg self.write("(writes") self.indent_sexp() - if not len(fields883) == 0: + if not len(fields888) == 0: self.newline() - for i885, elem884 in enumerate(fields883): - if (i885 > 0): + for i890, elem889 in enumerate(fields888): + if (i890 > 0): self.newline() - self.pretty_write(elem884) + self.pretty_write(elem889) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat895 = self._try_flat(msg, self.pretty_write) - if flat895 is not None: - assert flat895 is not None - self.write(flat895) + flat900 = self._try_flat(msg, self.pretty_write) + if flat900 is not None: + assert flat900 is not None + self.write(flat900) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("define"): - _t1617 = _dollar_dollar.define + _t1627 = _dollar_dollar.define else: - _t1617 = None - deconstruct_result893 = _t1617 - if deconstruct_result893 is not None: - assert deconstruct_result893 is not None - unwrapped894 = deconstruct_result893 - self.pretty_define(unwrapped894) + _t1627 = None + deconstruct_result898 = _t1627 + if deconstruct_result898 is not None: + assert deconstruct_result898 is not None + unwrapped899 = deconstruct_result898 + self.pretty_define(unwrapped899) else: _dollar_dollar = msg if _dollar_dollar.HasField("undefine"): - _t1618 = _dollar_dollar.undefine + _t1628 = _dollar_dollar.undefine else: - _t1618 = None - deconstruct_result891 = _t1618 - if deconstruct_result891 is not None: - assert deconstruct_result891 is not None - unwrapped892 = deconstruct_result891 - self.pretty_undefine(unwrapped892) + _t1628 = None + deconstruct_result896 = _t1628 + if deconstruct_result896 is not None: + assert deconstruct_result896 is not None + unwrapped897 = deconstruct_result896 + self.pretty_undefine(unwrapped897) else: _dollar_dollar = msg if _dollar_dollar.HasField("context"): - _t1619 = _dollar_dollar.context + _t1629 = _dollar_dollar.context else: - _t1619 = None - deconstruct_result889 = _t1619 - if deconstruct_result889 is not None: - assert deconstruct_result889 is not None - unwrapped890 = deconstruct_result889 - self.pretty_context(unwrapped890) + _t1629 = None + deconstruct_result894 = _t1629 + if deconstruct_result894 is not None: + assert deconstruct_result894 is not None + unwrapped895 = deconstruct_result894 + self.pretty_context(unwrapped895) else: _dollar_dollar = msg if _dollar_dollar.HasField("snapshot"): - _t1620 = _dollar_dollar.snapshot + _t1630 = _dollar_dollar.snapshot else: - _t1620 = None - deconstruct_result887 = _t1620 - if deconstruct_result887 is not None: - assert deconstruct_result887 is not None - unwrapped888 = deconstruct_result887 - self.pretty_snapshot(unwrapped888) + _t1630 = None + deconstruct_result892 = _t1630 + if deconstruct_result892 is not None: + assert deconstruct_result892 is not None + unwrapped893 = deconstruct_result892 + self.pretty_snapshot(unwrapped893) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat898 = self._try_flat(msg, self.pretty_define) - if flat898 is not None: - assert flat898 is not None - self.write(flat898) + flat903 = self._try_flat(msg, self.pretty_define) + if flat903 is not None: + assert flat903 is not None + self.write(flat903) return None else: _dollar_dollar = msg - fields896 = _dollar_dollar.fragment - assert fields896 is not None - unwrapped_fields897 = fields896 + fields901 = _dollar_dollar.fragment + assert fields901 is not None + unwrapped_fields902 = fields901 self.write("(define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields897) + self.pretty_fragment(unwrapped_fields902) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat905 = self._try_flat(msg, self.pretty_fragment) - if flat905 is not None: - assert flat905 is not None - self.write(flat905) + flat910 = self._try_flat(msg, self.pretty_fragment) + if flat910 is not None: + assert flat910 is not None + self.write(flat910) return None else: _dollar_dollar = msg self.start_pretty_fragment(_dollar_dollar) - fields899 = (_dollar_dollar.id, _dollar_dollar.declarations,) - assert fields899 is not None - unwrapped_fields900 = fields899 + fields904 = (_dollar_dollar.id, _dollar_dollar.declarations,) + assert fields904 is not None + unwrapped_fields905 = fields904 self.write("(fragment") self.indent_sexp() self.newline() - field901 = unwrapped_fields900[0] - self.pretty_new_fragment_id(field901) - field902 = unwrapped_fields900[1] - if not len(field902) == 0: + field906 = unwrapped_fields905[0] + self.pretty_new_fragment_id(field906) + field907 = unwrapped_fields905[1] + if not len(field907) == 0: self.newline() - for i904, elem903 in enumerate(field902): - if (i904 > 0): + for i909, elem908 in enumerate(field907): + if (i909 > 0): self.newline() - self.pretty_declaration(elem903) + self.pretty_declaration(elem908) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat907 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat907 is not None: - assert flat907 is not None - self.write(flat907) + flat912 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat912 is not None: + assert flat912 is not None + self.write(flat912) return None else: - fields906 = msg - self.pretty_fragment_id(fields906) + fields911 = msg + self.pretty_fragment_id(fields911) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat916 = self._try_flat(msg, self.pretty_declaration) - if flat916 is not None: - assert flat916 is not None - self.write(flat916) + flat921 = self._try_flat(msg, self.pretty_declaration) + if flat921 is not None: + assert flat921 is not None + self.write(flat921) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("def"): - _t1621 = getattr(_dollar_dollar, 'def') + _t1631 = getattr(_dollar_dollar, 'def') else: - _t1621 = None - deconstruct_result914 = _t1621 - if deconstruct_result914 is not None: - assert deconstruct_result914 is not None - unwrapped915 = deconstruct_result914 - self.pretty_def(unwrapped915) + _t1631 = None + deconstruct_result919 = _t1631 + if deconstruct_result919 is not None: + assert deconstruct_result919 is not None + unwrapped920 = deconstruct_result919 + self.pretty_def(unwrapped920) else: _dollar_dollar = msg if _dollar_dollar.HasField("algorithm"): - _t1622 = _dollar_dollar.algorithm + _t1632 = _dollar_dollar.algorithm else: - _t1622 = None - deconstruct_result912 = _t1622 - if deconstruct_result912 is not None: - assert deconstruct_result912 is not None - unwrapped913 = deconstruct_result912 - self.pretty_algorithm(unwrapped913) + _t1632 = None + deconstruct_result917 = _t1632 + if deconstruct_result917 is not None: + assert deconstruct_result917 is not None + unwrapped918 = deconstruct_result917 + self.pretty_algorithm(unwrapped918) else: _dollar_dollar = msg if _dollar_dollar.HasField("constraint"): - _t1623 = _dollar_dollar.constraint + _t1633 = _dollar_dollar.constraint else: - _t1623 = None - deconstruct_result910 = _t1623 - if deconstruct_result910 is not None: - assert deconstruct_result910 is not None - unwrapped911 = deconstruct_result910 - self.pretty_constraint(unwrapped911) + _t1633 = None + deconstruct_result915 = _t1633 + if deconstruct_result915 is not None: + assert deconstruct_result915 is not None + unwrapped916 = deconstruct_result915 + self.pretty_constraint(unwrapped916) else: _dollar_dollar = msg if _dollar_dollar.HasField("data"): - _t1624 = _dollar_dollar.data + _t1634 = _dollar_dollar.data else: - _t1624 = None - deconstruct_result908 = _t1624 - if deconstruct_result908 is not None: - assert deconstruct_result908 is not None - unwrapped909 = deconstruct_result908 - self.pretty_data(unwrapped909) + _t1634 = None + deconstruct_result913 = _t1634 + if deconstruct_result913 is not None: + assert deconstruct_result913 is not None + unwrapped914 = deconstruct_result913 + self.pretty_data(unwrapped914) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat923 = self._try_flat(msg, self.pretty_def) - if flat923 is not None: - assert flat923 is not None - self.write(flat923) + flat928 = self._try_flat(msg, self.pretty_def) + if flat928 is not None: + assert flat928 is not None + self.write(flat928) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1625 = _dollar_dollar.attrs + _t1635 = _dollar_dollar.attrs else: - _t1625 = None - fields917 = (_dollar_dollar.name, _dollar_dollar.body, _t1625,) - assert fields917 is not None - unwrapped_fields918 = fields917 + _t1635 = None + fields922 = (_dollar_dollar.name, _dollar_dollar.body, _t1635,) + assert fields922 is not None + unwrapped_fields923 = fields922 self.write("(def") self.indent_sexp() self.newline() - field919 = unwrapped_fields918[0] - self.pretty_relation_id(field919) + field924 = unwrapped_fields923[0] + self.pretty_relation_id(field924) self.newline() - field920 = unwrapped_fields918[1] - self.pretty_abstraction(field920) - field921 = unwrapped_fields918[2] - if field921 is not None: + field925 = unwrapped_fields923[1] + self.pretty_abstraction(field925) + field926 = unwrapped_fields923[2] + if field926 is not None: self.newline() - assert field921 is not None - opt_val922 = field921 - self.pretty_attrs(opt_val922) + assert field926 is not None + opt_val927 = field926 + self.pretty_attrs(opt_val927) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat928 = self._try_flat(msg, self.pretty_relation_id) - if flat928 is not None: - assert flat928 is not None - self.write(flat928) + flat933 = self._try_flat(msg, self.pretty_relation_id) + if flat933 is not None: + assert flat933 is not None + self.write(flat933) return None else: _dollar_dollar = msg if self.relation_id_to_string(_dollar_dollar) is not None: - _t1627 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1626 = _t1627 + _t1637 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1636 = _t1637 else: - _t1626 = None - deconstruct_result926 = _t1626 - if deconstruct_result926 is not None: - assert deconstruct_result926 is not None - unwrapped927 = deconstruct_result926 + _t1636 = None + deconstruct_result931 = _t1636 + if deconstruct_result931 is not None: + assert deconstruct_result931 is not None + unwrapped932 = deconstruct_result931 self.write(":") - self.write(unwrapped927) + self.write(unwrapped932) else: _dollar_dollar = msg - _t1628 = self.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result924 = _t1628 - if deconstruct_result924 is not None: - assert deconstruct_result924 is not None - unwrapped925 = deconstruct_result924 - self.write(self.format_uint128(unwrapped925)) + _t1638 = self.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result929 = _t1638 + if deconstruct_result929 is not None: + assert deconstruct_result929 is not None + unwrapped930 = deconstruct_result929 + self.write(self.format_uint128(unwrapped930)) else: raise ParseError("No matching rule for relation_id") def pretty_abstraction(self, msg: logic_pb2.Abstraction): - flat933 = self._try_flat(msg, self.pretty_abstraction) - if flat933 is not None: - assert flat933 is not None - self.write(flat933) + flat938 = self._try_flat(msg, self.pretty_abstraction) + if flat938 is not None: + assert flat938 is not None + self.write(flat938) return None else: _dollar_dollar = msg - _t1629 = self.deconstruct_bindings(_dollar_dollar) - fields929 = (_t1629, _dollar_dollar.value,) - assert fields929 is not None - unwrapped_fields930 = fields929 + _t1639 = self.deconstruct_bindings(_dollar_dollar) + fields934 = (_t1639, _dollar_dollar.value,) + assert fields934 is not None + unwrapped_fields935 = fields934 self.write("(") self.indent() - field931 = unwrapped_fields930[0] - self.pretty_bindings(field931) + field936 = unwrapped_fields935[0] + self.pretty_bindings(field936) self.newline() - field932 = unwrapped_fields930[1] - self.pretty_formula(field932) + field937 = unwrapped_fields935[1] + self.pretty_formula(field937) self.dedent() self.write(")") def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): - flat941 = self._try_flat(msg, self.pretty_bindings) - if flat941 is not None: - assert flat941 is not None - self.write(flat941) + flat946 = self._try_flat(msg, self.pretty_bindings) + if flat946 is not None: + assert flat946 is not None + self.write(flat946) return None else: _dollar_dollar = msg if not len(_dollar_dollar[1]) == 0: - _t1630 = _dollar_dollar[1] + _t1640 = _dollar_dollar[1] else: - _t1630 = None - fields934 = (_dollar_dollar[0], _t1630,) - assert fields934 is not None - unwrapped_fields935 = fields934 + _t1640 = None + fields939 = (_dollar_dollar[0], _t1640,) + assert fields939 is not None + unwrapped_fields940 = fields939 self.write("[") self.indent() - field936 = unwrapped_fields935[0] - for i938, elem937 in enumerate(field936): - if (i938 > 0): + field941 = unwrapped_fields940[0] + for i943, elem942 in enumerate(field941): + if (i943 > 0): self.newline() - self.pretty_binding(elem937) - field939 = unwrapped_fields935[1] - if field939 is not None: + self.pretty_binding(elem942) + field944 = unwrapped_fields940[1] + if field944 is not None: self.newline() - assert field939 is not None - opt_val940 = field939 - self.pretty_value_bindings(opt_val940) + assert field944 is not None + opt_val945 = field944 + self.pretty_value_bindings(opt_val945) self.dedent() self.write("]") def pretty_binding(self, msg: logic_pb2.Binding): - flat946 = self._try_flat(msg, self.pretty_binding) - if flat946 is not None: - assert flat946 is not None - self.write(flat946) + flat951 = self._try_flat(msg, self.pretty_binding) + if flat951 is not None: + assert flat951 is not None + self.write(flat951) return None else: _dollar_dollar = msg - fields942 = (_dollar_dollar.var.name, _dollar_dollar.type,) - assert fields942 is not None - unwrapped_fields943 = fields942 - field944 = unwrapped_fields943[0] - self.write(field944) + fields947 = (_dollar_dollar.var.name, _dollar_dollar.type,) + assert fields947 is not None + unwrapped_fields948 = fields947 + field949 = unwrapped_fields948[0] + self.write(field949) self.write("::") - field945 = unwrapped_fields943[1] - self.pretty_type(field945) + field950 = unwrapped_fields948[1] + self.pretty_type(field950) def pretty_type(self, msg: logic_pb2.Type): - flat975 = self._try_flat(msg, self.pretty_type) - if flat975 is not None: - assert flat975 is not None - self.write(flat975) + flat980 = self._try_flat(msg, self.pretty_type) + if flat980 is not None: + assert flat980 is not None + self.write(flat980) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("unspecified_type"): - _t1631 = _dollar_dollar.unspecified_type + _t1641 = _dollar_dollar.unspecified_type else: - _t1631 = None - deconstruct_result973 = _t1631 - if deconstruct_result973 is not None: - assert deconstruct_result973 is not None - unwrapped974 = deconstruct_result973 - self.pretty_unspecified_type(unwrapped974) + _t1641 = None + deconstruct_result978 = _t1641 + if deconstruct_result978 is not None: + assert deconstruct_result978 is not None + unwrapped979 = deconstruct_result978 + self.pretty_unspecified_type(unwrapped979) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_type"): - _t1632 = _dollar_dollar.string_type + _t1642 = _dollar_dollar.string_type else: - _t1632 = None - deconstruct_result971 = _t1632 - if deconstruct_result971 is not None: - assert deconstruct_result971 is not None - unwrapped972 = deconstruct_result971 - self.pretty_string_type(unwrapped972) + _t1642 = None + deconstruct_result976 = _t1642 + if deconstruct_result976 is not None: + assert deconstruct_result976 is not None + unwrapped977 = deconstruct_result976 + self.pretty_string_type(unwrapped977) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_type"): - _t1633 = _dollar_dollar.int_type + _t1643 = _dollar_dollar.int_type else: - _t1633 = None - deconstruct_result969 = _t1633 - if deconstruct_result969 is not None: - assert deconstruct_result969 is not None - unwrapped970 = deconstruct_result969 - self.pretty_int_type(unwrapped970) + _t1643 = None + deconstruct_result974 = _t1643 + if deconstruct_result974 is not None: + assert deconstruct_result974 is not None + unwrapped975 = deconstruct_result974 + self.pretty_int_type(unwrapped975) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_type"): - _t1634 = _dollar_dollar.float_type + _t1644 = _dollar_dollar.float_type else: - _t1634 = None - deconstruct_result967 = _t1634 - if deconstruct_result967 is not None: - assert deconstruct_result967 is not None - unwrapped968 = deconstruct_result967 - self.pretty_float_type(unwrapped968) + _t1644 = None + deconstruct_result972 = _t1644 + if deconstruct_result972 is not None: + assert deconstruct_result972 is not None + unwrapped973 = deconstruct_result972 + self.pretty_float_type(unwrapped973) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_type"): - _t1635 = _dollar_dollar.uint128_type + _t1645 = _dollar_dollar.uint128_type else: - _t1635 = None - deconstruct_result965 = _t1635 - if deconstruct_result965 is not None: - assert deconstruct_result965 is not None - unwrapped966 = deconstruct_result965 - self.pretty_uint128_type(unwrapped966) + _t1645 = None + deconstruct_result970 = _t1645 + if deconstruct_result970 is not None: + assert deconstruct_result970 is not None + unwrapped971 = deconstruct_result970 + self.pretty_uint128_type(unwrapped971) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_type"): - _t1636 = _dollar_dollar.int128_type + _t1646 = _dollar_dollar.int128_type else: - _t1636 = None - deconstruct_result963 = _t1636 - if deconstruct_result963 is not None: - assert deconstruct_result963 is not None - unwrapped964 = deconstruct_result963 - self.pretty_int128_type(unwrapped964) + _t1646 = None + deconstruct_result968 = _t1646 + if deconstruct_result968 is not None: + assert deconstruct_result968 is not None + unwrapped969 = deconstruct_result968 + self.pretty_int128_type(unwrapped969) else: _dollar_dollar = msg if _dollar_dollar.HasField("date_type"): - _t1637 = _dollar_dollar.date_type + _t1647 = _dollar_dollar.date_type else: - _t1637 = None - deconstruct_result961 = _t1637 - if deconstruct_result961 is not None: - assert deconstruct_result961 is not None - unwrapped962 = deconstruct_result961 - self.pretty_date_type(unwrapped962) + _t1647 = None + deconstruct_result966 = _t1647 + if deconstruct_result966 is not None: + assert deconstruct_result966 is not None + unwrapped967 = deconstruct_result966 + self.pretty_date_type(unwrapped967) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_type"): - _t1638 = _dollar_dollar.datetime_type + _t1648 = _dollar_dollar.datetime_type else: - _t1638 = None - deconstruct_result959 = _t1638 - if deconstruct_result959 is not None: - assert deconstruct_result959 is not None - unwrapped960 = deconstruct_result959 - self.pretty_datetime_type(unwrapped960) + _t1648 = None + deconstruct_result964 = _t1648 + if deconstruct_result964 is not None: + assert deconstruct_result964 is not None + unwrapped965 = deconstruct_result964 + self.pretty_datetime_type(unwrapped965) else: _dollar_dollar = msg if _dollar_dollar.HasField("missing_type"): - _t1639 = _dollar_dollar.missing_type + _t1649 = _dollar_dollar.missing_type else: - _t1639 = None - deconstruct_result957 = _t1639 - if deconstruct_result957 is not None: - assert deconstruct_result957 is not None - unwrapped958 = deconstruct_result957 - self.pretty_missing_type(unwrapped958) + _t1649 = None + deconstruct_result962 = _t1649 + if deconstruct_result962 is not None: + assert deconstruct_result962 is not None + unwrapped963 = deconstruct_result962 + self.pretty_missing_type(unwrapped963) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_type"): - _t1640 = _dollar_dollar.decimal_type + _t1650 = _dollar_dollar.decimal_type else: - _t1640 = None - deconstruct_result955 = _t1640 - if deconstruct_result955 is not None: - assert deconstruct_result955 is not None - unwrapped956 = deconstruct_result955 - self.pretty_decimal_type(unwrapped956) + _t1650 = None + deconstruct_result960 = _t1650 + if deconstruct_result960 is not None: + assert deconstruct_result960 is not None + unwrapped961 = deconstruct_result960 + self.pretty_decimal_type(unwrapped961) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_type"): - _t1641 = _dollar_dollar.boolean_type + _t1651 = _dollar_dollar.boolean_type else: - _t1641 = None - deconstruct_result953 = _t1641 - if deconstruct_result953 is not None: - assert deconstruct_result953 is not None - unwrapped954 = deconstruct_result953 - self.pretty_boolean_type(unwrapped954) + _t1651 = None + deconstruct_result958 = _t1651 + if deconstruct_result958 is not None: + assert deconstruct_result958 is not None + unwrapped959 = deconstruct_result958 + self.pretty_boolean_type(unwrapped959) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_type"): - _t1642 = _dollar_dollar.int32_type + _t1652 = _dollar_dollar.int32_type else: - _t1642 = None - deconstruct_result951 = _t1642 - if deconstruct_result951 is not None: - assert deconstruct_result951 is not None - unwrapped952 = deconstruct_result951 - self.pretty_int32_type(unwrapped952) + _t1652 = None + deconstruct_result956 = _t1652 + if deconstruct_result956 is not None: + assert deconstruct_result956 is not None + unwrapped957 = deconstruct_result956 + self.pretty_int32_type(unwrapped957) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_type"): - _t1643 = _dollar_dollar.float32_type + _t1653 = _dollar_dollar.float32_type else: - _t1643 = None - deconstruct_result949 = _t1643 - if deconstruct_result949 is not None: - assert deconstruct_result949 is not None - unwrapped950 = deconstruct_result949 - self.pretty_float32_type(unwrapped950) + _t1653 = None + deconstruct_result954 = _t1653 + if deconstruct_result954 is not None: + assert deconstruct_result954 is not None + unwrapped955 = deconstruct_result954 + self.pretty_float32_type(unwrapped955) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_type"): - _t1644 = _dollar_dollar.uint32_type + _t1654 = _dollar_dollar.uint32_type else: - _t1644 = None - deconstruct_result947 = _t1644 - if deconstruct_result947 is not None: - assert deconstruct_result947 is not None - unwrapped948 = deconstruct_result947 - self.pretty_uint32_type(unwrapped948) + _t1654 = None + deconstruct_result952 = _t1654 + if deconstruct_result952 is not None: + assert deconstruct_result952 is not None + unwrapped953 = deconstruct_result952 + self.pretty_uint32_type(unwrapped953) else: raise ParseError("No matching rule for type") def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields976 = msg + fields981 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields977 = msg + fields982 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields978 = msg + fields983 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields979 = msg + fields984 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields980 = msg + fields985 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields981 = msg + fields986 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields982 = msg + fields987 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields983 = msg + fields988 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields984 = msg + fields989 = msg self.write("MISSING") def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat989 = self._try_flat(msg, self.pretty_decimal_type) - if flat989 is not None: - assert flat989 is not None - self.write(flat989) + flat994 = self._try_flat(msg, self.pretty_decimal_type) + if flat994 is not None: + assert flat994 is not None + self.write(flat994) return None else: _dollar_dollar = msg - fields985 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - assert fields985 is not None - unwrapped_fields986 = fields985 + fields990 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) + assert fields990 is not None + unwrapped_fields991 = fields990 self.write("(DECIMAL") self.indent_sexp() self.newline() - field987 = unwrapped_fields986[0] - self.write(str(field987)) + field992 = unwrapped_fields991[0] + self.write(str(field992)) self.newline() - field988 = unwrapped_fields986[1] - self.write(str(field988)) + field993 = unwrapped_fields991[1] + self.write(str(field993)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields990 = msg + fields995 = msg self.write("BOOLEAN") def pretty_int32_type(self, msg: logic_pb2.Int32Type): - fields991 = msg + fields996 = msg self.write("INT32") def pretty_float32_type(self, msg: logic_pb2.Float32Type): - fields992 = msg + fields997 = msg self.write("FLOAT32") def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): - fields993 = msg + fields998 = msg self.write("UINT32") def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat997 = self._try_flat(msg, self.pretty_value_bindings) - if flat997 is not None: - assert flat997 is not None - self.write(flat997) + flat1002 = self._try_flat(msg, self.pretty_value_bindings) + if flat1002 is not None: + assert flat1002 is not None + self.write(flat1002) return None else: - fields994 = msg + fields999 = msg self.write("|") - if not len(fields994) == 0: + if not len(fields999) == 0: self.write(" ") - for i996, elem995 in enumerate(fields994): - if (i996 > 0): + for i1001, elem1000 in enumerate(fields999): + if (i1001 > 0): self.newline() - self.pretty_binding(elem995) + self.pretty_binding(elem1000) def pretty_formula(self, msg: logic_pb2.Formula): - flat1024 = self._try_flat(msg, self.pretty_formula) - if flat1024 is not None: - assert flat1024 is not None - self.write(flat1024) + flat1029 = self._try_flat(msg, self.pretty_formula) + if flat1029 is not None: + assert flat1029 is not None + self.write(flat1029) return None else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1645 = _dollar_dollar.conjunction + _t1655 = _dollar_dollar.conjunction else: - _t1645 = None - deconstruct_result1022 = _t1645 - if deconstruct_result1022 is not None: - assert deconstruct_result1022 is not None - unwrapped1023 = deconstruct_result1022 - self.pretty_true(unwrapped1023) + _t1655 = None + deconstruct_result1027 = _t1655 + if deconstruct_result1027 is not None: + assert deconstruct_result1027 is not None + unwrapped1028 = deconstruct_result1027 + self.pretty_true(unwrapped1028) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1646 = _dollar_dollar.disjunction + _t1656 = _dollar_dollar.disjunction else: - _t1646 = None - deconstruct_result1020 = _t1646 - if deconstruct_result1020 is not None: - assert deconstruct_result1020 is not None - unwrapped1021 = deconstruct_result1020 - self.pretty_false(unwrapped1021) + _t1656 = None + deconstruct_result1025 = _t1656 + if deconstruct_result1025 is not None: + assert deconstruct_result1025 is not None + unwrapped1026 = deconstruct_result1025 + self.pretty_false(unwrapped1026) else: _dollar_dollar = msg if _dollar_dollar.HasField("exists"): - _t1647 = _dollar_dollar.exists + _t1657 = _dollar_dollar.exists else: - _t1647 = None - deconstruct_result1018 = _t1647 - if deconstruct_result1018 is not None: - assert deconstruct_result1018 is not None - unwrapped1019 = deconstruct_result1018 - self.pretty_exists(unwrapped1019) + _t1657 = None + deconstruct_result1023 = _t1657 + if deconstruct_result1023 is not None: + assert deconstruct_result1023 is not None + unwrapped1024 = deconstruct_result1023 + self.pretty_exists(unwrapped1024) else: _dollar_dollar = msg if _dollar_dollar.HasField("reduce"): - _t1648 = _dollar_dollar.reduce + _t1658 = _dollar_dollar.reduce else: - _t1648 = None - deconstruct_result1016 = _t1648 - if deconstruct_result1016 is not None: - assert deconstruct_result1016 is not None - unwrapped1017 = deconstruct_result1016 - self.pretty_reduce(unwrapped1017) + _t1658 = None + deconstruct_result1021 = _t1658 + if deconstruct_result1021 is not None: + assert deconstruct_result1021 is not None + unwrapped1022 = deconstruct_result1021 + self.pretty_reduce(unwrapped1022) else: _dollar_dollar = msg if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1649 = _dollar_dollar.conjunction + _t1659 = _dollar_dollar.conjunction else: - _t1649 = None - deconstruct_result1014 = _t1649 - if deconstruct_result1014 is not None: - assert deconstruct_result1014 is not None - unwrapped1015 = deconstruct_result1014 - self.pretty_conjunction(unwrapped1015) + _t1659 = None + deconstruct_result1019 = _t1659 + if deconstruct_result1019 is not None: + assert deconstruct_result1019 is not None + unwrapped1020 = deconstruct_result1019 + self.pretty_conjunction(unwrapped1020) else: _dollar_dollar = msg if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1650 = _dollar_dollar.disjunction + _t1660 = _dollar_dollar.disjunction else: - _t1650 = None - deconstruct_result1012 = _t1650 - if deconstruct_result1012 is not None: - assert deconstruct_result1012 is not None - unwrapped1013 = deconstruct_result1012 - self.pretty_disjunction(unwrapped1013) + _t1660 = None + deconstruct_result1017 = _t1660 + if deconstruct_result1017 is not None: + assert deconstruct_result1017 is not None + unwrapped1018 = deconstruct_result1017 + self.pretty_disjunction(unwrapped1018) else: _dollar_dollar = msg if _dollar_dollar.HasField("not"): - _t1651 = getattr(_dollar_dollar, 'not') + _t1661 = getattr(_dollar_dollar, 'not') else: - _t1651 = None - deconstruct_result1010 = _t1651 - if deconstruct_result1010 is not None: - assert deconstruct_result1010 is not None - unwrapped1011 = deconstruct_result1010 - self.pretty_not(unwrapped1011) + _t1661 = None + deconstruct_result1015 = _t1661 + if deconstruct_result1015 is not None: + assert deconstruct_result1015 is not None + unwrapped1016 = deconstruct_result1015 + self.pretty_not(unwrapped1016) else: _dollar_dollar = msg if _dollar_dollar.HasField("ffi"): - _t1652 = _dollar_dollar.ffi + _t1662 = _dollar_dollar.ffi else: - _t1652 = None - deconstruct_result1008 = _t1652 - if deconstruct_result1008 is not None: - assert deconstruct_result1008 is not None - unwrapped1009 = deconstruct_result1008 - self.pretty_ffi(unwrapped1009) + _t1662 = None + deconstruct_result1013 = _t1662 + if deconstruct_result1013 is not None: + assert deconstruct_result1013 is not None + unwrapped1014 = deconstruct_result1013 + self.pretty_ffi(unwrapped1014) else: _dollar_dollar = msg if _dollar_dollar.HasField("atom"): - _t1653 = _dollar_dollar.atom + _t1663 = _dollar_dollar.atom else: - _t1653 = None - deconstruct_result1006 = _t1653 - if deconstruct_result1006 is not None: - assert deconstruct_result1006 is not None - unwrapped1007 = deconstruct_result1006 - self.pretty_atom(unwrapped1007) + _t1663 = None + deconstruct_result1011 = _t1663 + if deconstruct_result1011 is not None: + assert deconstruct_result1011 is not None + unwrapped1012 = deconstruct_result1011 + self.pretty_atom(unwrapped1012) else: _dollar_dollar = msg if _dollar_dollar.HasField("pragma"): - _t1654 = _dollar_dollar.pragma + _t1664 = _dollar_dollar.pragma else: - _t1654 = None - deconstruct_result1004 = _t1654 - if deconstruct_result1004 is not None: - assert deconstruct_result1004 is not None - unwrapped1005 = deconstruct_result1004 - self.pretty_pragma(unwrapped1005) + _t1664 = None + deconstruct_result1009 = _t1664 + if deconstruct_result1009 is not None: + assert deconstruct_result1009 is not None + unwrapped1010 = deconstruct_result1009 + self.pretty_pragma(unwrapped1010) else: _dollar_dollar = msg if _dollar_dollar.HasField("primitive"): - _t1655 = _dollar_dollar.primitive + _t1665 = _dollar_dollar.primitive else: - _t1655 = None - deconstruct_result1002 = _t1655 - if deconstruct_result1002 is not None: - assert deconstruct_result1002 is not None - unwrapped1003 = deconstruct_result1002 - self.pretty_primitive(unwrapped1003) + _t1665 = None + deconstruct_result1007 = _t1665 + if deconstruct_result1007 is not None: + assert deconstruct_result1007 is not None + unwrapped1008 = deconstruct_result1007 + self.pretty_primitive(unwrapped1008) else: _dollar_dollar = msg if _dollar_dollar.HasField("rel_atom"): - _t1656 = _dollar_dollar.rel_atom + _t1666 = _dollar_dollar.rel_atom else: - _t1656 = None - deconstruct_result1000 = _t1656 - if deconstruct_result1000 is not None: - assert deconstruct_result1000 is not None - unwrapped1001 = deconstruct_result1000 - self.pretty_rel_atom(unwrapped1001) + _t1666 = None + deconstruct_result1005 = _t1666 + if deconstruct_result1005 is not None: + assert deconstruct_result1005 is not None + unwrapped1006 = deconstruct_result1005 + self.pretty_rel_atom(unwrapped1006) else: _dollar_dollar = msg if _dollar_dollar.HasField("cast"): - _t1657 = _dollar_dollar.cast + _t1667 = _dollar_dollar.cast else: - _t1657 = None - deconstruct_result998 = _t1657 - if deconstruct_result998 is not None: - assert deconstruct_result998 is not None - unwrapped999 = deconstruct_result998 - self.pretty_cast(unwrapped999) + _t1667 = None + deconstruct_result1003 = _t1667 + if deconstruct_result1003 is not None: + assert deconstruct_result1003 is not None + unwrapped1004 = deconstruct_result1003 + self.pretty_cast(unwrapped1004) else: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields1025 = msg + fields1030 = msg self.write("(true)") def pretty_false(self, msg: logic_pb2.Disjunction): - fields1026 = msg + fields1031 = msg self.write("(false)") def pretty_exists(self, msg: logic_pb2.Exists): - flat1031 = self._try_flat(msg, self.pretty_exists) - if flat1031 is not None: - assert flat1031 is not None - self.write(flat1031) + flat1036 = self._try_flat(msg, self.pretty_exists) + if flat1036 is not None: + assert flat1036 is not None + self.write(flat1036) return None else: _dollar_dollar = msg - _t1658 = self.deconstruct_bindings(_dollar_dollar.body) - fields1027 = (_t1658, _dollar_dollar.body.value,) - assert fields1027 is not None - unwrapped_fields1028 = fields1027 + _t1668 = self.deconstruct_bindings(_dollar_dollar.body) + fields1032 = (_t1668, _dollar_dollar.body.value,) + assert fields1032 is not None + unwrapped_fields1033 = fields1032 self.write("(exists") self.indent_sexp() self.newline() - field1029 = unwrapped_fields1028[0] - self.pretty_bindings(field1029) + field1034 = unwrapped_fields1033[0] + self.pretty_bindings(field1034) self.newline() - field1030 = unwrapped_fields1028[1] - self.pretty_formula(field1030) + field1035 = unwrapped_fields1033[1] + self.pretty_formula(field1035) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat1037 = self._try_flat(msg, self.pretty_reduce) - if flat1037 is not None: - assert flat1037 is not None - self.write(flat1037) + flat1042 = self._try_flat(msg, self.pretty_reduce) + if flat1042 is not None: + assert flat1042 is not None + self.write(flat1042) return None else: _dollar_dollar = msg - fields1032 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - assert fields1032 is not None - unwrapped_fields1033 = fields1032 + fields1037 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + assert fields1037 is not None + unwrapped_fields1038 = fields1037 self.write("(reduce") self.indent_sexp() self.newline() - field1034 = unwrapped_fields1033[0] - self.pretty_abstraction(field1034) + field1039 = unwrapped_fields1038[0] + self.pretty_abstraction(field1039) self.newline() - field1035 = unwrapped_fields1033[1] - self.pretty_abstraction(field1035) + field1040 = unwrapped_fields1038[1] + self.pretty_abstraction(field1040) self.newline() - field1036 = unwrapped_fields1033[2] - self.pretty_terms(field1036) + field1041 = unwrapped_fields1038[2] + self.pretty_terms(field1041) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat1041 = self._try_flat(msg, self.pretty_terms) - if flat1041 is not None: - assert flat1041 is not None - self.write(flat1041) + flat1046 = self._try_flat(msg, self.pretty_terms) + if flat1046 is not None: + assert flat1046 is not None + self.write(flat1046) return None else: - fields1038 = msg + fields1043 = msg self.write("(terms") self.indent_sexp() - if not len(fields1038) == 0: + if not len(fields1043) == 0: self.newline() - for i1040, elem1039 in enumerate(fields1038): - if (i1040 > 0): + for i1045, elem1044 in enumerate(fields1043): + if (i1045 > 0): self.newline() - self.pretty_term(elem1039) + self.pretty_term(elem1044) self.dedent() self.write(")") def pretty_term(self, msg: logic_pb2.Term): - flat1046 = self._try_flat(msg, self.pretty_term) - if flat1046 is not None: - assert flat1046 is not None - self.write(flat1046) + flat1051 = self._try_flat(msg, self.pretty_term) + if flat1051 is not None: + assert flat1051 is not None + self.write(flat1051) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("var"): - _t1659 = _dollar_dollar.var + _t1669 = _dollar_dollar.var else: - _t1659 = None - deconstruct_result1044 = _t1659 - if deconstruct_result1044 is not None: - assert deconstruct_result1044 is not None - unwrapped1045 = deconstruct_result1044 - self.pretty_var(unwrapped1045) + _t1669 = None + deconstruct_result1049 = _t1669 + if deconstruct_result1049 is not None: + assert deconstruct_result1049 is not None + unwrapped1050 = deconstruct_result1049 + self.pretty_var(unwrapped1050) else: _dollar_dollar = msg if _dollar_dollar.HasField("constant"): - _t1660 = _dollar_dollar.constant + _t1670 = _dollar_dollar.constant else: - _t1660 = None - deconstruct_result1042 = _t1660 - if deconstruct_result1042 is not None: - assert deconstruct_result1042 is not None - unwrapped1043 = deconstruct_result1042 - self.pretty_value(unwrapped1043) + _t1670 = None + deconstruct_result1047 = _t1670 + if deconstruct_result1047 is not None: + assert deconstruct_result1047 is not None + unwrapped1048 = deconstruct_result1047 + self.pretty_value(unwrapped1048) else: raise ParseError("No matching rule for term") def pretty_var(self, msg: logic_pb2.Var): - flat1049 = self._try_flat(msg, self.pretty_var) - if flat1049 is not None: - assert flat1049 is not None - self.write(flat1049) + flat1054 = self._try_flat(msg, self.pretty_var) + if flat1054 is not None: + assert flat1054 is not None + self.write(flat1054) return None else: _dollar_dollar = msg - fields1047 = _dollar_dollar.name - assert fields1047 is not None - unwrapped_fields1048 = fields1047 - self.write(unwrapped_fields1048) + fields1052 = _dollar_dollar.name + assert fields1052 is not None + unwrapped_fields1053 = fields1052 + self.write(unwrapped_fields1053) def pretty_value(self, msg: logic_pb2.Value): - flat1075 = self._try_flat(msg, self.pretty_value) - if flat1075 is not None: - assert flat1075 is not None - self.write(flat1075) + flat1080 = self._try_flat(msg, self.pretty_value) + if flat1080 is not None: + assert flat1080 is not None + self.write(flat1080) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1661 = _dollar_dollar.date_value + _t1671 = _dollar_dollar.date_value else: - _t1661 = None - deconstruct_result1073 = _t1661 - if deconstruct_result1073 is not None: - assert deconstruct_result1073 is not None - unwrapped1074 = deconstruct_result1073 - self.pretty_date(unwrapped1074) + _t1671 = None + deconstruct_result1078 = _t1671 + if deconstruct_result1078 is not None: + assert deconstruct_result1078 is not None + unwrapped1079 = deconstruct_result1078 + self.pretty_date(unwrapped1079) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1662 = _dollar_dollar.datetime_value + _t1672 = _dollar_dollar.datetime_value else: - _t1662 = None - deconstruct_result1071 = _t1662 - if deconstruct_result1071 is not None: - assert deconstruct_result1071 is not None - unwrapped1072 = deconstruct_result1071 - self.pretty_datetime(unwrapped1072) + _t1672 = None + deconstruct_result1076 = _t1672 + if deconstruct_result1076 is not None: + assert deconstruct_result1076 is not None + unwrapped1077 = deconstruct_result1076 + self.pretty_datetime(unwrapped1077) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1663 = _dollar_dollar.string_value + _t1673 = _dollar_dollar.string_value else: - _t1663 = None - deconstruct_result1069 = _t1663 - if deconstruct_result1069 is not None: - assert deconstruct_result1069 is not None - unwrapped1070 = deconstruct_result1069 - self.write(self.format_string_value(unwrapped1070)) + _t1673 = None + deconstruct_result1074 = _t1673 + if deconstruct_result1074 is not None: + assert deconstruct_result1074 is not None + unwrapped1075 = deconstruct_result1074 + self.write(self.format_string_value(unwrapped1075)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1664 = _dollar_dollar.int32_value + _t1674 = _dollar_dollar.int32_value else: - _t1664 = None - deconstruct_result1067 = _t1664 - if deconstruct_result1067 is not None: - assert deconstruct_result1067 is not None - unwrapped1068 = deconstruct_result1067 - self.write((str(unwrapped1068) + 'i32')) + _t1674 = None + deconstruct_result1072 = _t1674 + if deconstruct_result1072 is not None: + assert deconstruct_result1072 is not None + unwrapped1073 = deconstruct_result1072 + self.write((str(unwrapped1073) + 'i32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1665 = _dollar_dollar.int_value + _t1675 = _dollar_dollar.int_value else: - _t1665 = None - deconstruct_result1065 = _t1665 - if deconstruct_result1065 is not None: - assert deconstruct_result1065 is not None - unwrapped1066 = deconstruct_result1065 - self.write(str(unwrapped1066)) + _t1675 = None + deconstruct_result1070 = _t1675 + if deconstruct_result1070 is not None: + assert deconstruct_result1070 is not None + unwrapped1071 = deconstruct_result1070 + self.write(str(unwrapped1071)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1666 = _dollar_dollar.float32_value + _t1676 = _dollar_dollar.float32_value else: - _t1666 = None - deconstruct_result1063 = _t1666 - if deconstruct_result1063 is not None: - assert deconstruct_result1063 is not None - unwrapped1064 = deconstruct_result1063 - self.write(self.format_float32_literal(unwrapped1064)) + _t1676 = None + deconstruct_result1068 = _t1676 + if deconstruct_result1068 is not None: + assert deconstruct_result1068 is not None + unwrapped1069 = deconstruct_result1068 + self.write(self.format_float32_literal(unwrapped1069)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1667 = _dollar_dollar.float_value + _t1677 = _dollar_dollar.float_value else: - _t1667 = None - deconstruct_result1061 = _t1667 - if deconstruct_result1061 is not None: - assert deconstruct_result1061 is not None - unwrapped1062 = deconstruct_result1061 - self.write(str(unwrapped1062)) + _t1677 = None + deconstruct_result1066 = _t1677 + if deconstruct_result1066 is not None: + assert deconstruct_result1066 is not None + unwrapped1067 = deconstruct_result1066 + self.write(str(unwrapped1067)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1668 = _dollar_dollar.uint32_value + _t1678 = _dollar_dollar.uint32_value else: - _t1668 = None - deconstruct_result1059 = _t1668 - if deconstruct_result1059 is not None: - assert deconstruct_result1059 is not None - unwrapped1060 = deconstruct_result1059 - self.write((str(unwrapped1060) + 'u32')) + _t1678 = None + deconstruct_result1064 = _t1678 + if deconstruct_result1064 is not None: + assert deconstruct_result1064 is not None + unwrapped1065 = deconstruct_result1064 + self.write((str(unwrapped1065) + 'u32')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1669 = _dollar_dollar.uint128_value + _t1679 = _dollar_dollar.uint128_value else: - _t1669 = None - deconstruct_result1057 = _t1669 - if deconstruct_result1057 is not None: - assert deconstruct_result1057 is not None - unwrapped1058 = deconstruct_result1057 - self.write(self.format_uint128(unwrapped1058)) + _t1679 = None + deconstruct_result1062 = _t1679 + if deconstruct_result1062 is not None: + assert deconstruct_result1062 is not None + unwrapped1063 = deconstruct_result1062 + self.write(self.format_uint128(unwrapped1063)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1670 = _dollar_dollar.int128_value + _t1680 = _dollar_dollar.int128_value else: - _t1670 = None - deconstruct_result1055 = _t1670 - if deconstruct_result1055 is not None: - assert deconstruct_result1055 is not None - unwrapped1056 = deconstruct_result1055 - self.write(self.format_int128(unwrapped1056)) + _t1680 = None + deconstruct_result1060 = _t1680 + if deconstruct_result1060 is not None: + assert deconstruct_result1060 is not None + unwrapped1061 = deconstruct_result1060 + self.write(self.format_int128(unwrapped1061)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1671 = _dollar_dollar.decimal_value + _t1681 = _dollar_dollar.decimal_value else: - _t1671 = None - deconstruct_result1053 = _t1671 - if deconstruct_result1053 is not None: - assert deconstruct_result1053 is not None - unwrapped1054 = deconstruct_result1053 - self.write(self.format_decimal(unwrapped1054)) + _t1681 = None + deconstruct_result1058 = _t1681 + if deconstruct_result1058 is not None: + assert deconstruct_result1058 is not None + unwrapped1059 = deconstruct_result1058 + self.write(self.format_decimal(unwrapped1059)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1672 = _dollar_dollar.boolean_value + _t1682 = _dollar_dollar.boolean_value else: - _t1672 = None - deconstruct_result1051 = _t1672 - if deconstruct_result1051 is not None: - assert deconstruct_result1051 is not None - unwrapped1052 = deconstruct_result1051 - self.pretty_boolean_value(unwrapped1052) + _t1682 = None + deconstruct_result1056 = _t1682 + if deconstruct_result1056 is not None: + assert deconstruct_result1056 is not None + unwrapped1057 = deconstruct_result1056 + self.pretty_boolean_value(unwrapped1057) else: - fields1050 = msg + fields1055 = msg self.write("missing") def pretty_date(self, msg: logic_pb2.DateValue): - flat1081 = self._try_flat(msg, self.pretty_date) - if flat1081 is not None: - assert flat1081 is not None - self.write(flat1081) + flat1086 = self._try_flat(msg, self.pretty_date) + if flat1086 is not None: + assert flat1086 is not None + self.write(flat1086) return None else: _dollar_dollar = msg - fields1076 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields1076 is not None - unwrapped_fields1077 = fields1076 + fields1081 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields1081 is not None + unwrapped_fields1082 = fields1081 self.write("(date") self.indent_sexp() self.newline() - field1078 = unwrapped_fields1077[0] - self.write(str(field1078)) + field1083 = unwrapped_fields1082[0] + self.write(str(field1083)) self.newline() - field1079 = unwrapped_fields1077[1] - self.write(str(field1079)) + field1084 = unwrapped_fields1082[1] + self.write(str(field1084)) self.newline() - field1080 = unwrapped_fields1077[2] - self.write(str(field1080)) + field1085 = unwrapped_fields1082[2] + self.write(str(field1085)) self.dedent() self.write(")") def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat1092 = self._try_flat(msg, self.pretty_datetime) - if flat1092 is not None: - assert flat1092 is not None - self.write(flat1092) + flat1097 = self._try_flat(msg, self.pretty_datetime) + if flat1097 is not None: + assert flat1097 is not None + self.write(flat1097) return None else: _dollar_dollar = msg - fields1082 = (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 fields1082 is not None - unwrapped_fields1083 = fields1082 + fields1087 = (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 fields1087 is not None + unwrapped_fields1088 = fields1087 self.write("(datetime") self.indent_sexp() self.newline() - field1084 = unwrapped_fields1083[0] - self.write(str(field1084)) + field1089 = unwrapped_fields1088[0] + self.write(str(field1089)) self.newline() - field1085 = unwrapped_fields1083[1] - self.write(str(field1085)) + field1090 = unwrapped_fields1088[1] + self.write(str(field1090)) self.newline() - field1086 = unwrapped_fields1083[2] - self.write(str(field1086)) + field1091 = unwrapped_fields1088[2] + self.write(str(field1091)) self.newline() - field1087 = unwrapped_fields1083[3] - self.write(str(field1087)) + field1092 = unwrapped_fields1088[3] + self.write(str(field1092)) self.newline() - field1088 = unwrapped_fields1083[4] - self.write(str(field1088)) + field1093 = unwrapped_fields1088[4] + self.write(str(field1093)) self.newline() - field1089 = unwrapped_fields1083[5] - self.write(str(field1089)) - field1090 = unwrapped_fields1083[6] - if field1090 is not None: + field1094 = unwrapped_fields1088[5] + self.write(str(field1094)) + field1095 = unwrapped_fields1088[6] + if field1095 is not None: self.newline() - assert field1090 is not None - opt_val1091 = field1090 - self.write(str(opt_val1091)) + assert field1095 is not None + opt_val1096 = field1095 + self.write(str(opt_val1096)) self.dedent() self.write(")") def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat1097 = self._try_flat(msg, self.pretty_conjunction) - if flat1097 is not None: - assert flat1097 is not None - self.write(flat1097) + flat1102 = self._try_flat(msg, self.pretty_conjunction) + if flat1102 is not None: + assert flat1102 is not None + self.write(flat1102) return None else: _dollar_dollar = msg - fields1093 = _dollar_dollar.args - assert fields1093 is not None - unwrapped_fields1094 = fields1093 + fields1098 = _dollar_dollar.args + assert fields1098 is not None + unwrapped_fields1099 = fields1098 self.write("(and") self.indent_sexp() - if not len(unwrapped_fields1094) == 0: + if not len(unwrapped_fields1099) == 0: self.newline() - for i1096, elem1095 in enumerate(unwrapped_fields1094): - if (i1096 > 0): + for i1101, elem1100 in enumerate(unwrapped_fields1099): + if (i1101 > 0): self.newline() - self.pretty_formula(elem1095) + self.pretty_formula(elem1100) self.dedent() self.write(")") def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat1102 = self._try_flat(msg, self.pretty_disjunction) - if flat1102 is not None: - assert flat1102 is not None - self.write(flat1102) + flat1107 = self._try_flat(msg, self.pretty_disjunction) + if flat1107 is not None: + assert flat1107 is not None + self.write(flat1107) return None else: _dollar_dollar = msg - fields1098 = _dollar_dollar.args - assert fields1098 is not None - unwrapped_fields1099 = fields1098 + fields1103 = _dollar_dollar.args + assert fields1103 is not None + unwrapped_fields1104 = fields1103 self.write("(or") self.indent_sexp() - if not len(unwrapped_fields1099) == 0: + if not len(unwrapped_fields1104) == 0: self.newline() - for i1101, elem1100 in enumerate(unwrapped_fields1099): - if (i1101 > 0): + for i1106, elem1105 in enumerate(unwrapped_fields1104): + if (i1106 > 0): self.newline() - self.pretty_formula(elem1100) + self.pretty_formula(elem1105) self.dedent() self.write(")") def pretty_not(self, msg: logic_pb2.Not): - flat1105 = self._try_flat(msg, self.pretty_not) - if flat1105 is not None: - assert flat1105 is not None - self.write(flat1105) + flat1110 = self._try_flat(msg, self.pretty_not) + if flat1110 is not None: + assert flat1110 is not None + self.write(flat1110) return None else: _dollar_dollar = msg - fields1103 = _dollar_dollar.arg - assert fields1103 is not None - unwrapped_fields1104 = fields1103 + fields1108 = _dollar_dollar.arg + assert fields1108 is not None + unwrapped_fields1109 = fields1108 self.write("(not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields1104) + self.pretty_formula(unwrapped_fields1109) self.dedent() self.write(")") def pretty_ffi(self, msg: logic_pb2.FFI): - flat1111 = self._try_flat(msg, self.pretty_ffi) - if flat1111 is not None: - assert flat1111 is not None - self.write(flat1111) + flat1116 = self._try_flat(msg, self.pretty_ffi) + if flat1116 is not None: + assert flat1116 is not None + self.write(flat1116) return None else: _dollar_dollar = msg - fields1106 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - assert fields1106 is not None - unwrapped_fields1107 = fields1106 + fields1111 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + assert fields1111 is not None + unwrapped_fields1112 = fields1111 self.write("(ffi") self.indent_sexp() self.newline() - field1108 = unwrapped_fields1107[0] - self.pretty_name(field1108) + field1113 = unwrapped_fields1112[0] + self.pretty_name(field1113) self.newline() - field1109 = unwrapped_fields1107[1] - self.pretty_ffi_args(field1109) + field1114 = unwrapped_fields1112[1] + self.pretty_ffi_args(field1114) self.newline() - field1110 = unwrapped_fields1107[2] - self.pretty_terms(field1110) + field1115 = unwrapped_fields1112[2] + self.pretty_terms(field1115) self.dedent() self.write(")") def pretty_name(self, msg: str): - flat1113 = self._try_flat(msg, self.pretty_name) - if flat1113 is not None: - assert flat1113 is not None - self.write(flat1113) + flat1118 = self._try_flat(msg, self.pretty_name) + if flat1118 is not None: + assert flat1118 is not None + self.write(flat1118) return None else: - fields1112 = msg + fields1117 = msg self.write(":") - self.write(fields1112) + self.write(fields1117) def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat1117 = self._try_flat(msg, self.pretty_ffi_args) - if flat1117 is not None: - assert flat1117 is not None - self.write(flat1117) + flat1122 = self._try_flat(msg, self.pretty_ffi_args) + if flat1122 is not None: + assert flat1122 is not None + self.write(flat1122) return None else: - fields1114 = msg + fields1119 = msg self.write("(args") self.indent_sexp() - if not len(fields1114) == 0: + if not len(fields1119) == 0: self.newline() - for i1116, elem1115 in enumerate(fields1114): - if (i1116 > 0): + for i1121, elem1120 in enumerate(fields1119): + if (i1121 > 0): self.newline() - self.pretty_abstraction(elem1115) + self.pretty_abstraction(elem1120) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat1124 = self._try_flat(msg, self.pretty_atom) - if flat1124 is not None: - assert flat1124 is not None - self.write(flat1124) + flat1129 = self._try_flat(msg, self.pretty_atom) + if flat1129 is not None: + assert flat1129 is not None + self.write(flat1129) return None else: _dollar_dollar = msg - fields1118 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1118 is not None - unwrapped_fields1119 = fields1118 + fields1123 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1123 is not None + unwrapped_fields1124 = fields1123 self.write("(atom") self.indent_sexp() self.newline() - field1120 = unwrapped_fields1119[0] - self.pretty_relation_id(field1120) - field1121 = unwrapped_fields1119[1] - if not len(field1121) == 0: + field1125 = unwrapped_fields1124[0] + self.pretty_relation_id(field1125) + field1126 = unwrapped_fields1124[1] + if not len(field1126) == 0: self.newline() - for i1123, elem1122 in enumerate(field1121): - if (i1123 > 0): + for i1128, elem1127 in enumerate(field1126): + if (i1128 > 0): self.newline() - self.pretty_term(elem1122) + self.pretty_term(elem1127) self.dedent() self.write(")") def pretty_pragma(self, msg: logic_pb2.Pragma): - flat1131 = self._try_flat(msg, self.pretty_pragma) - if flat1131 is not None: - assert flat1131 is not None - self.write(flat1131) + flat1136 = self._try_flat(msg, self.pretty_pragma) + if flat1136 is not None: + assert flat1136 is not None + self.write(flat1136) return None else: _dollar_dollar = msg - fields1125 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1125 is not None - unwrapped_fields1126 = fields1125 + fields1130 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1130 is not None + unwrapped_fields1131 = fields1130 self.write("(pragma") self.indent_sexp() self.newline() - field1127 = unwrapped_fields1126[0] - self.pretty_name(field1127) - field1128 = unwrapped_fields1126[1] - if not len(field1128) == 0: + field1132 = unwrapped_fields1131[0] + self.pretty_name(field1132) + field1133 = unwrapped_fields1131[1] + if not len(field1133) == 0: self.newline() - for i1130, elem1129 in enumerate(field1128): - if (i1130 > 0): + for i1135, elem1134 in enumerate(field1133): + if (i1135 > 0): self.newline() - self.pretty_term(elem1129) + self.pretty_term(elem1134) self.dedent() self.write(")") def pretty_primitive(self, msg: logic_pb2.Primitive): - flat1147 = self._try_flat(msg, self.pretty_primitive) - if flat1147 is not None: - assert flat1147 is not None - self.write(flat1147) + flat1152 = self._try_flat(msg, self.pretty_primitive) + if flat1152 is not None: + assert flat1152 is not None + self.write(flat1152) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq": - _t1673 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1683 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1673 = None - guard_result1146 = _t1673 - if guard_result1146 is not None: + _t1683 = None + guard_result1151 = _t1683 + if guard_result1151 is not None: self.pretty_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1674 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1684 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1674 = None - guard_result1145 = _t1674 - if guard_result1145 is not None: + _t1684 = None + guard_result1150 = _t1684 + if guard_result1150 is not None: self.pretty_lt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1675 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1685 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1675 = None - guard_result1144 = _t1675 - if guard_result1144 is not None: + _t1685 = None + guard_result1149 = _t1685 + if guard_result1149 is not None: self.pretty_lt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1676 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1686 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1676 = None - guard_result1143 = _t1676 - if guard_result1143 is not None: + _t1686 = None + guard_result1148 = _t1686 + if guard_result1148 is not None: self.pretty_gt(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1677 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1687 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1677 = None - guard_result1142 = _t1677 - if guard_result1142 is not None: + _t1687 = None + guard_result1147 = _t1687 + if guard_result1147 is not None: self.pretty_gt_eq(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1678 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1688 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1678 = None - guard_result1141 = _t1678 - if guard_result1141 is not None: + _t1688 = None + guard_result1146 = _t1688 + if guard_result1146 is not None: self.pretty_add(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1679 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1689 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1679 = None - guard_result1140 = _t1679 - if guard_result1140 is not None: + _t1689 = None + guard_result1145 = _t1689 + if guard_result1145 is not None: self.pretty_minus(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1680 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1690 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1680 = None - guard_result1139 = _t1680 - if guard_result1139 is not None: + _t1690 = None + guard_result1144 = _t1690 + if guard_result1144 is not None: self.pretty_multiply(msg) else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1681 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1691 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1681 = None - guard_result1138 = _t1681 - if guard_result1138 is not None: + _t1691 = None + guard_result1143 = _t1691 + if guard_result1143 is not None: self.pretty_divide(msg) else: _dollar_dollar = msg - fields1132 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1132 is not None - unwrapped_fields1133 = fields1132 + fields1137 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1137 is not None + unwrapped_fields1138 = fields1137 self.write("(primitive") self.indent_sexp() self.newline() - field1134 = unwrapped_fields1133[0] - self.pretty_name(field1134) - field1135 = unwrapped_fields1133[1] - if not len(field1135) == 0: + field1139 = unwrapped_fields1138[0] + self.pretty_name(field1139) + field1140 = unwrapped_fields1138[1] + if not len(field1140) == 0: self.newline() - for i1137, elem1136 in enumerate(field1135): - if (i1137 > 0): + for i1142, elem1141 in enumerate(field1140): + if (i1142 > 0): self.newline() - self.pretty_rel_term(elem1136) + self.pretty_rel_term(elem1141) self.dedent() self.write(")") def pretty_eq(self, msg: logic_pb2.Primitive): - flat1152 = self._try_flat(msg, self.pretty_eq) - if flat1152 is not None: - assert flat1152 is not None - self.write(flat1152) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_eq": - _t1682 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1682 = None - fields1148 = _t1682 - assert fields1148 is not None - unwrapped_fields1149 = fields1148 - self.write("(=") - self.indent_sexp() - self.newline() - field1150 = unwrapped_fields1149[0] - self.pretty_term(field1150) - self.newline() - field1151 = unwrapped_fields1149[1] - self.pretty_term(field1151) - self.dedent() - self.write(")") - - def pretty_lt(self, msg: logic_pb2.Primitive): - flat1157 = self._try_flat(msg, self.pretty_lt) + flat1157 = self._try_flat(msg, self.pretty_eq) if flat1157 is not None: assert flat1157 is not None self.write(flat1157) return None else: _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1683 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + if _dollar_dollar.name == "rel_primitive_eq": + _t1692 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1683 = None - fields1153 = _t1683 + _t1692 = None + fields1153 = _t1692 assert fields1153 is not None unwrapped_fields1154 = fields1153 - self.write("(<") + self.write("(=") self.indent_sexp() self.newline() field1155 = unwrapped_fields1154[0] @@ -2221,22 +2198,22 @@ def pretty_lt(self, msg: logic_pb2.Primitive): self.dedent() self.write(")") - def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat1162 = self._try_flat(msg, self.pretty_lt_eq) + def pretty_lt(self, msg: logic_pb2.Primitive): + flat1162 = self._try_flat(msg, self.pretty_lt) if flat1162 is not None: assert flat1162 is not None self.write(flat1162) return None else: _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1684 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + if _dollar_dollar.name == "rel_primitive_lt_monotype": + _t1693 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1684 = None - fields1158 = _t1684 + _t1693 = None + fields1158 = _t1693 assert fields1158 is not None unwrapped_fields1159 = fields1158 - self.write("(<=") + self.write("(<") self.indent_sexp() self.newline() field1160 = unwrapped_fields1159[0] @@ -2247,22 +2224,22 @@ def pretty_lt_eq(self, msg: logic_pb2.Primitive): self.dedent() self.write(")") - def pretty_gt(self, msg: logic_pb2.Primitive): - flat1167 = self._try_flat(msg, self.pretty_gt) + def pretty_lt_eq(self, msg: logic_pb2.Primitive): + flat1167 = self._try_flat(msg, self.pretty_lt_eq) if flat1167 is not None: assert flat1167 is not None self.write(flat1167) return None else: _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1685 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": + _t1694 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1685 = None - fields1163 = _t1685 + _t1694 = None + fields1163 = _t1694 assert fields1163 is not None unwrapped_fields1164 = fields1163 - self.write("(>") + self.write("(<=") self.indent_sexp() self.newline() field1165 = unwrapped_fields1164[0] @@ -2273,22 +2250,22 @@ def pretty_gt(self, msg: logic_pb2.Primitive): self.dedent() self.write(")") - def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat1172 = self._try_flat(msg, self.pretty_gt_eq) + def pretty_gt(self, msg: logic_pb2.Primitive): + flat1172 = self._try_flat(msg, self.pretty_gt) if flat1172 is not None: assert flat1172 is not None self.write(flat1172) return None else: _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1686 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + if _dollar_dollar.name == "rel_primitive_gt_monotype": + _t1695 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1686 = None - fields1168 = _t1686 + _t1695 = None + fields1168 = _t1695 assert fields1168 is not None unwrapped_fields1169 = fields1168 - self.write("(>=") + self.write("(>") self.indent_sexp() self.newline() field1170 = unwrapped_fields1169[0] @@ -2299,22 +2276,22 @@ def pretty_gt_eq(self, msg: logic_pb2.Primitive): self.dedent() self.write(")") - def pretty_add(self, msg: logic_pb2.Primitive): - flat1178 = self._try_flat(msg, self.pretty_add) - if flat1178 is not None: - assert flat1178 is not None - self.write(flat1178) + def pretty_gt_eq(self, msg: logic_pb2.Primitive): + flat1177 = self._try_flat(msg, self.pretty_gt_eq) + if flat1177 is not None: + assert flat1177 is not None + self.write(flat1177) return None else: _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1687 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": + _t1696 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1687 = None - fields1173 = _t1687 + _t1696 = None + fields1173 = _t1696 assert fields1173 is not None unwrapped_fields1174 = fields1173 - self.write("(+") + self.write("(>=") self.indent_sexp() self.newline() field1175 = unwrapped_fields1174[0] @@ -2322,2062 +2299,2130 @@ def pretty_add(self, msg: logic_pb2.Primitive): self.newline() field1176 = unwrapped_fields1174[1] self.pretty_term(field1176) + self.dedent() + self.write(")") + + def pretty_add(self, msg: logic_pb2.Primitive): + flat1183 = self._try_flat(msg, self.pretty_add) + if flat1183 is not None: + assert flat1183 is not None + self.write(flat1183) + return None + else: + _dollar_dollar = msg + if _dollar_dollar.name == "rel_primitive_add_monotype": + _t1697 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + else: + _t1697 = None + fields1178 = _t1697 + assert fields1178 is not None + unwrapped_fields1179 = fields1178 + self.write("(+") + self.indent_sexp() + self.newline() + field1180 = unwrapped_fields1179[0] + self.pretty_term(field1180) self.newline() - field1177 = unwrapped_fields1174[2] - self.pretty_term(field1177) + field1181 = unwrapped_fields1179[1] + self.pretty_term(field1181) + self.newline() + field1182 = unwrapped_fields1179[2] + self.pretty_term(field1182) self.dedent() self.write(")") def pretty_minus(self, msg: logic_pb2.Primitive): - flat1184 = self._try_flat(msg, self.pretty_minus) - if flat1184 is not None: - assert flat1184 is not None - self.write(flat1184) + flat1189 = self._try_flat(msg, self.pretty_minus) + if flat1189 is not None: + assert flat1189 is not None + self.write(flat1189) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1688 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1698 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1688 = None - fields1179 = _t1688 - assert fields1179 is not None - unwrapped_fields1180 = fields1179 + _t1698 = None + fields1184 = _t1698 + assert fields1184 is not None + unwrapped_fields1185 = fields1184 self.write("(-") self.indent_sexp() self.newline() - field1181 = unwrapped_fields1180[0] - self.pretty_term(field1181) + field1186 = unwrapped_fields1185[0] + self.pretty_term(field1186) self.newline() - field1182 = unwrapped_fields1180[1] - self.pretty_term(field1182) + field1187 = unwrapped_fields1185[1] + self.pretty_term(field1187) self.newline() - field1183 = unwrapped_fields1180[2] - self.pretty_term(field1183) + field1188 = unwrapped_fields1185[2] + self.pretty_term(field1188) self.dedent() self.write(")") def pretty_multiply(self, msg: logic_pb2.Primitive): - flat1190 = self._try_flat(msg, self.pretty_multiply) - if flat1190 is not None: - assert flat1190 is not None - self.write(flat1190) + flat1195 = self._try_flat(msg, self.pretty_multiply) + if flat1195 is not None: + assert flat1195 is not None + self.write(flat1195) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1689 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1699 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1689 = None - fields1185 = _t1689 - assert fields1185 is not None - unwrapped_fields1186 = fields1185 + _t1699 = None + fields1190 = _t1699 + assert fields1190 is not None + unwrapped_fields1191 = fields1190 self.write("(*") self.indent_sexp() self.newline() - field1187 = unwrapped_fields1186[0] - self.pretty_term(field1187) + field1192 = unwrapped_fields1191[0] + self.pretty_term(field1192) self.newline() - field1188 = unwrapped_fields1186[1] - self.pretty_term(field1188) + field1193 = unwrapped_fields1191[1] + self.pretty_term(field1193) self.newline() - field1189 = unwrapped_fields1186[2] - self.pretty_term(field1189) + field1194 = unwrapped_fields1191[2] + self.pretty_term(field1194) self.dedent() self.write(")") def pretty_divide(self, msg: logic_pb2.Primitive): - flat1196 = self._try_flat(msg, self.pretty_divide) - if flat1196 is not None: - assert flat1196 is not None - self.write(flat1196) + flat1201 = self._try_flat(msg, self.pretty_divide) + if flat1201 is not None: + assert flat1201 is not None + self.write(flat1201) return None else: _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1690 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1700 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1690 = None - fields1191 = _t1690 - assert fields1191 is not None - unwrapped_fields1192 = fields1191 + _t1700 = None + fields1196 = _t1700 + assert fields1196 is not None + unwrapped_fields1197 = fields1196 self.write("(/") self.indent_sexp() self.newline() - field1193 = unwrapped_fields1192[0] - self.pretty_term(field1193) + field1198 = unwrapped_fields1197[0] + self.pretty_term(field1198) self.newline() - field1194 = unwrapped_fields1192[1] - self.pretty_term(field1194) + field1199 = unwrapped_fields1197[1] + self.pretty_term(field1199) self.newline() - field1195 = unwrapped_fields1192[2] - self.pretty_term(field1195) + field1200 = unwrapped_fields1197[2] + self.pretty_term(field1200) self.dedent() self.write(")") def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat1201 = self._try_flat(msg, self.pretty_rel_term) - if flat1201 is not None: - assert flat1201 is not None - self.write(flat1201) + flat1206 = self._try_flat(msg, self.pretty_rel_term) + if flat1206 is not None: + assert flat1206 is not None + self.write(flat1206) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("specialized_value"): - _t1691 = _dollar_dollar.specialized_value + _t1701 = _dollar_dollar.specialized_value else: - _t1691 = None - deconstruct_result1199 = _t1691 - if deconstruct_result1199 is not None: - assert deconstruct_result1199 is not None - unwrapped1200 = deconstruct_result1199 - self.pretty_specialized_value(unwrapped1200) + _t1701 = None + deconstruct_result1204 = _t1701 + if deconstruct_result1204 is not None: + assert deconstruct_result1204 is not None + unwrapped1205 = deconstruct_result1204 + self.pretty_specialized_value(unwrapped1205) else: _dollar_dollar = msg if _dollar_dollar.HasField("term"): - _t1692 = _dollar_dollar.term + _t1702 = _dollar_dollar.term else: - _t1692 = None - deconstruct_result1197 = _t1692 - if deconstruct_result1197 is not None: - assert deconstruct_result1197 is not None - unwrapped1198 = deconstruct_result1197 - self.pretty_term(unwrapped1198) + _t1702 = None + deconstruct_result1202 = _t1702 + if deconstruct_result1202 is not None: + assert deconstruct_result1202 is not None + unwrapped1203 = deconstruct_result1202 + self.pretty_term(unwrapped1203) else: raise ParseError("No matching rule for rel_term") def pretty_specialized_value(self, msg: logic_pb2.Value): - flat1203 = self._try_flat(msg, self.pretty_specialized_value) - if flat1203 is not None: - assert flat1203 is not None - self.write(flat1203) + flat1208 = self._try_flat(msg, self.pretty_specialized_value) + if flat1208 is not None: + assert flat1208 is not None + self.write(flat1208) return None else: - fields1202 = msg + fields1207 = msg self.write("#") - self.pretty_raw_value(fields1202) + self.pretty_raw_value(fields1207) def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat1210 = self._try_flat(msg, self.pretty_rel_atom) - if flat1210 is not None: - assert flat1210 is not None - self.write(flat1210) + flat1215 = self._try_flat(msg, self.pretty_rel_atom) + if flat1215 is not None: + assert flat1215 is not None + self.write(flat1215) return None else: _dollar_dollar = msg - fields1204 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1204 is not None - unwrapped_fields1205 = fields1204 + fields1209 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1209 is not None + unwrapped_fields1210 = fields1209 self.write("(relatom") self.indent_sexp() self.newline() - field1206 = unwrapped_fields1205[0] - self.pretty_name(field1206) - field1207 = unwrapped_fields1205[1] - if not len(field1207) == 0: + field1211 = unwrapped_fields1210[0] + self.pretty_name(field1211) + field1212 = unwrapped_fields1210[1] + if not len(field1212) == 0: self.newline() - for i1209, elem1208 in enumerate(field1207): - if (i1209 > 0): + for i1214, elem1213 in enumerate(field1212): + if (i1214 > 0): self.newline() - self.pretty_rel_term(elem1208) + self.pretty_rel_term(elem1213) self.dedent() self.write(")") def pretty_cast(self, msg: logic_pb2.Cast): - flat1215 = self._try_flat(msg, self.pretty_cast) - if flat1215 is not None: - assert flat1215 is not None - self.write(flat1215) + flat1220 = self._try_flat(msg, self.pretty_cast) + if flat1220 is not None: + assert flat1220 is not None + self.write(flat1220) return None else: _dollar_dollar = msg - fields1211 = (_dollar_dollar.input, _dollar_dollar.result,) - assert fields1211 is not None - unwrapped_fields1212 = fields1211 + fields1216 = (_dollar_dollar.input, _dollar_dollar.result,) + assert fields1216 is not None + unwrapped_fields1217 = fields1216 self.write("(cast") self.indent_sexp() self.newline() - field1213 = unwrapped_fields1212[0] - self.pretty_term(field1213) + field1218 = unwrapped_fields1217[0] + self.pretty_term(field1218) self.newline() - field1214 = unwrapped_fields1212[1] - self.pretty_term(field1214) + field1219 = unwrapped_fields1217[1] + self.pretty_term(field1219) self.dedent() self.write(")") def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1219 = self._try_flat(msg, self.pretty_attrs) - if flat1219 is not None: - assert flat1219 is not None - self.write(flat1219) + flat1224 = self._try_flat(msg, self.pretty_attrs) + if flat1224 is not None: + assert flat1224 is not None + self.write(flat1224) return None else: - fields1216 = msg + fields1221 = msg self.write("(attrs") self.indent_sexp() - if not len(fields1216) == 0: + if not len(fields1221) == 0: self.newline() - for i1218, elem1217 in enumerate(fields1216): - if (i1218 > 0): + for i1223, elem1222 in enumerate(fields1221): + if (i1223 > 0): self.newline() - self.pretty_attribute(elem1217) + self.pretty_attribute(elem1222) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1226 = self._try_flat(msg, self.pretty_attribute) - if flat1226 is not None: - assert flat1226 is not None - self.write(flat1226) + flat1231 = self._try_flat(msg, self.pretty_attribute) + if flat1231 is not None: + assert flat1231 is not None + self.write(flat1231) return None else: _dollar_dollar = msg - fields1220 = (_dollar_dollar.name, _dollar_dollar.args,) - assert fields1220 is not None - unwrapped_fields1221 = fields1220 + fields1225 = (_dollar_dollar.name, _dollar_dollar.args,) + assert fields1225 is not None + unwrapped_fields1226 = fields1225 self.write("(attribute") self.indent_sexp() self.newline() - field1222 = unwrapped_fields1221[0] - self.pretty_name(field1222) - field1223 = unwrapped_fields1221[1] - if not len(field1223) == 0: + field1227 = unwrapped_fields1226[0] + self.pretty_name(field1227) + field1228 = unwrapped_fields1226[1] + if not len(field1228) == 0: self.newline() - for i1225, elem1224 in enumerate(field1223): - if (i1225 > 0): + for i1230, elem1229 in enumerate(field1228): + if (i1230 > 0): self.newline() - self.pretty_raw_value(elem1224) + self.pretty_raw_value(elem1229) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1235 = self._try_flat(msg, self.pretty_algorithm) - if flat1235 is not None: - assert flat1235 is not None - self.write(flat1235) + flat1240 = self._try_flat(msg, self.pretty_algorithm) + if flat1240 is not None: + assert flat1240 is not None + self.write(flat1240) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1693 = _dollar_dollar.attrs + _t1703 = _dollar_dollar.attrs else: - _t1693 = None - fields1227 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1693,) - assert fields1227 is not None - unwrapped_fields1228 = fields1227 + _t1703 = None + fields1232 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1703,) + assert fields1232 is not None + unwrapped_fields1233 = fields1232 self.write("(algorithm") self.indent_sexp() - field1229 = unwrapped_fields1228[0] - if not len(field1229) == 0: + field1234 = unwrapped_fields1233[0] + if not len(field1234) == 0: self.newline() - for i1231, elem1230 in enumerate(field1229): - if (i1231 > 0): + for i1236, elem1235 in enumerate(field1234): + if (i1236 > 0): self.newline() - self.pretty_relation_id(elem1230) + self.pretty_relation_id(elem1235) self.newline() - field1232 = unwrapped_fields1228[1] - self.pretty_script(field1232) - field1233 = unwrapped_fields1228[2] - if field1233 is not None: + field1237 = unwrapped_fields1233[1] + self.pretty_script(field1237) + field1238 = unwrapped_fields1233[2] + if field1238 is not None: self.newline() - assert field1233 is not None - opt_val1234 = field1233 - self.pretty_attrs(opt_val1234) + assert field1238 is not None + opt_val1239 = field1238 + self.pretty_attrs(opt_val1239) self.dedent() self.write(")") def pretty_script(self, msg: logic_pb2.Script): - flat1240 = self._try_flat(msg, self.pretty_script) - if flat1240 is not None: - assert flat1240 is not None - self.write(flat1240) + flat1245 = self._try_flat(msg, self.pretty_script) + if flat1245 is not None: + assert flat1245 is not None + self.write(flat1245) return None else: _dollar_dollar = msg - fields1236 = _dollar_dollar.constructs - assert fields1236 is not None - unwrapped_fields1237 = fields1236 + fields1241 = _dollar_dollar.constructs + assert fields1241 is not None + unwrapped_fields1242 = fields1241 self.write("(script") self.indent_sexp() - if not len(unwrapped_fields1237) == 0: + if not len(unwrapped_fields1242) == 0: self.newline() - for i1239, elem1238 in enumerate(unwrapped_fields1237): - if (i1239 > 0): + for i1244, elem1243 in enumerate(unwrapped_fields1242): + if (i1244 > 0): self.newline() - self.pretty_construct(elem1238) + self.pretty_construct(elem1243) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1245 = self._try_flat(msg, self.pretty_construct) - if flat1245 is not None: - assert flat1245 is not None - self.write(flat1245) + flat1250 = self._try_flat(msg, self.pretty_construct) + if flat1250 is not None: + assert flat1250 is not None + self.write(flat1250) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("loop"): - _t1694 = _dollar_dollar.loop + _t1704 = _dollar_dollar.loop else: - _t1694 = None - deconstruct_result1243 = _t1694 - if deconstruct_result1243 is not None: - assert deconstruct_result1243 is not None - unwrapped1244 = deconstruct_result1243 - self.pretty_loop(unwrapped1244) + _t1704 = None + deconstruct_result1248 = _t1704 + if deconstruct_result1248 is not None: + assert deconstruct_result1248 is not None + unwrapped1249 = deconstruct_result1248 + self.pretty_loop(unwrapped1249) else: _dollar_dollar = msg if _dollar_dollar.HasField("instruction"): - _t1695 = _dollar_dollar.instruction + _t1705 = _dollar_dollar.instruction else: - _t1695 = None - deconstruct_result1241 = _t1695 - if deconstruct_result1241 is not None: - assert deconstruct_result1241 is not None - unwrapped1242 = deconstruct_result1241 - self.pretty_instruction(unwrapped1242) + _t1705 = None + deconstruct_result1246 = _t1705 + if deconstruct_result1246 is not None: + assert deconstruct_result1246 is not None + unwrapped1247 = deconstruct_result1246 + self.pretty_instruction(unwrapped1247) else: raise ParseError("No matching rule for construct") def pretty_loop(self, msg: logic_pb2.Loop): - flat1252 = self._try_flat(msg, self.pretty_loop) - if flat1252 is not None: - assert flat1252 is not None - self.write(flat1252) + flat1257 = self._try_flat(msg, self.pretty_loop) + if flat1257 is not None: + assert flat1257 is not None + self.write(flat1257) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1696 = _dollar_dollar.attrs + _t1706 = _dollar_dollar.attrs else: - _t1696 = None - fields1246 = (_dollar_dollar.init, _dollar_dollar.body, _t1696,) - assert fields1246 is not None - unwrapped_fields1247 = fields1246 + _t1706 = None + fields1251 = (_dollar_dollar.init, _dollar_dollar.body, _t1706,) + assert fields1251 is not None + unwrapped_fields1252 = fields1251 self.write("(loop") self.indent_sexp() self.newline() - field1248 = unwrapped_fields1247[0] - self.pretty_init(field1248) + field1253 = unwrapped_fields1252[0] + self.pretty_init(field1253) self.newline() - field1249 = unwrapped_fields1247[1] - self.pretty_script(field1249) - field1250 = unwrapped_fields1247[2] - if field1250 is not None: + field1254 = unwrapped_fields1252[1] + self.pretty_script(field1254) + field1255 = unwrapped_fields1252[2] + if field1255 is not None: self.newline() - assert field1250 is not None - opt_val1251 = field1250 - self.pretty_attrs(opt_val1251) + assert field1255 is not None + opt_val1256 = field1255 + self.pretty_attrs(opt_val1256) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1256 = self._try_flat(msg, self.pretty_init) - if flat1256 is not None: - assert flat1256 is not None - self.write(flat1256) + flat1261 = self._try_flat(msg, self.pretty_init) + if flat1261 is not None: + assert flat1261 is not None + self.write(flat1261) return None else: - fields1253 = msg + fields1258 = msg self.write("(init") self.indent_sexp() - if not len(fields1253) == 0: + if not len(fields1258) == 0: self.newline() - for i1255, elem1254 in enumerate(fields1253): - if (i1255 > 0): + for i1260, elem1259 in enumerate(fields1258): + if (i1260 > 0): self.newline() - self.pretty_instruction(elem1254) + self.pretty_instruction(elem1259) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1267 = self._try_flat(msg, self.pretty_instruction) - if flat1267 is not None: - assert flat1267 is not None - self.write(flat1267) + flat1272 = self._try_flat(msg, self.pretty_instruction) + if flat1272 is not None: + assert flat1272 is not None + self.write(flat1272) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("assign"): - _t1697 = _dollar_dollar.assign + _t1707 = _dollar_dollar.assign else: - _t1697 = None - deconstruct_result1265 = _t1697 - if deconstruct_result1265 is not None: - assert deconstruct_result1265 is not None - unwrapped1266 = deconstruct_result1265 - self.pretty_assign(unwrapped1266) + _t1707 = None + deconstruct_result1270 = _t1707 + if deconstruct_result1270 is not None: + assert deconstruct_result1270 is not None + unwrapped1271 = deconstruct_result1270 + self.pretty_assign(unwrapped1271) else: _dollar_dollar = msg if _dollar_dollar.HasField("upsert"): - _t1698 = _dollar_dollar.upsert + _t1708 = _dollar_dollar.upsert else: - _t1698 = None - deconstruct_result1263 = _t1698 - if deconstruct_result1263 is not None: - assert deconstruct_result1263 is not None - unwrapped1264 = deconstruct_result1263 - self.pretty_upsert(unwrapped1264) + _t1708 = None + deconstruct_result1268 = _t1708 + if deconstruct_result1268 is not None: + assert deconstruct_result1268 is not None + unwrapped1269 = deconstruct_result1268 + self.pretty_upsert(unwrapped1269) else: _dollar_dollar = msg if _dollar_dollar.HasField("break"): - _t1699 = getattr(_dollar_dollar, 'break') + _t1709 = getattr(_dollar_dollar, 'break') else: - _t1699 = None - deconstruct_result1261 = _t1699 - if deconstruct_result1261 is not None: - assert deconstruct_result1261 is not None - unwrapped1262 = deconstruct_result1261 - self.pretty_break(unwrapped1262) + _t1709 = None + deconstruct_result1266 = _t1709 + if deconstruct_result1266 is not None: + assert deconstruct_result1266 is not None + unwrapped1267 = deconstruct_result1266 + self.pretty_break(unwrapped1267) else: _dollar_dollar = msg if _dollar_dollar.HasField("monoid_def"): - _t1700 = _dollar_dollar.monoid_def + _t1710 = _dollar_dollar.monoid_def else: - _t1700 = None - deconstruct_result1259 = _t1700 - if deconstruct_result1259 is not None: - assert deconstruct_result1259 is not None - unwrapped1260 = deconstruct_result1259 - self.pretty_monoid_def(unwrapped1260) + _t1710 = None + deconstruct_result1264 = _t1710 + if deconstruct_result1264 is not None: + assert deconstruct_result1264 is not None + unwrapped1265 = deconstruct_result1264 + self.pretty_monoid_def(unwrapped1265) else: _dollar_dollar = msg if _dollar_dollar.HasField("monus_def"): - _t1701 = _dollar_dollar.monus_def + _t1711 = _dollar_dollar.monus_def else: - _t1701 = None - deconstruct_result1257 = _t1701 - if deconstruct_result1257 is not None: - assert deconstruct_result1257 is not None - unwrapped1258 = deconstruct_result1257 - self.pretty_monus_def(unwrapped1258) + _t1711 = None + deconstruct_result1262 = _t1711 + if deconstruct_result1262 is not None: + assert deconstruct_result1262 is not None + unwrapped1263 = deconstruct_result1262 + self.pretty_monus_def(unwrapped1263) else: raise ParseError("No matching rule for instruction") def pretty_assign(self, msg: logic_pb2.Assign): - flat1274 = self._try_flat(msg, self.pretty_assign) - if flat1274 is not None: - assert flat1274 is not None - self.write(flat1274) + flat1279 = self._try_flat(msg, self.pretty_assign) + if flat1279 is not None: + assert flat1279 is not None + self.write(flat1279) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1702 = _dollar_dollar.attrs + _t1712 = _dollar_dollar.attrs else: - _t1702 = None - fields1268 = (_dollar_dollar.name, _dollar_dollar.body, _t1702,) - assert fields1268 is not None - unwrapped_fields1269 = fields1268 + _t1712 = None + fields1273 = (_dollar_dollar.name, _dollar_dollar.body, _t1712,) + assert fields1273 is not None + unwrapped_fields1274 = fields1273 self.write("(assign") self.indent_sexp() self.newline() - field1270 = unwrapped_fields1269[0] - self.pretty_relation_id(field1270) + field1275 = unwrapped_fields1274[0] + self.pretty_relation_id(field1275) self.newline() - field1271 = unwrapped_fields1269[1] - self.pretty_abstraction(field1271) - field1272 = unwrapped_fields1269[2] - if field1272 is not None: + field1276 = unwrapped_fields1274[1] + self.pretty_abstraction(field1276) + field1277 = unwrapped_fields1274[2] + if field1277 is not None: self.newline() - assert field1272 is not None - opt_val1273 = field1272 - self.pretty_attrs(opt_val1273) + assert field1277 is not None + opt_val1278 = field1277 + self.pretty_attrs(opt_val1278) self.dedent() self.write(")") def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1281 = self._try_flat(msg, self.pretty_upsert) - if flat1281 is not None: - assert flat1281 is not None - self.write(flat1281) + flat1286 = self._try_flat(msg, self.pretty_upsert) + 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: - _t1703 = _dollar_dollar.attrs + _t1713 = _dollar_dollar.attrs else: - _t1703 = None - fields1275 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1703,) - assert fields1275 is not None - unwrapped_fields1276 = fields1275 + _t1713 = None + fields1280 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1713,) + assert fields1280 is not None + unwrapped_fields1281 = fields1280 self.write("(upsert") self.indent_sexp() self.newline() - field1277 = unwrapped_fields1276[0] - self.pretty_relation_id(field1277) + field1282 = unwrapped_fields1281[0] + self.pretty_relation_id(field1282) self.newline() - field1278 = unwrapped_fields1276[1] - self.pretty_abstraction_with_arity(field1278) - field1279 = unwrapped_fields1276[2] - if field1279 is not None: + field1283 = unwrapped_fields1281[1] + self.pretty_abstraction_with_arity(field1283) + field1284 = unwrapped_fields1281[2] + if field1284 is not None: self.newline() - assert field1279 is not None - opt_val1280 = field1279 - self.pretty_attrs(opt_val1280) + assert field1284 is not None + opt_val1285 = field1284 + self.pretty_attrs(opt_val1285) self.dedent() self.write(")") def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1286 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1286 is not None: - assert flat1286 is not None - self.write(flat1286) + flat1291 = self._try_flat(msg, self.pretty_abstraction_with_arity) + if flat1291 is not None: + assert flat1291 is not None + self.write(flat1291) return None else: _dollar_dollar = msg - _t1704 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - fields1282 = (_t1704, _dollar_dollar[0].value,) - assert fields1282 is not None - unwrapped_fields1283 = fields1282 + _t1714 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) + fields1287 = (_t1714, _dollar_dollar[0].value,) + assert fields1287 is not None + unwrapped_fields1288 = fields1287 self.write("(") self.indent() - field1284 = unwrapped_fields1283[0] - self.pretty_bindings(field1284) + field1289 = unwrapped_fields1288[0] + self.pretty_bindings(field1289) self.newline() - field1285 = unwrapped_fields1283[1] - self.pretty_formula(field1285) + field1290 = unwrapped_fields1288[1] + self.pretty_formula(field1290) self.dedent() self.write(")") def pretty_break(self, msg: logic_pb2.Break): - flat1293 = self._try_flat(msg, self.pretty_break) - if flat1293 is not None: - assert flat1293 is not None - self.write(flat1293) + flat1298 = self._try_flat(msg, self.pretty_break) + if flat1298 is not None: + assert flat1298 is not None + self.write(flat1298) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1705 = _dollar_dollar.attrs + _t1715 = _dollar_dollar.attrs else: - _t1705 = None - fields1287 = (_dollar_dollar.name, _dollar_dollar.body, _t1705,) - assert fields1287 is not None - unwrapped_fields1288 = fields1287 + _t1715 = None + fields1292 = (_dollar_dollar.name, _dollar_dollar.body, _t1715,) + assert fields1292 is not None + unwrapped_fields1293 = fields1292 self.write("(break") self.indent_sexp() self.newline() - field1289 = unwrapped_fields1288[0] - self.pretty_relation_id(field1289) + field1294 = unwrapped_fields1293[0] + self.pretty_relation_id(field1294) self.newline() - field1290 = unwrapped_fields1288[1] - self.pretty_abstraction(field1290) - field1291 = unwrapped_fields1288[2] - if field1291 is not None: + field1295 = unwrapped_fields1293[1] + self.pretty_abstraction(field1295) + field1296 = unwrapped_fields1293[2] + if field1296 is not None: self.newline() - assert field1291 is not None - opt_val1292 = field1291 - self.pretty_attrs(opt_val1292) + assert field1296 is not None + opt_val1297 = field1296 + self.pretty_attrs(opt_val1297) self.dedent() self.write(")") def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1301 = self._try_flat(msg, self.pretty_monoid_def) - if flat1301 is not None: - assert flat1301 is not None - self.write(flat1301) + flat1306 = self._try_flat(msg, self.pretty_monoid_def) + if flat1306 is not None: + assert flat1306 is not None + self.write(flat1306) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1706 = _dollar_dollar.attrs + _t1716 = _dollar_dollar.attrs else: - _t1706 = None - fields1294 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1706,) - assert fields1294 is not None - unwrapped_fields1295 = fields1294 + _t1716 = None + fields1299 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1716,) + assert fields1299 is not None + unwrapped_fields1300 = fields1299 self.write("(monoid") self.indent_sexp() self.newline() - field1296 = unwrapped_fields1295[0] - self.pretty_monoid(field1296) + field1301 = unwrapped_fields1300[0] + self.pretty_monoid(field1301) self.newline() - field1297 = unwrapped_fields1295[1] - self.pretty_relation_id(field1297) + field1302 = unwrapped_fields1300[1] + self.pretty_relation_id(field1302) self.newline() - field1298 = unwrapped_fields1295[2] - self.pretty_abstraction_with_arity(field1298) - field1299 = unwrapped_fields1295[3] - if field1299 is not None: + field1303 = unwrapped_fields1300[2] + self.pretty_abstraction_with_arity(field1303) + field1304 = unwrapped_fields1300[3] + if field1304 is not None: self.newline() - assert field1299 is not None - opt_val1300 = field1299 - self.pretty_attrs(opt_val1300) + assert field1304 is not None + opt_val1305 = field1304 + self.pretty_attrs(opt_val1305) self.dedent() self.write(")") def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1310 = self._try_flat(msg, self.pretty_monoid) - if flat1310 is not None: - assert flat1310 is not None - self.write(flat1310) + flat1315 = self._try_flat(msg, self.pretty_monoid) + if flat1315 is not None: + assert flat1315 is not None + self.write(flat1315) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("or_monoid"): - _t1707 = _dollar_dollar.or_monoid + _t1717 = _dollar_dollar.or_monoid else: - _t1707 = None - deconstruct_result1308 = _t1707 - if deconstruct_result1308 is not None: - assert deconstruct_result1308 is not None - unwrapped1309 = deconstruct_result1308 - self.pretty_or_monoid(unwrapped1309) + _t1717 = None + deconstruct_result1313 = _t1717 + if deconstruct_result1313 is not None: + assert deconstruct_result1313 is not None + unwrapped1314 = deconstruct_result1313 + self.pretty_or_monoid(unwrapped1314) else: _dollar_dollar = msg if _dollar_dollar.HasField("min_monoid"): - _t1708 = _dollar_dollar.min_monoid + _t1718 = _dollar_dollar.min_monoid else: - _t1708 = None - deconstruct_result1306 = _t1708 - if deconstruct_result1306 is not None: - assert deconstruct_result1306 is not None - unwrapped1307 = deconstruct_result1306 - self.pretty_min_monoid(unwrapped1307) + _t1718 = None + deconstruct_result1311 = _t1718 + if deconstruct_result1311 is not None: + assert deconstruct_result1311 is not None + unwrapped1312 = deconstruct_result1311 + self.pretty_min_monoid(unwrapped1312) else: _dollar_dollar = msg if _dollar_dollar.HasField("max_monoid"): - _t1709 = _dollar_dollar.max_monoid + _t1719 = _dollar_dollar.max_monoid else: - _t1709 = None - deconstruct_result1304 = _t1709 - if deconstruct_result1304 is not None: - assert deconstruct_result1304 is not None - unwrapped1305 = deconstruct_result1304 - self.pretty_max_monoid(unwrapped1305) + _t1719 = None + deconstruct_result1309 = _t1719 + if deconstruct_result1309 is not None: + assert deconstruct_result1309 is not None + unwrapped1310 = deconstruct_result1309 + self.pretty_max_monoid(unwrapped1310) else: _dollar_dollar = msg if _dollar_dollar.HasField("sum_monoid"): - _t1710 = _dollar_dollar.sum_monoid + _t1720 = _dollar_dollar.sum_monoid else: - _t1710 = None - deconstruct_result1302 = _t1710 - if deconstruct_result1302 is not None: - assert deconstruct_result1302 is not None - unwrapped1303 = deconstruct_result1302 - self.pretty_sum_monoid(unwrapped1303) + _t1720 = None + deconstruct_result1307 = _t1720 + if deconstruct_result1307 is not None: + assert deconstruct_result1307 is not None + unwrapped1308 = deconstruct_result1307 + self.pretty_sum_monoid(unwrapped1308) else: raise ParseError("No matching rule for monoid") def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1311 = msg + fields1316 = msg self.write("(or)") def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1314 = self._try_flat(msg, self.pretty_min_monoid) - if flat1314 is not None: - assert flat1314 is not None - self.write(flat1314) + flat1319 = self._try_flat(msg, self.pretty_min_monoid) + if flat1319 is not None: + assert flat1319 is not None + self.write(flat1319) return None else: _dollar_dollar = msg - fields1312 = _dollar_dollar.type - assert fields1312 is not None - unwrapped_fields1313 = fields1312 + fields1317 = _dollar_dollar.type + assert fields1317 is not None + unwrapped_fields1318 = fields1317 self.write("(min") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1313) + self.pretty_type(unwrapped_fields1318) self.dedent() self.write(")") def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1317 = self._try_flat(msg, self.pretty_max_monoid) - if flat1317 is not None: - assert flat1317 is not None - self.write(flat1317) + flat1322 = self._try_flat(msg, self.pretty_max_monoid) + if flat1322 is not None: + assert flat1322 is not None + self.write(flat1322) return None else: _dollar_dollar = msg - fields1315 = _dollar_dollar.type - assert fields1315 is not None - unwrapped_fields1316 = fields1315 + fields1320 = _dollar_dollar.type + assert fields1320 is not None + unwrapped_fields1321 = fields1320 self.write("(max") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1316) + self.pretty_type(unwrapped_fields1321) self.dedent() self.write(")") def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1320 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1320 is not None: - assert flat1320 is not None - self.write(flat1320) + flat1325 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1325 is not None: + assert flat1325 is not None + self.write(flat1325) return None else: _dollar_dollar = msg - fields1318 = _dollar_dollar.type - assert fields1318 is not None - unwrapped_fields1319 = fields1318 + fields1323 = _dollar_dollar.type + assert fields1323 is not None + unwrapped_fields1324 = fields1323 self.write("(sum") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1319) + self.pretty_type(unwrapped_fields1324) self.dedent() self.write(")") def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1328 = self._try_flat(msg, self.pretty_monus_def) - if flat1328 is not None: - assert flat1328 is not None - self.write(flat1328) + flat1333 = self._try_flat(msg, self.pretty_monus_def) + if flat1333 is not None: + assert flat1333 is not None + self.write(flat1333) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1711 = _dollar_dollar.attrs + _t1721 = _dollar_dollar.attrs else: - _t1711 = None - fields1321 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1711,) - assert fields1321 is not None - unwrapped_fields1322 = fields1321 + _t1721 = None + fields1326 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1721,) + assert fields1326 is not None + unwrapped_fields1327 = fields1326 self.write("(monus") self.indent_sexp() self.newline() - field1323 = unwrapped_fields1322[0] - self.pretty_monoid(field1323) + field1328 = unwrapped_fields1327[0] + self.pretty_monoid(field1328) self.newline() - field1324 = unwrapped_fields1322[1] - self.pretty_relation_id(field1324) + field1329 = unwrapped_fields1327[1] + self.pretty_relation_id(field1329) self.newline() - field1325 = unwrapped_fields1322[2] - self.pretty_abstraction_with_arity(field1325) - field1326 = unwrapped_fields1322[3] - if field1326 is not None: + field1330 = unwrapped_fields1327[2] + self.pretty_abstraction_with_arity(field1330) + field1331 = unwrapped_fields1327[3] + if field1331 is not None: self.newline() - assert field1326 is not None - opt_val1327 = field1326 - self.pretty_attrs(opt_val1327) + assert field1331 is not None + opt_val1332 = field1331 + self.pretty_attrs(opt_val1332) self.dedent() self.write(")") def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1335 = self._try_flat(msg, self.pretty_constraint) - if flat1335 is not None: - assert flat1335 is not None - self.write(flat1335) + flat1340 = self._try_flat(msg, self.pretty_constraint) + if flat1340 is not None: + assert flat1340 is not None + self.write(flat1340) return None else: _dollar_dollar = msg - fields1329 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - assert fields1329 is not None - unwrapped_fields1330 = fields1329 + fields1334 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) + assert fields1334 is not None + unwrapped_fields1335 = fields1334 self.write("(functional_dependency") self.indent_sexp() self.newline() - field1331 = unwrapped_fields1330[0] - self.pretty_relation_id(field1331) + field1336 = unwrapped_fields1335[0] + self.pretty_relation_id(field1336) self.newline() - field1332 = unwrapped_fields1330[1] - self.pretty_abstraction(field1332) + field1337 = unwrapped_fields1335[1] + self.pretty_abstraction(field1337) self.newline() - field1333 = unwrapped_fields1330[2] - self.pretty_functional_dependency_keys(field1333) + field1338 = unwrapped_fields1335[2] + self.pretty_functional_dependency_keys(field1338) self.newline() - field1334 = unwrapped_fields1330[3] - self.pretty_functional_dependency_values(field1334) + field1339 = unwrapped_fields1335[3] + self.pretty_functional_dependency_values(field1339) self.dedent() self.write(")") def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1339 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1339 is not None: - assert flat1339 is not None - self.write(flat1339) + flat1344 = self._try_flat(msg, self.pretty_functional_dependency_keys) + if flat1344 is not None: + assert flat1344 is not None + self.write(flat1344) return None else: - fields1336 = msg + fields1341 = msg self.write("(keys") self.indent_sexp() - if not len(fields1336) == 0: + if not len(fields1341) == 0: self.newline() - for i1338, elem1337 in enumerate(fields1336): - if (i1338 > 0): + for i1343, elem1342 in enumerate(fields1341): + if (i1343 > 0): self.newline() - self.pretty_var(elem1337) + self.pretty_var(elem1342) self.dedent() self.write(")") def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1343 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1343 is not None: - assert flat1343 is not None - self.write(flat1343) + flat1348 = self._try_flat(msg, self.pretty_functional_dependency_values) + if flat1348 is not None: + assert flat1348 is not None + self.write(flat1348) return None else: - fields1340 = msg + fields1345 = msg self.write("(values") self.indent_sexp() - if not len(fields1340) == 0: + if not len(fields1345) == 0: self.newline() - for i1342, elem1341 in enumerate(fields1340): - if (i1342 > 0): + for i1347, elem1346 in enumerate(fields1345): + if (i1347 > 0): self.newline() - self.pretty_var(elem1341) + self.pretty_var(elem1346) self.dedent() self.write(")") def pretty_data(self, msg: logic_pb2.Data): - flat1352 = self._try_flat(msg, self.pretty_data) - if flat1352 is not None: - assert flat1352 is not None - self.write(flat1352) + flat1357 = self._try_flat(msg, self.pretty_data) + if flat1357 is not None: + assert flat1357 is not None + self.write(flat1357) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("edb"): - _t1712 = _dollar_dollar.edb + _t1722 = _dollar_dollar.edb else: - _t1712 = None - deconstruct_result1350 = _t1712 - if deconstruct_result1350 is not None: - assert deconstruct_result1350 is not None - unwrapped1351 = deconstruct_result1350 - self.pretty_edb(unwrapped1351) + _t1722 = None + deconstruct_result1355 = _t1722 + if deconstruct_result1355 is not None: + assert deconstruct_result1355 is not None + unwrapped1356 = deconstruct_result1355 + self.pretty_edb(unwrapped1356) else: _dollar_dollar = msg if _dollar_dollar.HasField("betree_relation"): - _t1713 = _dollar_dollar.betree_relation + _t1723 = _dollar_dollar.betree_relation else: - _t1713 = None - deconstruct_result1348 = _t1713 - if deconstruct_result1348 is not None: - assert deconstruct_result1348 is not None - unwrapped1349 = deconstruct_result1348 - self.pretty_betree_relation(unwrapped1349) + _t1723 = None + deconstruct_result1353 = _t1723 + if deconstruct_result1353 is not None: + assert deconstruct_result1353 is not None + unwrapped1354 = deconstruct_result1353 + self.pretty_betree_relation(unwrapped1354) else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_data"): - _t1714 = _dollar_dollar.csv_data + _t1724 = _dollar_dollar.csv_data else: - _t1714 = None - deconstruct_result1346 = _t1714 - if deconstruct_result1346 is not None: - assert deconstruct_result1346 is not None - unwrapped1347 = deconstruct_result1346 - self.pretty_csv_data(unwrapped1347) + _t1724 = None + deconstruct_result1351 = _t1724 + if deconstruct_result1351 is not None: + assert deconstruct_result1351 is not None + unwrapped1352 = deconstruct_result1351 + self.pretty_csv_data(unwrapped1352) else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_data"): - _t1715 = _dollar_dollar.iceberg_data + _t1725 = _dollar_dollar.iceberg_data else: - _t1715 = None - deconstruct_result1344 = _t1715 - if deconstruct_result1344 is not None: - assert deconstruct_result1344 is not None - unwrapped1345 = deconstruct_result1344 - self.pretty_iceberg_data(unwrapped1345) + _t1725 = None + deconstruct_result1349 = _t1725 + if deconstruct_result1349 is not None: + assert deconstruct_result1349 is not None + unwrapped1350 = deconstruct_result1349 + self.pretty_iceberg_data(unwrapped1350) else: raise ParseError("No matching rule for data") def pretty_edb(self, msg: logic_pb2.EDB): - flat1358 = self._try_flat(msg, self.pretty_edb) - if flat1358 is not None: - assert flat1358 is not None - self.write(flat1358) + flat1363 = self._try_flat(msg, self.pretty_edb) + if flat1363 is not None: + assert flat1363 is not None + self.write(flat1363) return None else: _dollar_dollar = msg - fields1353 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - assert fields1353 is not None - unwrapped_fields1354 = fields1353 + fields1358 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + assert fields1358 is not None + unwrapped_fields1359 = fields1358 self.write("(edb") self.indent_sexp() self.newline() - field1355 = unwrapped_fields1354[0] - self.pretty_relation_id(field1355) + field1360 = unwrapped_fields1359[0] + self.pretty_relation_id(field1360) self.newline() - field1356 = unwrapped_fields1354[1] - self.pretty_edb_path(field1356) + field1361 = unwrapped_fields1359[1] + self.pretty_edb_path(field1361) self.newline() - field1357 = unwrapped_fields1354[2] - self.pretty_edb_types(field1357) + field1362 = unwrapped_fields1359[2] + self.pretty_edb_types(field1362) self.dedent() self.write(")") def pretty_edb_path(self, msg: Sequence[str]): - flat1362 = self._try_flat(msg, self.pretty_edb_path) - if flat1362 is not None: - assert flat1362 is not None - self.write(flat1362) + flat1367 = self._try_flat(msg, self.pretty_edb_path) + if flat1367 is not None: + assert flat1367 is not None + self.write(flat1367) return None else: - fields1359 = msg + fields1364 = msg self.write("[") self.indent() - for i1361, elem1360 in enumerate(fields1359): - if (i1361 > 0): + for i1366, elem1365 in enumerate(fields1364): + if (i1366 > 0): self.newline() - self.write(self.format_string_value(elem1360)) + self.write(self.format_string_value(elem1365)) self.dedent() self.write("]") def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1366 = self._try_flat(msg, self.pretty_edb_types) - if flat1366 is not None: - assert flat1366 is not None - self.write(flat1366) + flat1371 = self._try_flat(msg, self.pretty_edb_types) + if flat1371 is not None: + assert flat1371 is not None + self.write(flat1371) return None else: - fields1363 = msg + fields1368 = msg self.write("[") self.indent() - for i1365, elem1364 in enumerate(fields1363): - if (i1365 > 0): + for i1370, elem1369 in enumerate(fields1368): + if (i1370 > 0): self.newline() - self.pretty_type(elem1364) + self.pretty_type(elem1369) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1371 = self._try_flat(msg, self.pretty_betree_relation) - if flat1371 is not None: - assert flat1371 is not None - self.write(flat1371) + flat1376 = self._try_flat(msg, self.pretty_betree_relation) + if flat1376 is not None: + assert flat1376 is not None + self.write(flat1376) return None else: _dollar_dollar = msg - fields1367 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - assert fields1367 is not None - unwrapped_fields1368 = fields1367 + fields1372 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + assert fields1372 is not None + unwrapped_fields1373 = fields1372 self.write("(betree_relation") self.indent_sexp() self.newline() - field1369 = unwrapped_fields1368[0] - self.pretty_relation_id(field1369) + field1374 = unwrapped_fields1373[0] + self.pretty_relation_id(field1374) self.newline() - field1370 = unwrapped_fields1368[1] - self.pretty_betree_info(field1370) + field1375 = unwrapped_fields1373[1] + self.pretty_betree_info(field1375) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1377 = self._try_flat(msg, self.pretty_betree_info) - if flat1377 is not None: - assert flat1377 is not None - self.write(flat1377) + flat1382 = self._try_flat(msg, self.pretty_betree_info) + if flat1382 is not None: + assert flat1382 is not None + self.write(flat1382) return None else: _dollar_dollar = msg - _t1716 = self.deconstruct_betree_info_config(_dollar_dollar) - fields1372 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1716,) - assert fields1372 is not None - unwrapped_fields1373 = fields1372 + _t1726 = self.deconstruct_betree_info_config(_dollar_dollar) + fields1377 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1726,) + assert fields1377 is not None + unwrapped_fields1378 = fields1377 self.write("(betree_info") self.indent_sexp() self.newline() - field1374 = unwrapped_fields1373[0] - self.pretty_betree_info_key_types(field1374) + field1379 = unwrapped_fields1378[0] + self.pretty_betree_info_key_types(field1379) self.newline() - field1375 = unwrapped_fields1373[1] - self.pretty_betree_info_value_types(field1375) + field1380 = unwrapped_fields1378[1] + self.pretty_betree_info_value_types(field1380) self.newline() - field1376 = unwrapped_fields1373[2] - self.pretty_config_dict(field1376) + field1381 = unwrapped_fields1378[2] + self.pretty_config_dict(field1381) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1381 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1381 is not None: - assert flat1381 is not None - self.write(flat1381) + flat1386 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1386 is not None: + assert flat1386 is not None + self.write(flat1386) return None else: - fields1378 = msg + fields1383 = msg self.write("(key_types") self.indent_sexp() - if not len(fields1378) == 0: + if not len(fields1383) == 0: self.newline() - for i1380, elem1379 in enumerate(fields1378): - if (i1380 > 0): + for i1385, elem1384 in enumerate(fields1383): + if (i1385 > 0): self.newline() - self.pretty_type(elem1379) + self.pretty_type(elem1384) self.dedent() self.write(")") def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1385 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1385 is not None: - assert flat1385 is not None - self.write(flat1385) + flat1390 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1390 is not None: + assert flat1390 is not None + self.write(flat1390) return None else: - fields1382 = msg + fields1387 = msg self.write("(value_types") self.indent_sexp() - if not len(fields1382) == 0: + if not len(fields1387) == 0: self.newline() - for i1384, elem1383 in enumerate(fields1382): - if (i1384 > 0): + for i1389, elem1388 in enumerate(fields1387): + if (i1389 > 0): self.newline() - self.pretty_type(elem1383) + self.pretty_type(elem1388) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1392 = self._try_flat(msg, self.pretty_csv_data) - if flat1392 is not None: - assert flat1392 is not None - self.write(flat1392) + flat1397 = self._try_flat(msg, self.pretty_csv_data) + if flat1397 is not None: + assert flat1397 is not None + self.write(flat1397) return None else: _dollar_dollar = msg - fields1386 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - assert fields1386 is not None - unwrapped_fields1387 = fields1386 + fields1391 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) + assert fields1391 is not None + unwrapped_fields1392 = fields1391 self.write("(csv_data") self.indent_sexp() self.newline() - field1388 = unwrapped_fields1387[0] - self.pretty_csvlocator(field1388) + field1393 = unwrapped_fields1392[0] + self.pretty_csvlocator(field1393) self.newline() - field1389 = unwrapped_fields1387[1] - self.pretty_csv_config(field1389) + field1394 = unwrapped_fields1392[1] + self.pretty_csv_config(field1394) self.newline() - field1390 = unwrapped_fields1387[2] - self.pretty_gnf_columns(field1390) + field1395 = unwrapped_fields1392[2] + self.pretty_gnf_columns(field1395) self.newline() - field1391 = unwrapped_fields1387[3] - self.pretty_csv_asof(field1391) + field1396 = unwrapped_fields1392[3] + self.pretty_csv_asof(field1396) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1399 = self._try_flat(msg, self.pretty_csvlocator) - if flat1399 is not None: - assert flat1399 is not None - self.write(flat1399) + flat1404 = self._try_flat(msg, self.pretty_csvlocator) + if flat1404 is not None: + assert flat1404 is not None + self.write(flat1404) return None else: _dollar_dollar = msg if not len(_dollar_dollar.paths) == 0: - _t1717 = _dollar_dollar.paths + _t1727 = _dollar_dollar.paths else: - _t1717 = None + _t1727 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1718 = _dollar_dollar.inline_data.decode('utf-8') + _t1728 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1718 = None - fields1393 = (_t1717, _t1718,) - assert fields1393 is not None - unwrapped_fields1394 = fields1393 + _t1728 = None + fields1398 = (_t1727, _t1728,) + assert fields1398 is not None + unwrapped_fields1399 = fields1398 self.write("(csv_locator") self.indent_sexp() - field1395 = unwrapped_fields1394[0] - if field1395 is not None: + field1400 = unwrapped_fields1399[0] + if field1400 is not None: self.newline() - assert field1395 is not None - opt_val1396 = field1395 - self.pretty_csv_locator_paths(opt_val1396) - field1397 = unwrapped_fields1394[1] - if field1397 is not None: + assert field1400 is not None + opt_val1401 = field1400 + self.pretty_csv_locator_paths(opt_val1401) + field1402 = unwrapped_fields1399[1] + if field1402 is not None: self.newline() - assert field1397 is not None - opt_val1398 = field1397 - self.pretty_csv_locator_inline_data(opt_val1398) + assert field1402 is not None + opt_val1403 = field1402 + self.pretty_csv_locator_inline_data(opt_val1403) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1403 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1403 is not None: - assert flat1403 is not None - self.write(flat1403) + flat1408 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1408 is not None: + assert flat1408 is not None + self.write(flat1408) return None else: - fields1400 = msg + fields1405 = msg self.write("(paths") self.indent_sexp() - if not len(fields1400) == 0: + if not len(fields1405) == 0: self.newline() - for i1402, elem1401 in enumerate(fields1400): - if (i1402 > 0): + for i1407, elem1406 in enumerate(fields1405): + if (i1407 > 0): self.newline() - self.write(self.format_string_value(elem1401)) + self.write(self.format_string_value(elem1406)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1405 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1405 is not None: - assert flat1405 is not None - self.write(flat1405) + flat1410 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1410 is not None: + assert flat1410 is not None + self.write(flat1410) return None else: - fields1404 = msg + fields1409 = msg self.write("(inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1404)) + self.write(self.format_string_value(fields1409)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1411 = self._try_flat(msg, self.pretty_csv_config) - if flat1411 is not None: - assert flat1411 is not None - self.write(flat1411) + flat1416 = self._try_flat(msg, self.pretty_csv_config) + if flat1416 is not None: + assert flat1416 is not None + self.write(flat1416) return None else: _dollar_dollar = msg - _t1719 = self.deconstruct_csv_config(_dollar_dollar) - _t1720 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1406 = (_t1719, _t1720,) - assert fields1406 is not None - unwrapped_fields1407 = fields1406 + _t1729 = self.deconstruct_csv_config(_dollar_dollar) + _t1730 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1411 = (_t1729, _t1730,) + assert fields1411 is not None + unwrapped_fields1412 = fields1411 self.write("(csv_config") self.indent_sexp() self.newline() - field1408 = unwrapped_fields1407[0] - self.pretty_config_dict(field1408) - field1409 = unwrapped_fields1407[1] - if field1409 is not None: + field1413 = unwrapped_fields1412[0] + self.pretty_config_dict(field1413) + field1414 = unwrapped_fields1412[1] + if field1414 is not None: self.newline() - assert field1409 is not None - opt_val1410 = field1409 - self.pretty__storage_integration(opt_val1410) + assert field1414 is not None + opt_val1415 = field1414 + self.pretty__storage_integration(opt_val1415) self.dedent() self.write(")") def pretty__storage_integration(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat1413 = self._try_flat(msg, self.pretty__storage_integration) - if flat1413 is not None: - assert flat1413 is not None - self.write(flat1413) + flat1418 = self._try_flat(msg, self.pretty__storage_integration) + if flat1418 is not None: + assert flat1418 is not None + self.write(flat1418) return None else: - fields1412 = msg + fields1417 = msg self.write("(storage_integration") self.indent_sexp() self.newline() - self.pretty_config_dict(fields1412) + self.pretty_config_dict(fields1417) self.dedent() self.write(")") def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): - flat1417 = self._try_flat(msg, self.pretty_gnf_columns) - if flat1417 is not None: - assert flat1417 is not None - self.write(flat1417) + flat1422 = self._try_flat(msg, self.pretty_gnf_columns) + if flat1422 is not None: + assert flat1422 is not None + self.write(flat1422) return None else: - fields1414 = msg + fields1419 = msg self.write("(columns") self.indent_sexp() - if not len(fields1414) == 0: + if not len(fields1419) == 0: self.newline() - for i1416, elem1415 in enumerate(fields1414): - if (i1416 > 0): + for i1421, elem1420 in enumerate(fields1419): + if (i1421 > 0): self.newline() - self.pretty_gnf_column(elem1415) + self.pretty_gnf_column(elem1420) self.dedent() self.write(")") def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): - flat1426 = self._try_flat(msg, self.pretty_gnf_column) - if flat1426 is not None: - assert flat1426 is not None - self.write(flat1426) + flat1431 = self._try_flat(msg, self.pretty_gnf_column) + if flat1431 is not None: + assert flat1431 is not None + self.write(flat1431) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("target_id"): - _t1721 = _dollar_dollar.target_id + _t1731 = _dollar_dollar.target_id else: - _t1721 = None - fields1418 = (_dollar_dollar.column_path, _t1721, _dollar_dollar.types,) - assert fields1418 is not None - unwrapped_fields1419 = fields1418 + _t1731 = None + fields1423 = (_dollar_dollar.column_path, _t1731, _dollar_dollar.types,) + assert fields1423 is not None + unwrapped_fields1424 = fields1423 self.write("(column") self.indent_sexp() self.newline() - field1420 = unwrapped_fields1419[0] - self.pretty_gnf_column_path(field1420) - field1421 = unwrapped_fields1419[1] - if field1421 is not None: + field1425 = unwrapped_fields1424[0] + self.pretty_gnf_column_path(field1425) + field1426 = unwrapped_fields1424[1] + if field1426 is not None: self.newline() - assert field1421 is not None - opt_val1422 = field1421 - self.pretty_relation_id(opt_val1422) + assert field1426 is not None + opt_val1427 = field1426 + self.pretty_relation_id(opt_val1427) self.newline() self.write("[") - field1423 = unwrapped_fields1419[2] - for i1425, elem1424 in enumerate(field1423): - if (i1425 > 0): + field1428 = unwrapped_fields1424[2] + for i1430, elem1429 in enumerate(field1428): + if (i1430 > 0): self.newline() - self.pretty_type(elem1424) + self.pretty_type(elem1429) self.write("]") self.dedent() self.write(")") def pretty_gnf_column_path(self, msg: Sequence[str]): - flat1433 = self._try_flat(msg, self.pretty_gnf_column_path) - if flat1433 is not None: - assert flat1433 is not None - self.write(flat1433) + flat1438 = self._try_flat(msg, self.pretty_gnf_column_path) + if flat1438 is not None: + assert flat1438 is not None + self.write(flat1438) return None else: _dollar_dollar = msg if len(_dollar_dollar) == 1: - _t1722 = _dollar_dollar[0] + _t1732 = _dollar_dollar[0] else: - _t1722 = None - deconstruct_result1431 = _t1722 - if deconstruct_result1431 is not None: - assert deconstruct_result1431 is not None - unwrapped1432 = deconstruct_result1431 - self.write(self.format_string_value(unwrapped1432)) + _t1732 = None + deconstruct_result1436 = _t1732 + if deconstruct_result1436 is not None: + assert deconstruct_result1436 is not None + unwrapped1437 = deconstruct_result1436 + self.write(self.format_string_value(unwrapped1437)) else: _dollar_dollar = msg if len(_dollar_dollar) != 1: - _t1723 = _dollar_dollar + _t1733 = _dollar_dollar else: - _t1723 = None - deconstruct_result1427 = _t1723 - if deconstruct_result1427 is not None: - assert deconstruct_result1427 is not None - unwrapped1428 = deconstruct_result1427 + _t1733 = None + deconstruct_result1432 = _t1733 + if deconstruct_result1432 is not None: + assert deconstruct_result1432 is not None + unwrapped1433 = deconstruct_result1432 self.write("[") self.indent() - for i1430, elem1429 in enumerate(unwrapped1428): - if (i1430 > 0): + for i1435, elem1434 in enumerate(unwrapped1433): + if (i1435 > 0): self.newline() - self.write(self.format_string_value(elem1429)) + self.write(self.format_string_value(elem1434)) self.dedent() self.write("]") else: raise ParseError("No matching rule for gnf_column_path") def pretty_csv_asof(self, msg: str): - flat1435 = self._try_flat(msg, self.pretty_csv_asof) - if flat1435 is not None: - assert flat1435 is not None - self.write(flat1435) + flat1440 = self._try_flat(msg, self.pretty_csv_asof) + if flat1440 is not None: + assert flat1440 is not None + self.write(flat1440) return None else: - fields1434 = msg + fields1439 = msg self.write("(asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1434)) + self.write(self.format_string_value(fields1439)) self.dedent() self.write(")") def pretty_iceberg_data(self, msg: logic_pb2.IcebergData): - flat1446 = self._try_flat(msg, self.pretty_iceberg_data) - if flat1446 is not None: - assert flat1446 is not None - self.write(flat1446) + flat1451 = self._try_flat(msg, self.pretty_iceberg_data) + if flat1451 is not None: + assert flat1451 is not None + self.write(flat1451) return None else: _dollar_dollar = msg - _t1724 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1725 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1436 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1724, _t1725, _dollar_dollar.returns_delta,) - assert fields1436 is not None - unwrapped_fields1437 = fields1436 + _t1734 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) + _t1735 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) + fields1441 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1734, _t1735, _dollar_dollar.returns_delta,) + assert fields1441 is not None + unwrapped_fields1442 = fields1441 self.write("(iceberg_data") self.indent_sexp() self.newline() - field1438 = unwrapped_fields1437[0] - self.pretty_iceberg_locator(field1438) + field1443 = unwrapped_fields1442[0] + self.pretty_iceberg_locator(field1443) self.newline() - field1439 = unwrapped_fields1437[1] - self.pretty_iceberg_catalog_config(field1439) + field1444 = unwrapped_fields1442[1] + self.pretty_iceberg_catalog_config(field1444) self.newline() - field1440 = unwrapped_fields1437[2] - self.pretty_gnf_columns(field1440) - field1441 = unwrapped_fields1437[3] - if field1441 is not None: + field1445 = unwrapped_fields1442[2] + self.pretty_gnf_columns(field1445) + field1446 = unwrapped_fields1442[3] + if field1446 is not None: self.newline() - assert field1441 is not None - opt_val1442 = field1441 - self.pretty_iceberg_from_snapshot(opt_val1442) - field1443 = unwrapped_fields1437[4] - if field1443 is not None: + assert field1446 is not None + opt_val1447 = field1446 + self.pretty_iceberg_from_snapshot(opt_val1447) + field1448 = unwrapped_fields1442[4] + if field1448 is not None: self.newline() - assert field1443 is not None - opt_val1444 = field1443 - self.pretty_iceberg_to_snapshot(opt_val1444) + assert field1448 is not None + opt_val1449 = field1448 + self.pretty_iceberg_to_snapshot(opt_val1449) self.newline() - field1445 = unwrapped_fields1437[5] - self.pretty_boolean_value(field1445) + field1450 = unwrapped_fields1442[5] + self.pretty_boolean_value(field1450) self.dedent() self.write(")") def pretty_iceberg_locator(self, msg: logic_pb2.IcebergLocator): - flat1452 = self._try_flat(msg, self.pretty_iceberg_locator) - if flat1452 is not None: - assert flat1452 is not None - self.write(flat1452) + flat1457 = self._try_flat(msg, self.pretty_iceberg_locator) + if flat1457 is not None: + assert flat1457 is not None + self.write(flat1457) return None else: _dollar_dollar = msg - fields1447 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - assert fields1447 is not None - unwrapped_fields1448 = fields1447 + fields1452 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + assert fields1452 is not None + unwrapped_fields1453 = fields1452 self.write("(iceberg_locator") self.indent_sexp() self.newline() - field1449 = unwrapped_fields1448[0] - self.pretty_iceberg_locator_table_name(field1449) + field1454 = unwrapped_fields1453[0] + self.pretty_iceberg_locator_table_name(field1454) self.newline() - field1450 = unwrapped_fields1448[1] - self.pretty_iceberg_locator_namespace(field1450) + field1455 = unwrapped_fields1453[1] + self.pretty_iceberg_locator_namespace(field1455) self.newline() - field1451 = unwrapped_fields1448[2] - self.pretty_iceberg_locator_warehouse(field1451) + field1456 = unwrapped_fields1453[2] + self.pretty_iceberg_locator_warehouse(field1456) self.dedent() self.write(")") def pretty_iceberg_locator_table_name(self, msg: str): - flat1454 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) - if flat1454 is not None: - assert flat1454 is not None - self.write(flat1454) + flat1459 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) + if flat1459 is not None: + assert flat1459 is not None + self.write(flat1459) return None else: - fields1453 = msg + fields1458 = msg self.write("(table_name") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1453)) + self.write(self.format_string_value(fields1458)) self.dedent() self.write(")") def pretty_iceberg_locator_namespace(self, msg: Sequence[str]): - flat1458 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) - if flat1458 is not None: - assert flat1458 is not None - self.write(flat1458) + flat1463 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) + if flat1463 is not None: + assert flat1463 is not None + self.write(flat1463) return None else: - fields1455 = msg + fields1460 = msg self.write("(namespace") self.indent_sexp() - if not len(fields1455) == 0: + if not len(fields1460) == 0: self.newline() - for i1457, elem1456 in enumerate(fields1455): - if (i1457 > 0): + for i1462, elem1461 in enumerate(fields1460): + if (i1462 > 0): self.newline() - self.write(self.format_string_value(elem1456)) + self.write(self.format_string_value(elem1461)) self.dedent() self.write(")") def pretty_iceberg_locator_warehouse(self, msg: str): - flat1460 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) - if flat1460 is not None: - assert flat1460 is not None - self.write(flat1460) + flat1465 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) + if flat1465 is not None: + assert flat1465 is not None + self.write(flat1465) return None else: - fields1459 = msg + fields1464 = msg self.write("(warehouse") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1459)) + self.write(self.format_string_value(fields1464)) self.dedent() self.write(")") def pretty_iceberg_catalog_config(self, msg: logic_pb2.IcebergCatalogConfig): - flat1468 = self._try_flat(msg, self.pretty_iceberg_catalog_config) - if flat1468 is not None: - assert flat1468 is not None - self.write(flat1468) + flat1473 = self._try_flat(msg, self.pretty_iceberg_catalog_config) + if flat1473 is not None: + assert flat1473 is not None + self.write(flat1473) return None else: _dollar_dollar = msg - _t1726 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1461 = (_dollar_dollar.catalog_uri, _t1726, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) - assert fields1461 is not None - unwrapped_fields1462 = fields1461 + _t1736 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) + fields1466 = (_dollar_dollar.catalog_uri, _t1736, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) + assert fields1466 is not None + unwrapped_fields1467 = fields1466 self.write("(iceberg_catalog_config") self.indent_sexp() self.newline() - field1463 = unwrapped_fields1462[0] - self.pretty_iceberg_catalog_uri(field1463) - field1464 = unwrapped_fields1462[1] - if field1464 is not None: + field1468 = unwrapped_fields1467[0] + self.pretty_iceberg_catalog_uri(field1468) + field1469 = unwrapped_fields1467[1] + if field1469 is not None: self.newline() - assert field1464 is not None - opt_val1465 = field1464 - self.pretty_iceberg_catalog_config_scope(opt_val1465) + assert field1469 is not None + opt_val1470 = field1469 + self.pretty_iceberg_catalog_config_scope(opt_val1470) self.newline() - field1466 = unwrapped_fields1462[2] - self.pretty_iceberg_properties(field1466) + field1471 = unwrapped_fields1467[2] + self.pretty_iceberg_properties(field1471) self.newline() - field1467 = unwrapped_fields1462[3] - self.pretty_iceberg_auth_properties(field1467) + field1472 = unwrapped_fields1467[3] + self.pretty_iceberg_auth_properties(field1472) self.dedent() self.write(")") def pretty_iceberg_catalog_uri(self, msg: str): - flat1470 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) - if flat1470 is not None: - assert flat1470 is not None - self.write(flat1470) + flat1475 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) + if flat1475 is not None: + assert flat1475 is not None + self.write(flat1475) return None else: - fields1469 = msg + fields1474 = msg self.write("(catalog_uri") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1469)) + self.write(self.format_string_value(fields1474)) self.dedent() self.write(")") def pretty_iceberg_catalog_config_scope(self, msg: str): - flat1472 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) - if flat1472 is not None: - assert flat1472 is not None - self.write(flat1472) + flat1477 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) + if flat1477 is not None: + assert flat1477 is not None + self.write(flat1477) return None else: - fields1471 = msg + fields1476 = msg self.write("(scope") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1471)) + self.write(self.format_string_value(fields1476)) self.dedent() self.write(")") def pretty_iceberg_properties(self, msg: Sequence[tuple[str, str]]): - flat1476 = self._try_flat(msg, self.pretty_iceberg_properties) - if flat1476 is not None: - assert flat1476 is not None - self.write(flat1476) + flat1481 = self._try_flat(msg, self.pretty_iceberg_properties) + if flat1481 is not None: + assert flat1481 is not None + self.write(flat1481) return None else: - fields1473 = msg + fields1478 = msg self.write("(properties") self.indent_sexp() - if not len(fields1473) == 0: + if not len(fields1478) == 0: self.newline() - for i1475, elem1474 in enumerate(fields1473): - if (i1475 > 0): + for i1480, elem1479 in enumerate(fields1478): + if (i1480 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1474) + self.pretty_iceberg_property_entry(elem1479) self.dedent() self.write(")") def pretty_iceberg_property_entry(self, msg: tuple[str, str]): - flat1481 = self._try_flat(msg, self.pretty_iceberg_property_entry) - if flat1481 is not None: - assert flat1481 is not None - self.write(flat1481) + flat1486 = self._try_flat(msg, self.pretty_iceberg_property_entry) + if flat1486 is not None: + assert flat1486 is not None + self.write(flat1486) return None else: _dollar_dollar = msg - fields1477 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields1477 is not None - unwrapped_fields1478 = fields1477 + fields1482 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields1482 is not None + unwrapped_fields1483 = fields1482 self.write("(prop") self.indent_sexp() self.newline() - field1479 = unwrapped_fields1478[0] - self.write(self.format_string_value(field1479)) + field1484 = unwrapped_fields1483[0] + self.write(self.format_string_value(field1484)) self.newline() - field1480 = unwrapped_fields1478[1] - self.write(self.format_string_value(field1480)) + field1485 = unwrapped_fields1483[1] + self.write(self.format_string_value(field1485)) self.dedent() self.write(")") def pretty_iceberg_auth_properties(self, msg: Sequence[tuple[str, str]]): - flat1485 = self._try_flat(msg, self.pretty_iceberg_auth_properties) - if flat1485 is not None: - assert flat1485 is not None - self.write(flat1485) + flat1490 = self._try_flat(msg, self.pretty_iceberg_auth_properties) + if flat1490 is not None: + assert flat1490 is not None + self.write(flat1490) return None else: - fields1482 = msg + fields1487 = msg self.write("(auth_properties") self.indent_sexp() - if not len(fields1482) == 0: + if not len(fields1487) == 0: self.newline() - for i1484, elem1483 in enumerate(fields1482): - if (i1484 > 0): + for i1489, elem1488 in enumerate(fields1487): + if (i1489 > 0): self.newline() - self.pretty_iceberg_masked_property_entry(elem1483) + self.pretty_iceberg_masked_property_entry(elem1488) self.dedent() self.write(")") def pretty_iceberg_masked_property_entry(self, msg: tuple[str, str]): - flat1490 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) - if flat1490 is not None: - assert flat1490 is not None - self.write(flat1490) + flat1495 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) + if flat1495 is not None: + assert flat1495 is not None + self.write(flat1495) return None else: _dollar_dollar = msg - _t1727 = self.mask_secret_value(_dollar_dollar) - fields1486 = (_dollar_dollar[0], _t1727,) - assert fields1486 is not None - unwrapped_fields1487 = fields1486 + _t1737 = self.mask_secret_value(_dollar_dollar) + fields1491 = (_dollar_dollar[0], _t1737,) + assert fields1491 is not None + unwrapped_fields1492 = fields1491 self.write("(prop") self.indent_sexp() self.newline() - field1488 = unwrapped_fields1487[0] - self.write(self.format_string_value(field1488)) + field1493 = unwrapped_fields1492[0] + self.write(self.format_string_value(field1493)) self.newline() - field1489 = unwrapped_fields1487[1] - self.write(self.format_string_value(field1489)) + field1494 = unwrapped_fields1492[1] + self.write(self.format_string_value(field1494)) self.dedent() self.write(")") def pretty_iceberg_from_snapshot(self, msg: str): - flat1492 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) - if flat1492 is not None: - assert flat1492 is not None - self.write(flat1492) + flat1497 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) + if flat1497 is not None: + assert flat1497 is not None + self.write(flat1497) return None else: - fields1491 = msg + fields1496 = msg self.write("(from_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1491)) + self.write(self.format_string_value(fields1496)) self.dedent() self.write(")") def pretty_iceberg_to_snapshot(self, msg: str): - flat1494 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) - if flat1494 is not None: - assert flat1494 is not None - self.write(flat1494) + flat1499 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) + if flat1499 is not None: + assert flat1499 is not None + self.write(flat1499) return None else: - fields1493 = msg + fields1498 = msg self.write("(to_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1493)) + self.write(self.format_string_value(fields1498)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1497 = self._try_flat(msg, self.pretty_undefine) - if flat1497 is not None: - assert flat1497 is not None - self.write(flat1497) + flat1502 = self._try_flat(msg, self.pretty_undefine) + if flat1502 is not None: + assert flat1502 is not None + self.write(flat1502) return None else: _dollar_dollar = msg - fields1495 = _dollar_dollar.fragment_id - assert fields1495 is not None - unwrapped_fields1496 = fields1495 + fields1500 = _dollar_dollar.fragment_id + assert fields1500 is not None + unwrapped_fields1501 = fields1500 self.write("(undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1496) + self.pretty_fragment_id(unwrapped_fields1501) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1502 = self._try_flat(msg, self.pretty_context) - if flat1502 is not None: - assert flat1502 is not None - self.write(flat1502) + flat1507 = self._try_flat(msg, self.pretty_context) + if flat1507 is not None: + assert flat1507 is not None + self.write(flat1507) return None else: _dollar_dollar = msg - fields1498 = _dollar_dollar.relations - assert fields1498 is not None - unwrapped_fields1499 = fields1498 + fields1503 = _dollar_dollar.relations + assert fields1503 is not None + unwrapped_fields1504 = fields1503 self.write("(context") self.indent_sexp() - if not len(unwrapped_fields1499) == 0: + if not len(unwrapped_fields1504) == 0: self.newline() - for i1501, elem1500 in enumerate(unwrapped_fields1499): - if (i1501 > 0): + for i1506, elem1505 in enumerate(unwrapped_fields1504): + if (i1506 > 0): self.newline() - self.pretty_relation_id(elem1500) + self.pretty_relation_id(elem1505) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1509 = self._try_flat(msg, self.pretty_snapshot) - if flat1509 is not None: - assert flat1509 is not None - self.write(flat1509) + flat1514 = self._try_flat(msg, self.pretty_snapshot) + if flat1514 is not None: + assert flat1514 is not None + self.write(flat1514) return None else: _dollar_dollar = msg - fields1503 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - assert fields1503 is not None - unwrapped_fields1504 = fields1503 + fields1508 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + assert fields1508 is not None + unwrapped_fields1509 = fields1508 self.write("(snapshot") self.indent_sexp() self.newline() - field1505 = unwrapped_fields1504[0] - self.pretty_edb_path(field1505) - field1506 = unwrapped_fields1504[1] - if not len(field1506) == 0: + field1510 = unwrapped_fields1509[0] + self.pretty_edb_path(field1510) + field1511 = unwrapped_fields1509[1] + if not len(field1511) == 0: self.newline() - for i1508, elem1507 in enumerate(field1506): - if (i1508 > 0): + for i1513, elem1512 in enumerate(field1511): + if (i1513 > 0): self.newline() - self.pretty_snapshot_mapping(elem1507) + self.pretty_snapshot_mapping(elem1512) self.dedent() self.write(")") def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping): - flat1514 = self._try_flat(msg, self.pretty_snapshot_mapping) - if flat1514 is not None: - assert flat1514 is not None - self.write(flat1514) + flat1519 = self._try_flat(msg, self.pretty_snapshot_mapping) + if flat1519 is not None: + assert flat1519 is not None + self.write(flat1519) return None else: _dollar_dollar = msg - fields1510 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - assert fields1510 is not None - unwrapped_fields1511 = fields1510 - field1512 = unwrapped_fields1511[0] - self.pretty_edb_path(field1512) + fields1515 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + assert fields1515 is not None + unwrapped_fields1516 = fields1515 + field1517 = unwrapped_fields1516[0] + self.pretty_edb_path(field1517) self.write(" ") - field1513 = unwrapped_fields1511[1] - self.pretty_relation_id(field1513) + field1518 = unwrapped_fields1516[1] + self.pretty_relation_id(field1518) def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1518 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1518 is not None: - assert flat1518 is not None - self.write(flat1518) + flat1523 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1523 is not None: + assert flat1523 is not None + self.write(flat1523) return None else: - fields1515 = msg + fields1520 = msg self.write("(reads") self.indent_sexp() - if not len(fields1515) == 0: + if not len(fields1520) == 0: self.newline() - for i1517, elem1516 in enumerate(fields1515): - if (i1517 > 0): + for i1522, elem1521 in enumerate(fields1520): + if (i1522 > 0): self.newline() - self.pretty_read(elem1516) + self.pretty_read(elem1521) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1529 = self._try_flat(msg, self.pretty_read) - if flat1529 is not None: - assert flat1529 is not None - self.write(flat1529) + flat1534 = self._try_flat(msg, self.pretty_read) + if flat1534 is not None: + assert flat1534 is not None + self.write(flat1534) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("demand"): - _t1728 = _dollar_dollar.demand + _t1738 = _dollar_dollar.demand else: - _t1728 = None - deconstruct_result1527 = _t1728 - if deconstruct_result1527 is not None: - assert deconstruct_result1527 is not None - unwrapped1528 = deconstruct_result1527 - self.pretty_demand(unwrapped1528) + _t1738 = None + deconstruct_result1532 = _t1738 + if deconstruct_result1532 is not None: + assert deconstruct_result1532 is not None + unwrapped1533 = deconstruct_result1532 + self.pretty_demand(unwrapped1533) else: _dollar_dollar = msg if _dollar_dollar.HasField("output"): - _t1729 = _dollar_dollar.output + _t1739 = _dollar_dollar.output else: - _t1729 = None - deconstruct_result1525 = _t1729 - if deconstruct_result1525 is not None: - assert deconstruct_result1525 is not None - unwrapped1526 = deconstruct_result1525 - self.pretty_output(unwrapped1526) + _t1739 = None + deconstruct_result1530 = _t1739 + if deconstruct_result1530 is not None: + assert deconstruct_result1530 is not None + unwrapped1531 = deconstruct_result1530 + self.pretty_output(unwrapped1531) else: _dollar_dollar = msg if _dollar_dollar.HasField("what_if"): - _t1730 = _dollar_dollar.what_if + _t1740 = _dollar_dollar.what_if else: - _t1730 = None - deconstruct_result1523 = _t1730 - if deconstruct_result1523 is not None: - assert deconstruct_result1523 is not None - unwrapped1524 = deconstruct_result1523 - self.pretty_what_if(unwrapped1524) + _t1740 = None + deconstruct_result1528 = _t1740 + if deconstruct_result1528 is not None: + assert deconstruct_result1528 is not None + unwrapped1529 = deconstruct_result1528 + self.pretty_what_if(unwrapped1529) else: _dollar_dollar = msg if _dollar_dollar.HasField("abort"): - _t1731 = _dollar_dollar.abort + _t1741 = _dollar_dollar.abort else: - _t1731 = None - deconstruct_result1521 = _t1731 - if deconstruct_result1521 is not None: - assert deconstruct_result1521 is not None - unwrapped1522 = deconstruct_result1521 - self.pretty_abort(unwrapped1522) + _t1741 = None + deconstruct_result1526 = _t1741 + if deconstruct_result1526 is not None: + assert deconstruct_result1526 is not None + unwrapped1527 = deconstruct_result1526 + self.pretty_abort(unwrapped1527) else: _dollar_dollar = msg if _dollar_dollar.HasField("export"): - _t1732 = _dollar_dollar.export + _t1742 = _dollar_dollar.export else: - _t1732 = None - deconstruct_result1519 = _t1732 - if deconstruct_result1519 is not None: - assert deconstruct_result1519 is not None - unwrapped1520 = deconstruct_result1519 - self.pretty_export(unwrapped1520) + _t1742 = None + deconstruct_result1524 = _t1742 + if deconstruct_result1524 is not None: + assert deconstruct_result1524 is not None + unwrapped1525 = deconstruct_result1524 + self.pretty_export(unwrapped1525) else: raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1532 = self._try_flat(msg, self.pretty_demand) - if flat1532 is not None: - assert flat1532 is not None - self.write(flat1532) + flat1537 = self._try_flat(msg, self.pretty_demand) + if flat1537 is not None: + assert flat1537 is not None + self.write(flat1537) return None else: _dollar_dollar = msg - fields1530 = _dollar_dollar.relation_id - assert fields1530 is not None - unwrapped_fields1531 = fields1530 + fields1535 = _dollar_dollar.relation_id + assert fields1535 is not None + unwrapped_fields1536 = fields1535 self.write("(demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1531) + self.pretty_relation_id(unwrapped_fields1536) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1537 = self._try_flat(msg, self.pretty_output) - if flat1537 is not None: - assert flat1537 is not None - self.write(flat1537) + flat1542 = self._try_flat(msg, self.pretty_output) + if flat1542 is not None: + assert flat1542 is not None + self.write(flat1542) return None else: _dollar_dollar = msg - fields1533 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - assert fields1533 is not None - unwrapped_fields1534 = fields1533 + fields1538 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + assert fields1538 is not None + unwrapped_fields1539 = fields1538 self.write("(output") self.indent_sexp() self.newline() - field1535 = unwrapped_fields1534[0] - self.pretty_name(field1535) + field1540 = unwrapped_fields1539[0] + self.pretty_name(field1540) self.newline() - field1536 = unwrapped_fields1534[1] - self.pretty_relation_id(field1536) + field1541 = unwrapped_fields1539[1] + self.pretty_relation_id(field1541) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1542 = self._try_flat(msg, self.pretty_what_if) - if flat1542 is not None: - assert flat1542 is not None - self.write(flat1542) + flat1547 = self._try_flat(msg, self.pretty_what_if) + if flat1547 is not None: + assert flat1547 is not None + self.write(flat1547) return None else: _dollar_dollar = msg - fields1538 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - assert fields1538 is not None - unwrapped_fields1539 = fields1538 + fields1543 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + assert fields1543 is not None + unwrapped_fields1544 = fields1543 self.write("(what_if") self.indent_sexp() self.newline() - field1540 = unwrapped_fields1539[0] - self.pretty_name(field1540) + field1545 = unwrapped_fields1544[0] + self.pretty_name(field1545) self.newline() - field1541 = unwrapped_fields1539[1] - self.pretty_epoch(field1541) + field1546 = unwrapped_fields1544[1] + self.pretty_epoch(field1546) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - flat1548 = self._try_flat(msg, self.pretty_abort) - if flat1548 is not None: - assert flat1548 is not None - self.write(flat1548) + flat1553 = self._try_flat(msg, self.pretty_abort) + if flat1553 is not None: + assert flat1553 is not None + self.write(flat1553) return None else: _dollar_dollar = msg if _dollar_dollar.name != "abort": - _t1733 = _dollar_dollar.name + _t1743 = _dollar_dollar.name else: - _t1733 = None - fields1543 = (_t1733, _dollar_dollar.relation_id,) - assert fields1543 is not None - unwrapped_fields1544 = fields1543 + _t1743 = None + fields1548 = (_t1743, _dollar_dollar.relation_id,) + assert fields1548 is not None + unwrapped_fields1549 = fields1548 self.write("(abort") self.indent_sexp() - field1545 = unwrapped_fields1544[0] - if field1545 is not None: + field1550 = unwrapped_fields1549[0] + if field1550 is not None: self.newline() - assert field1545 is not None - opt_val1546 = field1545 - self.pretty_name(opt_val1546) + assert field1550 is not None + opt_val1551 = field1550 + self.pretty_name(opt_val1551) self.newline() - field1547 = unwrapped_fields1544[1] - self.pretty_relation_id(field1547) + field1552 = unwrapped_fields1549[1] + self.pretty_relation_id(field1552) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1553 = self._try_flat(msg, self.pretty_export) - if flat1553 is not None: - assert flat1553 is not None - self.write(flat1553) + flat1558 = self._try_flat(msg, self.pretty_export) + if flat1558 is not None: + assert flat1558 is not None + self.write(flat1558) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_config"): - _t1734 = _dollar_dollar.csv_config + _t1744 = _dollar_dollar.csv_config else: - _t1734 = None - deconstruct_result1551 = _t1734 - if deconstruct_result1551 is not None: - assert deconstruct_result1551 is not None - unwrapped1552 = deconstruct_result1551 + _t1744 = None + deconstruct_result1556 = _t1744 + if deconstruct_result1556 is not None: + assert deconstruct_result1556 is not None + unwrapped1557 = deconstruct_result1556 self.write("(export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped1552) + self.pretty_export_csv_config(unwrapped1557) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_config"): - _t1735 = _dollar_dollar.iceberg_config + _t1745 = _dollar_dollar.iceberg_config else: - _t1735 = None - deconstruct_result1549 = _t1735 - if deconstruct_result1549 is not None: - assert deconstruct_result1549 is not None - unwrapped1550 = deconstruct_result1549 + _t1745 = None + deconstruct_result1554 = _t1745 + if deconstruct_result1554 is not None: + assert deconstruct_result1554 is not None + unwrapped1555 = deconstruct_result1554 self.write("(export_iceberg") self.indent_sexp() self.newline() - self.pretty_export_iceberg_config(unwrapped1550) + self.pretty_export_iceberg_config(unwrapped1555) self.dedent() self.write(")") else: raise ParseError("No matching rule for export") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): - flat1564 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1564 is not None: - assert flat1564 is not None - self.write(flat1564) + flat1569 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1569 is not None: + assert flat1569 is not None + self.write(flat1569) return None else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) == 0: - _t1736 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1747 = self.deconstruct_export_csv_output_location(_dollar_dollar) + _t1746 = (_t1747, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else: - _t1736 = None - deconstruct_result1559 = _t1736 - if deconstruct_result1559 is not None: - assert deconstruct_result1559 is not None - unwrapped1560 = deconstruct_result1559 + _t1746 = None + deconstruct_result1564 = _t1746 + if deconstruct_result1564 is not None: + assert deconstruct_result1564 is not None + unwrapped1565 = deconstruct_result1564 self.write("(export_csv_config_v2") self.indent_sexp() self.newline() - field1561 = unwrapped1560[0] - self.pretty_export_csv_path(field1561) + field1566 = unwrapped1565[0] + self.pretty_export_csv_output_location(field1566) self.newline() - field1562 = unwrapped1560[1] - self.pretty_export_csv_source(field1562) + field1567 = unwrapped1565[1] + self.pretty_export_csv_source(field1567) self.newline() - field1563 = unwrapped1560[2] - self.pretty_csv_config(field1563) + field1568 = unwrapped1565[2] + self.pretty_csv_config(field1568) self.dedent() self.write(")") else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) != 0: - _t1738 = self.deconstruct_export_csv_config(_dollar_dollar) - _t1737 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1738,) + _t1749 = self.deconstruct_export_csv_config(_dollar_dollar) + _t1748 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1749,) else: - _t1737 = None - deconstruct_result1554 = _t1737 - if deconstruct_result1554 is not None: - assert deconstruct_result1554 is not None - unwrapped1555 = deconstruct_result1554 + _t1748 = None + deconstruct_result1559 = _t1748 + if deconstruct_result1559 is not None: + assert deconstruct_result1559 is not None + unwrapped1560 = deconstruct_result1559 self.write("(export_csv_config") self.indent_sexp() self.newline() - field1556 = unwrapped1555[0] - self.pretty_export_csv_path(field1556) + field1561 = unwrapped1560[0] + self.pretty_export_csv_path(field1561) self.newline() - field1557 = unwrapped1555[1] - self.pretty_export_csv_columns_list(field1557) + field1562 = unwrapped1560[1] + self.pretty_export_csv_columns_list(field1562) self.newline() - field1558 = unwrapped1555[2] - self.pretty_config_dict(field1558) + field1563 = unwrapped1560[2] + self.pretty_config_dict(field1563) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_config") - def pretty_export_csv_path(self, msg: str): - flat1566 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1566 is not None: - assert flat1566 is not None - self.write(flat1566) + def pretty_export_csv_output_location(self, msg: tuple[str, str]): + flat1574 = self._try_flat(msg, self.pretty_export_csv_output_location) + if flat1574 is not None: + assert flat1574 is not None + self.write(flat1574) return None else: - fields1565 = msg - self.write("(path") - self.indent_sexp() - self.newline() - self.write(self.format_string_value(fields1565)) - self.dedent() - self.write(")") + _dollar_dollar = msg + if _dollar_dollar[0] != "": + _t1750 = _dollar_dollar[0] + else: + _t1750 = None + deconstruct_result1572 = _t1750 + if deconstruct_result1572 is not None: + assert deconstruct_result1572 is not None + unwrapped1573 = deconstruct_result1572 + self.write("(path") + self.indent_sexp() + self.newline() + self.write(self.format_string_value(unwrapped1573)) + self.dedent() + self.write(")") + else: + _dollar_dollar = msg + if _dollar_dollar[1] != "": + _t1751 = _dollar_dollar[1] + else: + _t1751 = None + deconstruct_result1570 = _t1751 + if deconstruct_result1570 is not None: + assert deconstruct_result1570 is not None + unwrapped1571 = deconstruct_result1570 + self.write("(transaction_output_name") + self.indent_sexp() + self.newline() + self.pretty_name(unwrapped1571) + 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): - flat1573 = self._try_flat(msg, self.pretty_export_csv_source) - if flat1573 is not None: - assert flat1573 is not None - self.write(flat1573) + flat1581 = self._try_flat(msg, self.pretty_export_csv_source) + if flat1581 is not None: + assert flat1581 is not None + self.write(flat1581) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("gnf_columns"): - _t1739 = _dollar_dollar.gnf_columns.columns + _t1752 = _dollar_dollar.gnf_columns.columns else: - _t1739 = None - deconstruct_result1569 = _t1739 - if deconstruct_result1569 is not None: - assert deconstruct_result1569 is not None - unwrapped1570 = deconstruct_result1569 + _t1752 = None + deconstruct_result1577 = _t1752 + if deconstruct_result1577 is not None: + assert deconstruct_result1577 is not None + unwrapped1578 = deconstruct_result1577 self.write("(gnf_columns") self.indent_sexp() - if not len(unwrapped1570) == 0: + if not len(unwrapped1578) == 0: self.newline() - for i1572, elem1571 in enumerate(unwrapped1570): - if (i1572 > 0): + for i1580, elem1579 in enumerate(unwrapped1578): + if (i1580 > 0): self.newline() - self.pretty_export_csv_column(elem1571) + self.pretty_export_csv_column(elem1579) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("table_def"): - _t1740 = _dollar_dollar.table_def + _t1753 = _dollar_dollar.table_def else: - _t1740 = None - deconstruct_result1567 = _t1740 - if deconstruct_result1567 is not None: - assert deconstruct_result1567 is not None - unwrapped1568 = deconstruct_result1567 + _t1753 = None + deconstruct_result1575 = _t1753 + if deconstruct_result1575 is not None: + assert deconstruct_result1575 is not None + unwrapped1576 = deconstruct_result1575 self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped1568) + self.pretty_relation_id(unwrapped1576) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_source") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): - flat1578 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1578 is not None: - assert flat1578 is not None - self.write(flat1578) + flat1586 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1586 is not None: + assert flat1586 is not None + self.write(flat1586) return None else: _dollar_dollar = msg - fields1574 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - assert fields1574 is not None - unwrapped_fields1575 = fields1574 + fields1582 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + assert fields1582 is not None + unwrapped_fields1583 = fields1582 self.write("(column") self.indent_sexp() self.newline() - field1576 = unwrapped_fields1575[0] - self.write(self.format_string_value(field1576)) + field1584 = unwrapped_fields1583[0] + self.write(self.format_string_value(field1584)) + self.newline() + field1585 = unwrapped_fields1583[1] + self.pretty_relation_id(field1585) + self.dedent() + self.write(")") + + def pretty_export_csv_path(self, msg: str): + flat1588 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1588 is not None: + assert flat1588 is not None + self.write(flat1588) + return None + else: + fields1587 = msg + self.write("(path") + self.indent_sexp() self.newline() - field1577 = unwrapped_fields1575[1] - self.pretty_relation_id(field1577) + self.write(self.format_string_value(fields1587)) self.dedent() self.write(")") def pretty_export_csv_columns_list(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - flat1582 = self._try_flat(msg, self.pretty_export_csv_columns_list) - if flat1582 is not None: - assert flat1582 is not None - self.write(flat1582) + flat1592 = self._try_flat(msg, self.pretty_export_csv_columns_list) + if flat1592 is not None: + assert flat1592 is not None + self.write(flat1592) return None else: - fields1579 = msg + fields1589 = msg self.write("(columns") self.indent_sexp() - if not len(fields1579) == 0: + if not len(fields1589) == 0: self.newline() - for i1581, elem1580 in enumerate(fields1579): - if (i1581 > 0): + for i1591, elem1590 in enumerate(fields1589): + if (i1591 > 0): self.newline() - self.pretty_export_csv_column(elem1580) + self.pretty_export_csv_column(elem1590) self.dedent() self.write(")") def pretty_export_iceberg_config(self, msg: transactions_pb2.ExportIcebergConfig): - flat1591 = self._try_flat(msg, self.pretty_export_iceberg_config) - if flat1591 is not None: - assert flat1591 is not None - self.write(flat1591) + flat1601 = self._try_flat(msg, self.pretty_export_iceberg_config) + if flat1601 is not None: + assert flat1601 is not None + self.write(flat1601) return None else: _dollar_dollar = msg - _t1741 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1583 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1741,) - assert fields1583 is not None - unwrapped_fields1584 = fields1583 + _t1754 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) + fields1593 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1754,) + assert fields1593 is not None + unwrapped_fields1594 = fields1593 self.write("(export_iceberg_config") self.indent_sexp() self.newline() - field1585 = unwrapped_fields1584[0] - self.pretty_iceberg_locator(field1585) + field1595 = unwrapped_fields1594[0] + self.pretty_iceberg_locator(field1595) self.newline() - field1586 = unwrapped_fields1584[1] - self.pretty_iceberg_catalog_config(field1586) + field1596 = unwrapped_fields1594[1] + self.pretty_iceberg_catalog_config(field1596) self.newline() - field1587 = unwrapped_fields1584[2] - self.pretty_export_iceberg_table_def(field1587) + field1597 = unwrapped_fields1594[2] + self.pretty_export_iceberg_table_def(field1597) self.newline() - field1588 = unwrapped_fields1584[3] - self.pretty_iceberg_table_properties(field1588) - field1589 = unwrapped_fields1584[4] - if field1589 is not None: + field1598 = unwrapped_fields1594[3] + self.pretty_iceberg_table_properties(field1598) + field1599 = unwrapped_fields1594[4] + if field1599 is not None: self.newline() - assert field1589 is not None - opt_val1590 = field1589 - self.pretty_config_dict(opt_val1590) + assert field1599 is not None + opt_val1600 = field1599 + self.pretty_config_dict(opt_val1600) self.dedent() self.write(")") def pretty_export_iceberg_table_def(self, msg: logic_pb2.RelationId): - flat1593 = self._try_flat(msg, self.pretty_export_iceberg_table_def) - if flat1593 is not None: - assert flat1593 is not None - self.write(flat1593) + flat1603 = self._try_flat(msg, self.pretty_export_iceberg_table_def) + if flat1603 is not None: + assert flat1603 is not None + self.write(flat1603) return None else: - fields1592 = msg + fields1602 = msg self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(fields1592) + self.pretty_relation_id(fields1602) self.dedent() self.write(")") def pretty_iceberg_table_properties(self, msg: Sequence[tuple[str, str]]): - flat1597 = self._try_flat(msg, self.pretty_iceberg_table_properties) - if flat1597 is not None: - assert flat1597 is not None - self.write(flat1597) + flat1607 = self._try_flat(msg, self.pretty_iceberg_table_properties) + if flat1607 is not None: + assert flat1607 is not None + self.write(flat1607) return None else: - fields1594 = msg + fields1604 = msg self.write("(table_properties") self.indent_sexp() - if not len(fields1594) == 0: + if not len(fields1604) == 0: self.newline() - for i1596, elem1595 in enumerate(fields1594): - if (i1596 > 0): + for i1606, elem1605 in enumerate(fields1604): + if (i1606 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1595) + self.pretty_iceberg_property_entry(elem1605) self.dedent() self.write(")") @@ -4390,8 +4435,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1793 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1793) + _t1806 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1806) self.write(" ") self.write(self.format_string_value(msg.orig_names[_idx])) self.write(")") diff --git a/sdks/python/src/lqp/proto/v1/transactions_pb2.py b/sdks/python/src/lqp/proto/v1/transactions_pb2.py index 7485f539..c74a7f05 100644 --- a/sdks/python/src/lqp/proto/v1/transactions_pb2.py +++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.py @@ -26,7 +26,7 @@ from lqp.proto.v1 import logic_pb2 as relationalai_dot_lqp_dot_v1_dot_logic__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&relationalai/lqp/v1/transactions.proto\x12\x13relationalai.lqp.v1\x1a#relationalai/lqp/v1/fragments.proto\x1a\x1frelationalai/lqp/v1/logic.proto\"\xbc\x01\n\x0bTransaction\x12\x32\n\x06\x65pochs\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x06\x65pochs\x12<\n\tconfigure\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.ConfigureR\tconfigure\x12\x32\n\x04sync\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.SyncH\x00R\x04sync\x88\x01\x01\x42\x07\n\x05_sync\"w\n\tConfigure\x12+\n\x11semantics_version\x18\x01 \x01(\x03R\x10semanticsVersion\x12=\n\nivm_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.IVMConfigR\tivmConfig\"H\n\tIVMConfig\x12;\n\x05level\x18\x01 \x01(\x0e\x32%.relationalai.lqp.v1.MaintenanceLevelR\x05level\"E\n\x04Sync\x12=\n\tfragments\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\tfragments\"l\n\x05\x45poch\x12\x32\n\x06writes\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.WriteR\x06writes\x12/\n\x05reads\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.ReadR\x05reads\"\x86\x02\n\x05Write\x12\x35\n\x06\x64\x65\x66ine\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DefineH\x00R\x06\x64\x65\x66ine\x12;\n\x08undefine\x18\x02 \x01(\x0b\x32\x1d.relationalai.lqp.v1.UndefineH\x00R\x08undefine\x12\x38\n\x07\x63ontext\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.ContextH\x00R\x07\x63ontext\x12;\n\x08snapshot\x18\x05 \x01(\x0b\x32\x1d.relationalai.lqp.v1.SnapshotH\x00R\x08snapshotB\x0c\n\nwrite_typeJ\x04\x08\x04\x10\x05\"C\n\x06\x44\x65\x66ine\x12\x39\n\x08\x66ragment\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.FragmentR\x08\x66ragment\"L\n\x08Undefine\x12@\n\x0b\x66ragment_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\nfragmentId\"H\n\x07\x43ontext\x12=\n\trelations\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\trelations\"\x86\x01\n\x0fSnapshotMapping\x12)\n\x10\x64\x65stination_path\x18\x01 \x03(\tR\x0f\x64\x65stinationPath\x12H\n\x0fsource_relation\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x0esourceRelation\"d\n\x08Snapshot\x12@\n\x08mappings\x18\x01 \x03(\x0b\x32$.relationalai.lqp.v1.SnapshotMappingR\x08mappings\x12\x16\n\x06prefix\x18\x02 \x03(\tR\x06prefix\"\xc8\x05\n\x0f\x45xportCSVConfig\x12\x12\n\x04path\x18\x01 \x01(\tR\x04path\x12\x43\n\ncsv_source\x18\n \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVSourceR\tcsvSource\x12=\n\ncsv_config\x18\x0b \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\tcsvConfig\x12G\n\x0c\x64\x61ta_columns\x18\x02 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x0b\x64\x61taColumns\x12*\n\x0epartition_size\x18\x03 \x01(\x03H\x00R\rpartitionSize\x88\x01\x01\x12%\n\x0b\x63ompression\x18\x04 \x01(\tH\x01R\x0b\x63ompression\x88\x01\x01\x12/\n\x11syntax_header_row\x18\x05 \x01(\x08H\x02R\x0fsyntaxHeaderRow\x88\x01\x01\x12\x37\n\x15syntax_missing_string\x18\x06 \x01(\tH\x03R\x13syntaxMissingString\x88\x01\x01\x12&\n\x0csyntax_delim\x18\x07 \x01(\tH\x04R\x0bsyntaxDelim\x88\x01\x01\x12.\n\x10syntax_quotechar\x18\x08 \x01(\tH\x05R\x0fsyntaxQuotechar\x88\x01\x01\x12\x30\n\x11syntax_escapechar\x18\t \x01(\tH\x06R\x10syntaxEscapechar\x88\x01\x01\x42\x11\n\x0f_partition_sizeB\x0e\n\x0c_compressionB\x14\n\x12_syntax_header_rowB\x18\n\x16_syntax_missing_stringB\x0f\n\r_syntax_delimB\x13\n\x11_syntax_quotecharB\x14\n\x12_syntax_escapechar\"t\n\x0f\x45xportCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12@\n\x0b\x63olumn_data\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\ncolumnData\"R\n\x10\x45xportCSVColumns\x12>\n\x07\x63olumns\x18\x01 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x07\x63olumns\"\xa9\x01\n\x0f\x45xportCSVSource\x12H\n\x0bgnf_columns\x18\x01 \x01(\x0b\x32%.relationalai.lqp.v1.ExportCSVColumnsH\x00R\ngnfColumns\x12>\n\ttable_def\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdH\x00R\x08tableDefB\x0c\n\ncsv_source\"\xa8\x04\n\x13\x45xportIcebergConfig\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<\n\ttable_def\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08tableDef\x12\x1b\n\x06prefix\x18\x05 \x01(\tH\x00R\x06prefix\x88\x01\x01\x12\x38\n\x16target_file_size_bytes\x18\x06 \x01(\x03H\x01R\x13targetFileSizeBytes\x88\x01\x01\x12 \n\x0b\x63ompression\x18\x07 \x01(\tR\x0b\x63ompression\x12h\n\x10table_properties\x18\x08 \x03(\x0b\x32=.relationalai.lqp.v1.ExportIcebergConfig.TablePropertiesEntryR\x0ftableProperties\x1a\x42\n\x14TablePropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\t\n\x07_prefixB\x19\n\x17_target_file_size_bytesJ\x04\x08\x04\x10\x05\"\xa4\x02\n\x04Read\x12\x35\n\x06\x64\x65mand\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DemandH\x00R\x06\x64\x65mand\x12\x35\n\x06output\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.OutputH\x00R\x06output\x12\x36\n\x07what_if\x18\x03 \x01(\x0b\x32\x1b.relationalai.lqp.v1.WhatIfH\x00R\x06whatIf\x12\x32\n\x05\x61\x62ort\x18\x04 \x01(\x0b\x32\x1a.relationalai.lqp.v1.AbortH\x00R\x05\x61\x62ort\x12\x35\n\x06\x65xport\x18\x05 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExportH\x00R\x06\x65xportB\x0b\n\tread_type\"J\n\x06\x44\x65mand\x12@\n\x0brelation_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"^\n\x06Output\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"\xb3\x01\n\x06\x45xport\x12\x45\n\ncsv_config\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVConfigH\x00R\tcsvConfig\x12Q\n\x0eiceberg_config\x18\x02 \x01(\x0b\x32(.relationalai.lqp.v1.ExportIcebergConfigH\x00R\ricebergConfigB\x0f\n\rexport_config\"R\n\x06WhatIf\x12\x16\n\x06\x62ranch\x18\x01 \x01(\tR\x06\x62ranch\x12\x30\n\x05\x65poch\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x05\x65poch\"]\n\x05\x41\x62ort\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId*\x87\x01\n\x10MaintenanceLevel\x12!\n\x1dMAINTENANCE_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n\x15MAINTENANCE_LEVEL_OFF\x10\x01\x12\x1a\n\x16MAINTENANCE_LEVEL_AUTO\x10\x02\x12\x19\n\x15MAINTENANCE_LEVEL_ALL\x10\x03\x42\x43ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n&relationalai/lqp/v1/transactions.proto\x12\x13relationalai.lqp.v1\x1a#relationalai/lqp/v1/fragments.proto\x1a\x1frelationalai/lqp/v1/logic.proto\"\xbc\x01\n\x0bTransaction\x12\x32\n\x06\x65pochs\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x06\x65pochs\x12<\n\tconfigure\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.ConfigureR\tconfigure\x12\x32\n\x04sync\x18\x03 \x01(\x0b\x32\x19.relationalai.lqp.v1.SyncH\x00R\x04sync\x88\x01\x01\x42\x07\n\x05_sync\"w\n\tConfigure\x12+\n\x11semantics_version\x18\x01 \x01(\x03R\x10semanticsVersion\x12=\n\nivm_config\x18\x02 \x01(\x0b\x32\x1e.relationalai.lqp.v1.IVMConfigR\tivmConfig\"H\n\tIVMConfig\x12;\n\x05level\x18\x01 \x01(\x0e\x32%.relationalai.lqp.v1.MaintenanceLevelR\x05level\"E\n\x04Sync\x12=\n\tfragments\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\tfragments\"l\n\x05\x45poch\x12\x32\n\x06writes\x18\x01 \x03(\x0b\x32\x1a.relationalai.lqp.v1.WriteR\x06writes\x12/\n\x05reads\x18\x02 \x03(\x0b\x32\x19.relationalai.lqp.v1.ReadR\x05reads\"\x86\x02\n\x05Write\x12\x35\n\x06\x64\x65\x66ine\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DefineH\x00R\x06\x64\x65\x66ine\x12;\n\x08undefine\x18\x02 \x01(\x0b\x32\x1d.relationalai.lqp.v1.UndefineH\x00R\x08undefine\x12\x38\n\x07\x63ontext\x18\x03 \x01(\x0b\x32\x1c.relationalai.lqp.v1.ContextH\x00R\x07\x63ontext\x12;\n\x08snapshot\x18\x05 \x01(\x0b\x32\x1d.relationalai.lqp.v1.SnapshotH\x00R\x08snapshotB\x0c\n\nwrite_typeJ\x04\x08\x04\x10\x05\"C\n\x06\x44\x65\x66ine\x12\x39\n\x08\x66ragment\x18\x01 \x01(\x0b\x32\x1d.relationalai.lqp.v1.FragmentR\x08\x66ragment\"L\n\x08Undefine\x12@\n\x0b\x66ragment_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.FragmentIdR\nfragmentId\"H\n\x07\x43ontext\x12=\n\trelations\x18\x01 \x03(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\trelations\"\x86\x01\n\x0fSnapshotMapping\x12)\n\x10\x64\x65stination_path\x18\x01 \x03(\tR\x0f\x64\x65stinationPath\x12H\n\x0fsource_relation\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x0esourceRelation\"d\n\x08Snapshot\x12@\n\x08mappings\x18\x01 \x03(\x0b\x32$.relationalai.lqp.v1.SnapshotMappingR\x08mappings\x12\x16\n\x06prefix\x18\x02 \x03(\tR\x06prefix\"\x80\x06\n\x0f\x45xportCSVConfig\x12\x12\n\x04path\x18\x01 \x01(\tR\x04path\x12\x36\n\x17transaction_output_name\x18\x0c \x01(\tR\x15transactionOutputName\x12\x43\n\ncsv_source\x18\n \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVSourceR\tcsvSource\x12=\n\ncsv_config\x18\x0b \x01(\x0b\x32\x1e.relationalai.lqp.v1.CSVConfigR\tcsvConfig\x12G\n\x0c\x64\x61ta_columns\x18\x02 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x0b\x64\x61taColumns\x12*\n\x0epartition_size\x18\x03 \x01(\x03H\x00R\rpartitionSize\x88\x01\x01\x12%\n\x0b\x63ompression\x18\x04 \x01(\tH\x01R\x0b\x63ompression\x88\x01\x01\x12/\n\x11syntax_header_row\x18\x05 \x01(\x08H\x02R\x0fsyntaxHeaderRow\x88\x01\x01\x12\x37\n\x15syntax_missing_string\x18\x06 \x01(\tH\x03R\x13syntaxMissingString\x88\x01\x01\x12&\n\x0csyntax_delim\x18\x07 \x01(\tH\x04R\x0bsyntaxDelim\x88\x01\x01\x12.\n\x10syntax_quotechar\x18\x08 \x01(\tH\x05R\x0fsyntaxQuotechar\x88\x01\x01\x12\x30\n\x11syntax_escapechar\x18\t \x01(\tH\x06R\x10syntaxEscapechar\x88\x01\x01\x42\x11\n\x0f_partition_sizeB\x0e\n\x0c_compressionB\x14\n\x12_syntax_header_rowB\x18\n\x16_syntax_missing_stringB\x0f\n\r_syntax_delimB\x13\n\x11_syntax_quotecharB\x14\n\x12_syntax_escapechar\"t\n\x0f\x45xportCSVColumn\x12\x1f\n\x0b\x63olumn_name\x18\x01 \x01(\tR\ncolumnName\x12@\n\x0b\x63olumn_data\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\ncolumnData\"R\n\x10\x45xportCSVColumns\x12>\n\x07\x63olumns\x18\x01 \x03(\x0b\x32$.relationalai.lqp.v1.ExportCSVColumnR\x07\x63olumns\"\xa9\x01\n\x0f\x45xportCSVSource\x12H\n\x0bgnf_columns\x18\x01 \x01(\x0b\x32%.relationalai.lqp.v1.ExportCSVColumnsH\x00R\ngnfColumns\x12>\n\ttable_def\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdH\x00R\x08tableDefB\x0c\n\ncsv_source\"\xa8\x04\n\x13\x45xportIcebergConfig\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<\n\ttable_def\x18\x03 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\x08tableDef\x12\x1b\n\x06prefix\x18\x05 \x01(\tH\x00R\x06prefix\x88\x01\x01\x12\x38\n\x16target_file_size_bytes\x18\x06 \x01(\x03H\x01R\x13targetFileSizeBytes\x88\x01\x01\x12 \n\x0b\x63ompression\x18\x07 \x01(\tR\x0b\x63ompression\x12h\n\x10table_properties\x18\x08 \x03(\x0b\x32=.relationalai.lqp.v1.ExportIcebergConfig.TablePropertiesEntryR\x0ftableProperties\x1a\x42\n\x14TablePropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\x42\t\n\x07_prefixB\x19\n\x17_target_file_size_bytesJ\x04\x08\x04\x10\x05\"\xa4\x02\n\x04Read\x12\x35\n\x06\x64\x65mand\x18\x01 \x01(\x0b\x32\x1b.relationalai.lqp.v1.DemandH\x00R\x06\x64\x65mand\x12\x35\n\x06output\x18\x02 \x01(\x0b\x32\x1b.relationalai.lqp.v1.OutputH\x00R\x06output\x12\x36\n\x07what_if\x18\x03 \x01(\x0b\x32\x1b.relationalai.lqp.v1.WhatIfH\x00R\x06whatIf\x12\x32\n\x05\x61\x62ort\x18\x04 \x01(\x0b\x32\x1a.relationalai.lqp.v1.AbortH\x00R\x05\x61\x62ort\x12\x35\n\x06\x65xport\x18\x05 \x01(\x0b\x32\x1b.relationalai.lqp.v1.ExportH\x00R\x06\x65xportB\x0b\n\tread_type\"J\n\x06\x44\x65mand\x12@\n\x0brelation_id\x18\x01 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"^\n\x06Output\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId\"\xb3\x01\n\x06\x45xport\x12\x45\n\ncsv_config\x18\x01 \x01(\x0b\x32$.relationalai.lqp.v1.ExportCSVConfigH\x00R\tcsvConfig\x12Q\n\x0eiceberg_config\x18\x02 \x01(\x0b\x32(.relationalai.lqp.v1.ExportIcebergConfigH\x00R\ricebergConfigB\x0f\n\rexport_config\"R\n\x06WhatIf\x12\x16\n\x06\x62ranch\x18\x01 \x01(\tR\x06\x62ranch\x12\x30\n\x05\x65poch\x18\x02 \x01(\x0b\x32\x1a.relationalai.lqp.v1.EpochR\x05\x65poch\"]\n\x05\x41\x62ort\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12@\n\x0brelation_id\x18\x02 \x01(\x0b\x32\x1f.relationalai.lqp.v1.RelationIdR\nrelationId*\x87\x01\n\x10MaintenanceLevel\x12!\n\x1dMAINTENANCE_LEVEL_UNSPECIFIED\x10\x00\x12\x19\n\x15MAINTENANCE_LEVEL_OFF\x10\x01\x12\x1a\n\x16MAINTENANCE_LEVEL_AUTO\x10\x02\x12\x19\n\x15MAINTENANCE_LEVEL_ALL\x10\x03\x42\x43ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -36,8 +36,8 @@ _globals['DESCRIPTOR']._serialized_options = b'ZAgithub.com/RelationalAI/logical-query-protocol/sdks/go/src/lqp/v1' _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._loaded_options = None _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_options = b'8\001' - _globals['_MAINTENANCELEVEL']._serialized_start=3898 - _globals['_MAINTENANCELEVEL']._serialized_end=4033 + _globals['_MAINTENANCELEVEL']._serialized_start=3954 + _globals['_MAINTENANCELEVEL']._serialized_end=4089 _globals['_TRANSACTION']._serialized_start=134 _globals['_TRANSACTION']._serialized_end=322 _globals['_CONFIGURE']._serialized_start=324 @@ -61,27 +61,27 @@ _globals['_SNAPSHOT']._serialized_start=1323 _globals['_SNAPSHOT']._serialized_end=1423 _globals['_EXPORTCSVCONFIG']._serialized_start=1426 - _globals['_EXPORTCSVCONFIG']._serialized_end=2138 - _globals['_EXPORTCSVCOLUMN']._serialized_start=2140 - _globals['_EXPORTCSVCOLUMN']._serialized_end=2256 - _globals['_EXPORTCSVCOLUMNS']._serialized_start=2258 - _globals['_EXPORTCSVCOLUMNS']._serialized_end=2340 - _globals['_EXPORTCSVSOURCE']._serialized_start=2343 - _globals['_EXPORTCSVSOURCE']._serialized_end=2512 - _globals['_EXPORTICEBERGCONFIG']._serialized_start=2515 - _globals['_EXPORTICEBERGCONFIG']._serialized_end=3067 - _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_start=2957 - _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_end=3023 - _globals['_READ']._serialized_start=3070 - _globals['_READ']._serialized_end=3362 - _globals['_DEMAND']._serialized_start=3364 - _globals['_DEMAND']._serialized_end=3438 - _globals['_OUTPUT']._serialized_start=3440 - _globals['_OUTPUT']._serialized_end=3534 - _globals['_EXPORT']._serialized_start=3537 - _globals['_EXPORT']._serialized_end=3716 - _globals['_WHATIF']._serialized_start=3718 - _globals['_WHATIF']._serialized_end=3800 - _globals['_ABORT']._serialized_start=3802 - _globals['_ABORT']._serialized_end=3895 + _globals['_EXPORTCSVCONFIG']._serialized_end=2194 + _globals['_EXPORTCSVCOLUMN']._serialized_start=2196 + _globals['_EXPORTCSVCOLUMN']._serialized_end=2312 + _globals['_EXPORTCSVCOLUMNS']._serialized_start=2314 + _globals['_EXPORTCSVCOLUMNS']._serialized_end=2396 + _globals['_EXPORTCSVSOURCE']._serialized_start=2399 + _globals['_EXPORTCSVSOURCE']._serialized_end=2568 + _globals['_EXPORTICEBERGCONFIG']._serialized_start=2571 + _globals['_EXPORTICEBERGCONFIG']._serialized_end=3123 + _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_start=3013 + _globals['_EXPORTICEBERGCONFIG_TABLEPROPERTIESENTRY']._serialized_end=3079 + _globals['_READ']._serialized_start=3126 + _globals['_READ']._serialized_end=3418 + _globals['_DEMAND']._serialized_start=3420 + _globals['_DEMAND']._serialized_end=3494 + _globals['_OUTPUT']._serialized_start=3496 + _globals['_OUTPUT']._serialized_end=3590 + _globals['_EXPORT']._serialized_start=3593 + _globals['_EXPORT']._serialized_end=3772 + _globals['_WHATIF']._serialized_start=3774 + _globals['_WHATIF']._serialized_end=3856 + _globals['_ABORT']._serialized_start=3858 + _globals['_ABORT']._serialized_end=3951 # @@protoc_insertion_point(module_scope) diff --git a/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi b/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi index f0beccf5..78c1c0b2 100644 --- a/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi +++ b/sdks/python/src/lqp/proto/v1/transactions_pb2.pyi @@ -105,8 +105,9 @@ class Snapshot(_message.Message): def __init__(self, mappings: _Optional[_Iterable[_Union[SnapshotMapping, _Mapping]]] = ..., prefix: _Optional[_Iterable[str]] = ...) -> None: ... class ExportCSVConfig(_message.Message): - __slots__ = ("path", "csv_source", "csv_config", "data_columns", "partition_size", "compression", "syntax_header_row", "syntax_missing_string", "syntax_delim", "syntax_quotechar", "syntax_escapechar") + __slots__ = ("path", "transaction_output_name", "csv_source", "csv_config", "data_columns", "partition_size", "compression", "syntax_header_row", "syntax_missing_string", "syntax_delim", "syntax_quotechar", "syntax_escapechar") PATH_FIELD_NUMBER: _ClassVar[int] + TRANSACTION_OUTPUT_NAME_FIELD_NUMBER: _ClassVar[int] CSV_SOURCE_FIELD_NUMBER: _ClassVar[int] CSV_CONFIG_FIELD_NUMBER: _ClassVar[int] DATA_COLUMNS_FIELD_NUMBER: _ClassVar[int] @@ -118,6 +119,7 @@ class ExportCSVConfig(_message.Message): SYNTAX_QUOTECHAR_FIELD_NUMBER: _ClassVar[int] SYNTAX_ESCAPECHAR_FIELD_NUMBER: _ClassVar[int] path: str + transaction_output_name: str csv_source: ExportCSVSource csv_config: _logic_pb2.CSVConfig data_columns: _containers.RepeatedCompositeFieldContainer[ExportCSVColumn] @@ -128,7 +130,7 @@ class ExportCSVConfig(_message.Message): syntax_delim: str syntax_quotechar: str syntax_escapechar: str - def __init__(self, path: _Optional[str] = ..., csv_source: _Optional[_Union[ExportCSVSource, _Mapping]] = ..., csv_config: _Optional[_Union[_logic_pb2.CSVConfig, _Mapping]] = ..., data_columns: _Optional[_Iterable[_Union[ExportCSVColumn, _Mapping]]] = ..., partition_size: _Optional[int] = ..., compression: _Optional[str] = ..., syntax_header_row: _Optional[bool] = ..., syntax_missing_string: _Optional[str] = ..., syntax_delim: _Optional[str] = ..., syntax_quotechar: _Optional[str] = ..., syntax_escapechar: _Optional[str] = ...) -> None: ... + def __init__(self, path: _Optional[str] = ..., transaction_output_name: _Optional[str] = ..., csv_source: _Optional[_Union[ExportCSVSource, _Mapping]] = ..., csv_config: _Optional[_Union[_logic_pb2.CSVConfig, _Mapping]] = ..., data_columns: _Optional[_Iterable[_Union[ExportCSVColumn, _Mapping]]] = ..., partition_size: _Optional[int] = ..., compression: _Optional[str] = ..., syntax_header_row: _Optional[bool] = ..., syntax_missing_string: _Optional[str] = ..., syntax_delim: _Optional[str] = ..., syntax_quotechar: _Optional[str] = ..., syntax_escapechar: _Optional[str] = ...) -> None: ... class ExportCSVColumn(_message.Message): __slots__ = ("column_name", "column_data") diff --git a/sdks/python/uv.lock b/sdks/python/uv.lock index b04dc8d6..37e64873 100644 --- a/sdks/python/uv.lock +++ b/sdks/python/uv.lock @@ -62,7 +62,7 @@ wheels = [ [[package]] name = "lqp" -version = "0.5.2" +version = "0.5.3" source = { editable = "." } dependencies = [ { name = "protobuf" }, diff --git a/tests/bin/export_transaction_output.bin b/tests/bin/export_transaction_output.bin new file mode 100644 index 0000000000000000000000000000000000000000..0443893e89a99fdad9ce5d70c426a4dddb68bb16 GIT binary patch literal 384 zcmd=3&cwBuiE9HB*IFhn7A~eVL!lNXu0|#4y20nRfLViIBy+RLc4i;*i@Dw0dXON~pQC^aX(peQppvm~=DH9oaa zh)akAuA5DWMTkj&kxSQ08?Q `my_table` From e9c69c9a403de0f7efea19fed7ab4ed5bd85ae02 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Tue, 23 Jun 2026 12:44:15 +1000 Subject: [PATCH 5/6] Add ExportCSVColumns/Source equality and transaction_output_name to ExportCSVConfig ExportCSVColumns had no custom == so structural comparison fell back to identity, breaking ExportCSVSource comparisons. Add equality for ExportCSVColumns first, then ExportCSVSource, then wire csv_source, csv_config, and the new transaction_output_name field into ExportCSVConfig ==, hash, and isequal. Co-Authored-By: Claude Sonnet 4.6 --- .../LogicalQueryProtocol.jl/src/equality.jl | 16 +++++++++++++--- .../test/equality_tests.jl | 11 +++++++++++ 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl index 744d9de7..5ae81caa 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl @@ -342,10 +342,20 @@ Base.:(==)(a::ExportCSVColumn, b::ExportCSVColumn) = a.column_name == b.column_n Base.hash(a::ExportCSVColumn, h::UInt) = hash(a.column_data, hash(a.column_name, h)) Base.isequal(a::ExportCSVColumn, b::ExportCSVColumn) = isequal(a.column_name, b.column_name) && isequal(a.column_data, b.column_data) +# ExportCSVColumns +Base.:(==)(a::ExportCSVColumns, b::ExportCSVColumns) = a.columns == b.columns +Base.hash(a::ExportCSVColumns, h::UInt) = hash(a.columns, h) +Base.isequal(a::ExportCSVColumns, b::ExportCSVColumns) = isequal(a.columns, b.columns) + +# ExportCSVSource +Base.:(==)(a::ExportCSVSource, b::ExportCSVSource) = _isequal_oneof(a.csv_source, b.csv_source) +Base.hash(a::ExportCSVSource, h::UInt) = _hash_oneof(a.csv_source, h) +Base.isequal(a::ExportCSVSource, b::ExportCSVSource) = _isequal_oneof(a.csv_source, b.csv_source) + # ExportCSVConfig -Base.:(==)(a::ExportCSVConfig, b::ExportCSVConfig) = a.path == b.path && a.data_columns == b.data_columns && a.partition_size == b.partition_size && a.compression == b.compression && a.syntax_header_row == b.syntax_header_row && a.syntax_missing_string == b.syntax_missing_string && a.syntax_delim == b.syntax_delim && a.syntax_quotechar == b.syntax_quotechar && a.syntax_escapechar == b.syntax_escapechar -Base.hash(a::ExportCSVConfig, h::UInt) = hash(a.syntax_escapechar, hash(a.syntax_quotechar, hash(a.syntax_delim, hash(a.syntax_missing_string, hash(a.syntax_header_row, hash(a.compression, hash(a.partition_size, hash(a.data_columns, hash(a.path, h))))))))) -Base.isequal(a::ExportCSVConfig, b::ExportCSVConfig) = isequal(a.path, b.path) && isequal(a.data_columns, b.data_columns) && isequal(a.partition_size, b.partition_size) && isequal(a.compression, b.compression) && isequal(a.syntax_header_row, b.syntax_header_row) && isequal(a.syntax_missing_string, b.syntax_missing_string) && isequal(a.syntax_delim, b.syntax_delim) && isequal(a.syntax_quotechar, b.syntax_quotechar) && isequal(a.syntax_escapechar, b.syntax_escapechar) +Base.:(==)(a::ExportCSVConfig, b::ExportCSVConfig) = a.path == b.path && a.transaction_output_name == b.transaction_output_name && a.csv_source == b.csv_source && a.csv_config == b.csv_config && a.data_columns == b.data_columns && a.partition_size == b.partition_size && a.compression == b.compression && a.syntax_header_row == b.syntax_header_row && a.syntax_missing_string == b.syntax_missing_string && a.syntax_delim == b.syntax_delim && a.syntax_quotechar == b.syntax_quotechar && a.syntax_escapechar == b.syntax_escapechar +Base.hash(a::ExportCSVConfig, h::UInt) = hash(a.syntax_escapechar, hash(a.syntax_quotechar, hash(a.syntax_delim, hash(a.syntax_missing_string, hash(a.syntax_header_row, hash(a.compression, hash(a.partition_size, hash(a.data_columns, hash(a.csv_config, hash(a.csv_source, hash(a.transaction_output_name, hash(a.path, h)))))))))))) +Base.isequal(a::ExportCSVConfig, b::ExportCSVConfig) = isequal(a.path, b.path) && isequal(a.transaction_output_name, b.transaction_output_name) && isequal(a.csv_source, b.csv_source) && isequal(a.csv_config, b.csv_config) && isequal(a.data_columns, b.data_columns) && isequal(a.partition_size, b.partition_size) && isequal(a.compression, b.compression) && isequal(a.syntax_header_row, b.syntax_header_row) && isequal(a.syntax_missing_string, b.syntax_missing_string) && isequal(a.syntax_delim, b.syntax_delim) && isequal(a.syntax_quotechar, b.syntax_quotechar) && isequal(a.syntax_escapechar, b.syntax_escapechar) # IcebergLocator Base.:(==)(a::IcebergLocator, b::IcebergLocator) = diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl index 4b5cde4b..53bdc70b 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl @@ -1695,6 +1695,17 @@ end data_columns=[col1, col2] ) + # transaction_output_name distinguishes from path-based config + cfg_tx1 = ExportCSVConfig(transaction_output_name="my_result") + cfg_tx2 = ExportCSVConfig(transaction_output_name="my_result") + cfg_tx3 = ExportCSVConfig(transaction_output_name="other_result") + @test cfg_tx1 == cfg_tx2 + @test cfg_tx1 != cfg_tx3 + @test cfg_tx1 != cfg1 + @test isequal(cfg_tx1, cfg_tx2) + @test hash(cfg_tx1) == hash(cfg_tx2) + @test hash(cfg_tx1) != hash(cfg_tx3) + # Equality and inequality @test cfg1 == cfg2 @test cfg1 != cfg3 From c48b2ed821ec8def7d76f65fd363e0f737ca3851 Mon Sep 17 00:00:00 2001 From: David Zhao Date: Wed, 24 Jun 2026 16:33:43 +1000 Subject: [PATCH 6/6] Regenerate parsers and printers --- sdks/go/src/parser.go | 10427 ++++++++-------------------- sdks/go/src/pretty.go | 7927 ++++++--------------- sdks/python/src/lqp/gen/parser.py | 8539 +++++++---------------- sdks/python/src/lqp/gen/pretty.py | 9697 ++++++++------------------ 4 files changed, 10420 insertions(+), 26170 deletions(-) diff --git a/sdks/go/src/parser.go b/sdks/go/src/parser.go index b7d57190..dc0ac259 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -655,362 +655,206 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { -<<<<<<< HEAD - var _t2113 interface{} + var _t2212 interface{} if (value != nil && hasProtoField(value, "int32_value")) { return value.GetInt32Value() } - _ = _t2113 -======= - var _t2200 interface{} - if (value != nil && hasProtoField(value, "int32_value")) { - return value.GetInt32Value() - } - _ = _t2200 ->>>>>>> origin/main + _ = _t2212 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { -<<<<<<< HEAD - var _t2114 interface{} - if (value != nil && hasProtoField(value, "int_value")) { - return value.GetIntValue() - } - _ = _t2114 -======= - var _t2201 interface{} + var _t2213 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2201 ->>>>>>> origin/main + _ = _t2213 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { -<<<<<<< HEAD - var _t2115 interface{} + var _t2214 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2115 -======= - var _t2202 interface{} - if (value != nil && hasProtoField(value, "string_value")) { - return value.GetStringValue() - } - _ = _t2202 ->>>>>>> origin/main + _ = _t2214 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { -<<<<<<< HEAD - var _t2116 interface{} - if (value != nil && hasProtoField(value, "boolean_value")) { - return value.GetBooleanValue() - } - _ = _t2116 -======= - var _t2203 interface{} + var _t2215 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2203 ->>>>>>> origin/main + _ = _t2215 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { -<<<<<<< HEAD - var _t2117 interface{} - if (value != nil && hasProtoField(value, "string_value")) { - return []string{value.GetStringValue()} - } - _ = _t2117 -======= - var _t2204 interface{} + var _t2216 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2204 ->>>>>>> origin/main + _ = _t2216 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { -<<<<<<< HEAD - var _t2118 interface{} - if (value != nil && hasProtoField(value, "int_value")) { - return ptr(value.GetIntValue()) - } - _ = _t2118 -======= - var _t2205 interface{} + var _t2217 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2205 ->>>>>>> origin/main + _ = _t2217 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { -<<<<<<< HEAD - var _t2119 interface{} + var _t2218 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2119 -======= - var _t2206 interface{} - if (value != nil && hasProtoField(value, "float_value")) { - return ptr(value.GetFloatValue()) - } - _ = _t2206 ->>>>>>> origin/main + _ = _t2218 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { -<<<<<<< HEAD - var _t2120 interface{} - if (value != nil && hasProtoField(value, "string_value")) { - return []byte(value.GetStringValue()) - } - _ = _t2120 -======= - var _t2207 interface{} + var _t2219 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2207 ->>>>>>> origin/main + _ = _t2219 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { -<<<<<<< HEAD - var _t2121 interface{} - if (value != nil && hasProtoField(value, "uint128_value")) { - return value.GetUint128Value() - } - _ = _t2121 -======= - var _t2208 interface{} + var _t2220 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2208 ->>>>>>> origin/main + _ = _t2220 return nil } func (p *Parser) construct_non_cdc_relations(targets []*pb.TargetRelation) *pb.TargetRelations { - _t2209 := &pb.PlainTargets{Targets: targets} - _t2210 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2210.Body = &pb.TargetRelations_Plain{Plain: _t2209} - return _t2210 + _t2221 := &pb.PlainTargets{Targets: targets} + _t2222 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2222.Body = &pb.TargetRelations_Plain{Plain: _t2221} + return _t2222 } func (p *Parser) construct_cdc_relations(inserts []*pb.TargetRelation, deletes []*pb.TargetRelation) *pb.TargetRelations { - _t2211 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} - _t2212 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} - _t2212.Body = &pb.TargetRelations_Cdc{Cdc: _t2211} - return _t2212 + _t2223 := &pb.CDCTargets{Inserts: inserts, Deletes: deletes} + _t2224 := &pb.TargetRelations{Keys: []*pb.NamedColumn{}} + _t2224.Body = &pb.TargetRelations_Cdc{Cdc: _t2223} + return _t2224 } func (p *Parser) construct_relations(keys []*pb.NamedColumn, body *pb.TargetRelations) *pb.TargetRelations { - var _t2213 interface{} + var _t2225 interface{} if hasProtoField(body, "plain") { - _t2214 := &pb.TargetRelations{Keys: keys} - _t2214.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} - return _t2214 + _t2226 := &pb.TargetRelations{Keys: keys} + _t2226.Body = &pb.TargetRelations_Plain{Plain: body.GetPlain()} + return _t2226 } - _ = _t2213 - _t2215 := &pb.TargetRelations{Keys: keys} - _t2215.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} - return _t2215 + _ = _t2225 + _t2227 := &pb.TargetRelations{Keys: keys} + _t2227.Body = &pb.TargetRelations_Cdc{Cdc: body.GetCdc()} + return _t2227 } func (p *Parser) construct_csv_data(locator *pb.CSVLocator, config *pb.CSVConfig, columns_opt []*pb.GNFColumn, relations_opt *pb.TargetRelations, asof string) *pb.CSVData { - _t2216 := columns_opt + _t2228 := columns_opt if columns_opt == nil { - _t2216 = []*pb.GNFColumn{} + _t2228 = []*pb.GNFColumn{} } - _t2217 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2216, Asof: asof, Relations: relations_opt} - return _t2217 + _t2229 := &pb.CSVData{Locator: locator, Config: config, Columns: _t2228, Asof: asof, Relations: relations_opt} + return _t2229 } func (p *Parser) construct_csv_config(config_dict [][]interface{}, storage_integration_opt [][]interface{}) *pb.CSVConfig { config := dictFromList(config_dict) -<<<<<<< HEAD - _t2122 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2122 - _t2123 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2123 - _t2124 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2124 - _t2125 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2125 - _t2126 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2126 - _t2127 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2127 - _t2128 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2128 - _t2129 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2129 - _t2130 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2130 - _t2131 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2131 - _t2132 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") - compression := _t2132 - _t2133 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2133 - _t2134 := p.construct_csv_storage_integration(storage_integration_opt) - storage_integration := _t2134 - _t2135 := &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 _t2135 -} - -func (p *Parser) construct_csv_storage_integration(storage_integration_opt [][]interface{}) *pb.StorageIntegration { - var _t2136 interface{} - if storage_integration_opt == nil { - return nil - } - _ = _t2136 - config := dictFromList(storage_integration_opt) - _t2137 := p._extract_value_string(dictGetValue(config, "provider"), "") - _t2138 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") - _t2139 := p._extract_value_string(dictGetValue(config, "s3_region"), "") - _t2140 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") - _t2141 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") - _t2142 := &pb.StorageIntegration{Provider: _t2137, AzureSasToken: _t2138, S3Region: _t2139, S3AccessKeyId: _t2140, S3SecretAccessKey: _t2141} - return _t2142 -======= - _t2218 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) - header_row := _t2218 - _t2219 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) - skip := _t2219 - _t2220 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") - new_line := _t2220 - _t2221 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") - delimiter := _t2221 - _t2222 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") - quotechar := _t2222 - _t2223 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") - escapechar := _t2223 - _t2224 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") - comment := _t2224 - _t2225 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) - missing_strings := _t2225 - _t2226 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") - decimal_separator := _t2226 - _t2227 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") - encoding := _t2227 - _t2228 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") - compression := _t2228 - _t2229 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) - partition_size_mb := _t2229 - _t2230 := p.construct_csv_storage_integration(storage_integration_opt) - storage_integration := _t2230 - _t2231 := &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 _t2231 + _t2230 := p._extract_value_int32(dictGetValue(config, "csv_header_row"), 1) + header_row := _t2230 + _t2231 := p._extract_value_int64(dictGetValue(config, "csv_skip"), 0) + skip := _t2231 + _t2232 := p._extract_value_string(dictGetValue(config, "csv_new_line"), "") + new_line := _t2232 + _t2233 := p._extract_value_string(dictGetValue(config, "csv_delimiter"), ",") + delimiter := _t2233 + _t2234 := p._extract_value_string(dictGetValue(config, "csv_quotechar"), "\"") + quotechar := _t2234 + _t2235 := p._extract_value_string(dictGetValue(config, "csv_escapechar"), "\"") + escapechar := _t2235 + _t2236 := p._extract_value_string(dictGetValue(config, "csv_comment"), "") + comment := _t2236 + _t2237 := p._extract_value_string_list(dictGetValue(config, "csv_missing_strings"), []string{}) + missing_strings := _t2237 + _t2238 := p._extract_value_string(dictGetValue(config, "csv_decimal_separator"), ".") + decimal_separator := _t2238 + _t2239 := p._extract_value_string(dictGetValue(config, "csv_encoding"), "utf-8") + encoding := _t2239 + _t2240 := p._extract_value_string(dictGetValue(config, "csv_compression"), "") + compression := _t2240 + _t2241 := p._extract_value_int64(dictGetValue(config, "csv_partition_size_mb"), 0) + partition_size_mb := _t2241 + _t2242 := p.construct_csv_storage_integration(storage_integration_opt) + storage_integration := _t2242 + _t2243 := &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 _t2243 } func (p *Parser) construct_csv_storage_integration(storage_integration_opt [][]interface{}) *pb.StorageIntegration { - var _t2232 interface{} + var _t2244 interface{} if storage_integration_opt == nil { return nil } - _ = _t2232 + _ = _t2244 config := dictFromList(storage_integration_opt) - _t2233 := p._extract_value_string(dictGetValue(config, "provider"), "") - _t2234 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") - _t2235 := p._extract_value_string(dictGetValue(config, "s3_region"), "") - _t2236 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") - _t2237 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") - _t2238 := &pb.StorageIntegration{Provider: _t2233, AzureSasToken: _t2234, S3Region: _t2235, S3AccessKeyId: _t2236, S3SecretAccessKey: _t2237} - return _t2238 ->>>>>>> origin/main + _t2245 := p._extract_value_string(dictGetValue(config, "provider"), "") + _t2246 := p._extract_value_string(dictGetValue(config, "azure_sas_token"), "") + _t2247 := p._extract_value_string(dictGetValue(config, "s3_region"), "") + _t2248 := p._extract_value_string(dictGetValue(config, "s3_access_key_id"), "") + _t2249 := p._extract_value_string(dictGetValue(config, "s3_secret_access_key"), "") + _t2250 := &pb.StorageIntegration{Provider: _t2245, AzureSasToken: _t2246, S3Region: _t2247, S3AccessKeyId: _t2248, S3SecretAccessKey: _t2249} + return _t2250 } func (p *Parser) construct_betree_info(key_types []*pb.Type, value_types []*pb.Type, config_dict [][]interface{}) *pb.BeTreeInfo { config := dictFromList(config_dict) -<<<<<<< HEAD - _t2143 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2143 - _t2144 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2144 - _t2145 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2145 - _t2146 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2146 - _t2147 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2147 - _t2148 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2148 - _t2149 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2149 - _t2150 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2150 - _t2151 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2151 - _t2152 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} - if root_pageid != nil { - _t2152.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} - } else { - _t2152.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} - } - relation_locator := _t2152 - _t2153 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2153 -} - -func (p *Parser) default_configure() *pb.Configure { - _t2154 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2154 - _t2155 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2155 -======= - _t2239 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) - epsilon := _t2239 - _t2240 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) - max_pivots := _t2240 - _t2241 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) - max_deltas := _t2241 - _t2242 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) - max_leaf := _t2242 - _t2243 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} - storage_config := _t2243 - _t2244 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) - root_pageid := _t2244 - _t2245 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) - inline_data := _t2245 - _t2246 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) - element_count := _t2246 - _t2247 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) - tree_height := _t2247 - _t2248 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} + _t2251 := p._try_extract_value_float64(dictGetValue(config, "betree_config_epsilon")) + epsilon := _t2251 + _t2252 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_pivots")) + max_pivots := _t2252 + _t2253 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_deltas")) + max_deltas := _t2253 + _t2254 := p._try_extract_value_int64(dictGetValue(config, "betree_config_max_leaf")) + max_leaf := _t2254 + _t2255 := &pb.BeTreeConfig{Epsilon: deref(epsilon, 0.0), MaxPivots: deref(max_pivots, 0), MaxDeltas: deref(max_deltas, 0), MaxLeaf: deref(max_leaf, 0)} + storage_config := _t2255 + _t2256 := p._try_extract_value_uint128(dictGetValue(config, "betree_locator_root_pageid")) + root_pageid := _t2256 + _t2257 := p._try_extract_value_bytes(dictGetValue(config, "betree_locator_inline_data")) + inline_data := _t2257 + _t2258 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_element_count")) + element_count := _t2258 + _t2259 := p._try_extract_value_int64(dictGetValue(config, "betree_locator_tree_height")) + tree_height := _t2259 + _t2260 := &pb.BeTreeLocator{ElementCount: deref(element_count, 0), TreeHeight: deref(tree_height, 0)} if root_pageid != nil { - _t2248.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} + _t2260.Location = &pb.BeTreeLocator_RootPageid{RootPageid: root_pageid} } else { - _t2248.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} + _t2260.Location = &pb.BeTreeLocator_InlineData{InlineData: inline_data} } - relation_locator := _t2248 - _t2249 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} - return _t2249 + relation_locator := _t2260 + _t2261 := &pb.BeTreeInfo{KeyTypes: key_types, ValueTypes: value_types, StorageConfig: storage_config, RelationLocator: relation_locator} + return _t2261 } func (p *Parser) default_configure() *pb.Configure { - _t2250 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} - ivm_config := _t2250 - _t2251 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} - return _t2251 ->>>>>>> origin/main + _t2262 := &pb.IVMConfig{Level: pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF} + ivm_config := _t2262 + _t2263 := &pb.Configure{SemanticsVersion: 0, IvmConfig: ivm_config} + return _t2263 } func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure { @@ -1032,8684 +876,4485 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } -<<<<<<< HEAD - _t2156 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2156 - _t2157 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2157 - _t2158 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t2158 -======= - _t2252 := &pb.IVMConfig{Level: maintenance_level} - ivm_config := _t2252 - _t2253 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) - semantics_version := _t2253 - _t2254 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} - return _t2254 ->>>>>>> origin/main + _t2264 := &pb.IVMConfig{Level: maintenance_level} + ivm_config := _t2264 + _t2265 := p._extract_value_int64(dictGetValue(config, "semantics_version"), 0) + semantics_version := _t2265 + _t2266 := &pb.Configure{SemanticsVersion: semantics_version, IvmConfig: ivm_config} + return _t2266 } func (p *Parser) construct_export_csv_config(path string, columns []*pb.ExportCSVColumn, config_dict [][]interface{}) *pb.ExportCSVConfig { config := dictFromList(config_dict) -<<<<<<< HEAD - _t2159 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2159 - _t2160 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2160 - _t2161 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2161 - _t2162 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2162 - _t2163 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2163 - _t2164 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2164 - _t2165 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2165 - _t2166 := &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 _t2166 + _t2267 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) + partition_size := _t2267 + _t2268 := p._extract_value_string(dictGetValue(config, "compression"), "") + compression := _t2268 + _t2269 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) + syntax_header_row := _t2269 + _t2270 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") + syntax_missing_string := _t2270 + _t2271 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") + syntax_delim := _t2271 + _t2272 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") + syntax_quotechar := _t2272 + _t2273 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") + syntax_escapechar := _t2273 + _t2274 := &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 _t2274 } func (p *Parser) construct_export_csv_config_with_location(location []interface{}, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2167 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} - return _t2167 -======= - _t2255 := p._extract_value_int64(dictGetValue(config, "partition_size"), 0) - partition_size := _t2255 - _t2256 := p._extract_value_string(dictGetValue(config, "compression"), "") - compression := _t2256 - _t2257 := p._extract_value_boolean(dictGetValue(config, "syntax_header_row"), true) - syntax_header_row := _t2257 - _t2258 := p._extract_value_string(dictGetValue(config, "syntax_missing_string"), "") - syntax_missing_string := _t2258 - _t2259 := p._extract_value_string(dictGetValue(config, "syntax_delim"), ",") - syntax_delim := _t2259 - _t2260 := p._extract_value_string(dictGetValue(config, "syntax_quotechar"), "\"") - syntax_quotechar := _t2260 - _t2261 := p._extract_value_string(dictGetValue(config, "syntax_escapechar"), "\\") - syntax_escapechar := _t2261 - _t2262 := &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 _t2262 -} - -func (p *Parser) construct_export_csv_config_with_source(path string, csv_source *pb.ExportCSVSource, csv_config *pb.CSVConfig) *pb.ExportCSVConfig { - _t2263 := &pb.ExportCSVConfig{Path: path, CsvSource: csv_source, CsvConfig: csv_config} - return _t2263 ->>>>>>> origin/main + _t2275 := &pb.ExportCSVConfig{Path: location[0].(string), TransactionOutputName: location[1].(string), CsvSource: csv_source, CsvConfig: csv_config} + return _t2275 } 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) -<<<<<<< HEAD - _t2168 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2168 -} - -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 { - _t2169 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2169 -} - -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 { - _t2170 := config_dict - if config_dict == nil { - _t2170 = [][]interface{}{} - } - cfg := dictFromList(_t2170) - _t2171 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2171 - _t2172 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2172 - _t2173 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2173 - table_props := stringMapFromPairs(table_property_pairs) - _t2174 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2174 -======= - _t2264 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} - return _t2264 + _t2276 := &pb.IcebergCatalogConfig{CatalogUri: catalog_uri, Scope: ptr(deref(scope_opt, "")), Properties: props, AuthProperties: auth_props} + return _t2276 } 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 { - _t2265 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} - return _t2265 + _t2277 := &pb.IcebergData{Locator: locator, Config: config, Columns: columns, FromSnapshot: ptr(deref(from_snapshot_opt, "")), ToSnapshot: ptr(deref(to_snapshot_opt, "")), ReturnsDelta: returns_delta} + return _t2277 } 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 { - _t2266 := config_dict + _t2278 := config_dict if config_dict == nil { - _t2266 = [][]interface{}{} - } - cfg := dictFromList(_t2266) - _t2267 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") - prefix := _t2267 - _t2268 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) - target_file_size_bytes := _t2268 - _t2269 := p._extract_value_string(dictGetValue(cfg, "compression"), "") - compression := _t2269 + _t2278 = [][]interface{}{} + } + cfg := dictFromList(_t2278) + _t2279 := p._extract_value_string(dictGetValue(cfg, "prefix"), "") + prefix := _t2279 + _t2280 := p._extract_value_int64(dictGetValue(cfg, "target_file_size_bytes"), 0) + target_file_size_bytes := _t2280 + _t2281 := p._extract_value_string(dictGetValue(cfg, "compression"), "") + compression := _t2281 table_props := stringMapFromPairs(table_property_pairs) - _t2270 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} - return _t2270 ->>>>>>> origin/main + _t2282 := &pb.ExportIcebergConfig{Locator: locator, Config: config, TableDef: table_def, Prefix: ptr(prefix), TargetFileSizeBytes: ptr(target_file_size_bytes), Compression: compression, TableProperties: table_props} + return _t2282 } // --- Parse functions --- func (p *Parser) parse_transaction() *pb.Transaction { -<<<<<<< HEAD - span_start676 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("transaction") - var _t1340 *pb.Configure - if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t1341 := p.parse_configure() - _t1340 = _t1341 - } - configure670 := _t1340 - var _t1342 *pb.Sync - if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t1343 := p.parse_sync() - _t1342 = _t1343 - } - sync671 := _t1342 - xs672 := []*pb.Epoch{} - cond673 := p.matchLookaheadLiteral("(", 0) - for cond673 { - _t1344 := p.parse_epoch() - item674 := _t1344 - xs672 = append(xs672, item674) - cond673 = p.matchLookaheadLiteral("(", 0) - } - epochs675 := xs672 - p.consumeLiteral(")") - _t1345 := p.default_configure() - _t1346 := configure670 - if configure670 == nil { - _t1346 = _t1345 - } - _t1347 := &pb.Transaction{Epochs: epochs675, Configure: _t1346, Sync: sync671} - result677 := _t1347 - p.recordSpan(int(span_start676), "Transaction") - return result677 -} - -func (p *Parser) parse_configure() *pb.Configure { - span_start679 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("configure") - _t1348 := p.parse_config_dict() - config_dict678 := _t1348 - p.consumeLiteral(")") - _t1349 := p.construct_configure(config_dict678) - result680 := _t1349 - p.recordSpan(int(span_start679), "Configure") - return result680 -======= - span_start710 := int64(p.spanStart()) + span_start713 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("transaction") - var _t1408 *pb.Configure + var _t1414 *pb.Configure if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("configure", 1)) { - _t1409 := p.parse_configure() - _t1408 = _t1409 + _t1415 := p.parse_configure() + _t1414 = _t1415 } - configure704 := _t1408 - var _t1410 *pb.Sync + configure707 := _t1414 + var _t1416 *pb.Sync if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("sync", 1)) { - _t1411 := p.parse_sync() - _t1410 = _t1411 - } - sync705 := _t1410 - xs706 := []*pb.Epoch{} - cond707 := p.matchLookaheadLiteral("(", 0) - for cond707 { - _t1412 := p.parse_epoch() - item708 := _t1412 - xs706 = append(xs706, item708) - cond707 = p.matchLookaheadLiteral("(", 0) - } - epochs709 := xs706 - p.consumeLiteral(")") - _t1413 := p.default_configure() - _t1414 := configure704 - if configure704 == nil { - _t1414 = _t1413 - } - _t1415 := &pb.Transaction{Epochs: epochs709, Configure: _t1414, Sync: sync705} - result711 := _t1415 - p.recordSpan(int(span_start710), "Transaction") - return result711 + _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 + p.consumeLiteral(")") + _t1419 := p.default_configure() + _t1420 := configure707 + if configure707 == nil { + _t1420 = _t1419 + } + _t1421 := &pb.Transaction{Epochs: epochs712, Configure: _t1420, Sync: sync708} + result714 := _t1421 + p.recordSpan(int(span_start713), "Transaction") + return result714 } func (p *Parser) parse_configure() *pb.Configure { - span_start713 := int64(p.spanStart()) + span_start716 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("configure") - _t1416 := p.parse_config_dict() - config_dict712 := _t1416 + _t1422 := p.parse_config_dict() + config_dict715 := _t1422 p.consumeLiteral(")") - _t1417 := p.construct_configure(config_dict712) - result714 := _t1417 - p.recordSpan(int(span_start713), "Configure") - return result714 ->>>>>>> origin/main + _t1423 := p.construct_configure(config_dict715) + result717 := _t1423 + p.recordSpan(int(span_start716), "Configure") + return result717 } func (p *Parser) parse_config_dict() [][]interface{} { p.consumeLiteral("{") -<<<<<<< HEAD - xs681 := [][]interface{}{} - cond682 := p.matchLookaheadLiteral(":", 0) - for cond682 { - _t1350 := p.parse_config_key_value() - item683 := _t1350 - xs681 = append(xs681, item683) - cond682 = p.matchLookaheadLiteral(":", 0) - } - config_key_values684 := xs681 + 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 p.consumeLiteral("}") - return config_key_values684 -======= - xs715 := [][]interface{}{} - cond716 := p.matchLookaheadLiteral(":", 0) - for cond716 { - _t1418 := p.parse_config_key_value() - item717 := _t1418 - xs715 = append(xs715, item717) - cond716 = p.matchLookaheadLiteral(":", 0) - } - config_key_values718 := xs715 - p.consumeLiteral("}") - return config_key_values718 ->>>>>>> origin/main + return config_key_values721 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") -<<<<<<< HEAD - symbol685 := p.consumeTerminal("SYMBOL").Value.str - _t1351 := p.parse_raw_value() - raw_value686 := _t1351 - return []interface{}{symbol685, raw_value686} -} - -func (p *Parser) parse_raw_value() *pb.Value { - span_start700 := int64(p.spanStart()) - var _t1352 int64 - if p.matchLookaheadLiteral("true", 0) { - _t1352 = 12 - } else { - var _t1353 int64 - if p.matchLookaheadLiteral("missing", 0) { - _t1353 = 11 - } else { - var _t1354 int64 - if p.matchLookaheadLiteral("false", 0) { - _t1354 = 12 - } else { - var _t1355 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1356 int64 - if p.matchLookaheadLiteral("datetime", 1) { - _t1356 = 1 - } else { - var _t1357 int64 - if p.matchLookaheadLiteral("date", 1) { - _t1357 = 0 - } else { - _t1357 = -1 - } - _t1356 = _t1357 - } - _t1355 = _t1356 - } else { - var _t1358 int64 - if p.matchLookaheadTerminal("UINT32", 0) { - _t1358 = 7 - } else { - var _t1359 int64 - if p.matchLookaheadTerminal("UINT128", 0) { - _t1359 = 8 - } else { - var _t1360 int64 - if p.matchLookaheadTerminal("STRING", 0) { - _t1360 = 2 - } else { - var _t1361 int64 - if p.matchLookaheadTerminal("INT32", 0) { - _t1361 = 3 - } else { - var _t1362 int64 - if p.matchLookaheadTerminal("INT128", 0) { - _t1362 = 9 - } else { - var _t1363 int64 - if p.matchLookaheadTerminal("INT", 0) { - _t1363 = 4 - } else { - var _t1364 int64 - if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1364 = 5 - } else { - var _t1365 int64 - if p.matchLookaheadTerminal("FLOAT", 0) { - _t1365 = 6 - } else { - var _t1366 int64 - if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1366 = 10 - } else { - _t1366 = -1 - } - _t1365 = _t1366 - } - _t1364 = _t1365 - } - _t1363 = _t1364 - } - _t1362 = _t1363 - } - _t1361 = _t1362 - } - _t1360 = _t1361 - } - _t1359 = _t1360 - } - _t1358 = _t1359 - } - _t1355 = _t1358 - } - _t1354 = _t1355 - } - _t1353 = _t1354 - } - _t1352 = _t1353 - } - prediction687 := _t1352 - var _t1367 *pb.Value - if prediction687 == 12 { - _t1368 := p.parse_boolean_value() - boolean_value699 := _t1368 - _t1369 := &pb.Value{} - _t1369.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value699} - _t1367 = _t1369 - } else { - var _t1370 *pb.Value - if prediction687 == 11 { - p.consumeLiteral("missing") - _t1371 := &pb.MissingValue{} - _t1372 := &pb.Value{} - _t1372.Value = &pb.Value_MissingValue{MissingValue: _t1371} - _t1370 = _t1372 - } else { - var _t1373 *pb.Value - if prediction687 == 10 { - decimal698 := p.consumeTerminal("DECIMAL").Value.decimal - _t1374 := &pb.Value{} - _t1374.Value = &pb.Value_DecimalValue{DecimalValue: decimal698} - _t1373 = _t1374 - } else { - var _t1375 *pb.Value - if prediction687 == 9 { - int128697 := p.consumeTerminal("INT128").Value.int128 - _t1376 := &pb.Value{} - _t1376.Value = &pb.Value_Int128Value{Int128Value: int128697} - _t1375 = _t1376 - } else { - var _t1377 *pb.Value - if prediction687 == 8 { - uint128696 := p.consumeTerminal("UINT128").Value.uint128 - _t1378 := &pb.Value{} - _t1378.Value = &pb.Value_Uint128Value{Uint128Value: uint128696} - _t1377 = _t1378 - } else { - var _t1379 *pb.Value - if prediction687 == 7 { - uint32695 := p.consumeTerminal("UINT32").Value.u32 - _t1380 := &pb.Value{} - _t1380.Value = &pb.Value_Uint32Value{Uint32Value: uint32695} - _t1379 = _t1380 - } else { - var _t1381 *pb.Value - if prediction687 == 6 { - float694 := p.consumeTerminal("FLOAT").Value.f64 - _t1382 := &pb.Value{} - _t1382.Value = &pb.Value_FloatValue{FloatValue: float694} - _t1381 = _t1382 - } else { - var _t1383 *pb.Value - if prediction687 == 5 { - float32693 := p.consumeTerminal("FLOAT32").Value.f32 - _t1384 := &pb.Value{} - _t1384.Value = &pb.Value_Float32Value{Float32Value: float32693} - _t1383 = _t1384 - } else { - var _t1385 *pb.Value - if prediction687 == 4 { - int692 := p.consumeTerminal("INT").Value.i64 - _t1386 := &pb.Value{} - _t1386.Value = &pb.Value_IntValue{IntValue: int692} - _t1385 = _t1386 - } else { - var _t1387 *pb.Value - if prediction687 == 3 { - int32691 := p.consumeTerminal("INT32").Value.i32 - _t1388 := &pb.Value{} - _t1388.Value = &pb.Value_Int32Value{Int32Value: int32691} - _t1387 = _t1388 - } else { - var _t1389 *pb.Value - if prediction687 == 2 { - string690 := p.consumeTerminal("STRING").Value.str - _t1390 := &pb.Value{} - _t1390.Value = &pb.Value_StringValue{StringValue: string690} - _t1389 = _t1390 - } else { - var _t1391 *pb.Value - if prediction687 == 1 { - _t1392 := p.parse_raw_datetime() - raw_datetime689 := _t1392 - _t1393 := &pb.Value{} - _t1393.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime689} - _t1391 = _t1393 - } else { - var _t1394 *pb.Value - if prediction687 == 0 { - _t1395 := p.parse_raw_date() - raw_date688 := _t1395 - _t1396 := &pb.Value{} - _t1396.Value = &pb.Value_DateValue{DateValue: raw_date688} - _t1394 = _t1396 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in raw_value", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1391 = _t1394 - } - _t1389 = _t1391 - } - _t1387 = _t1389 - } - _t1385 = _t1387 - } - _t1383 = _t1385 - } - _t1381 = _t1383 - } - _t1379 = _t1381 - } - _t1377 = _t1379 - } - _t1375 = _t1377 - } - _t1373 = _t1375 - } - _t1370 = _t1373 - } - _t1367 = _t1370 - } - result701 := _t1367 - p.recordSpan(int(span_start700), "Value") - return result701 -} - -func (p *Parser) parse_raw_date() *pb.DateValue { - span_start705 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("date") - int702 := p.consumeTerminal("INT").Value.i64 - int_3703 := p.consumeTerminal("INT").Value.i64 - int_4704 := p.consumeTerminal("INT").Value.i64 - p.consumeLiteral(")") - _t1397 := &pb.DateValue{Year: int32(int702), Month: int32(int_3703), Day: int32(int_4704)} - result706 := _t1397 - p.recordSpan(int(span_start705), "DateValue") - return result706 -} - -func (p *Parser) parse_raw_datetime() *pb.DateTimeValue { - span_start714 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("datetime") - int707 := p.consumeTerminal("INT").Value.i64 - int_3708 := p.consumeTerminal("INT").Value.i64 - int_4709 := p.consumeTerminal("INT").Value.i64 - int_5710 := p.consumeTerminal("INT").Value.i64 - int_6711 := p.consumeTerminal("INT").Value.i64 - int_7712 := p.consumeTerminal("INT").Value.i64 - var _t1398 *int64 - if p.matchLookaheadTerminal("INT", 0) { - _t1398 = ptr(p.consumeTerminal("INT").Value.i64) - } - int_8713 := _t1398 - p.consumeLiteral(")") - _t1399 := &pb.DateTimeValue{Year: int32(int707), Month: int32(int_3708), Day: int32(int_4709), Hour: int32(int_5710), Minute: int32(int_6711), Second: int32(int_7712), Microsecond: int32(deref(int_8713, 0))} - result715 := _t1399 - p.recordSpan(int(span_start714), "DateTimeValue") - return result715 -} - -func (p *Parser) parse_boolean_value() bool { - var _t1400 int64 - if p.matchLookaheadLiteral("true", 0) { - _t1400 = 0 - } else { - var _t1401 int64 - if p.matchLookaheadLiteral("false", 0) { - _t1401 = 1 - } else { - _t1401 = -1 - } - _t1400 = _t1401 - } - prediction716 := _t1400 - var _t1402 bool - if prediction716 == 1 { - p.consumeLiteral("false") - _t1402 = false - } else { - var _t1403 bool - if prediction716 == 0 { - p.consumeLiteral("true") - _t1403 = true - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1402 = _t1403 - } - return _t1402 -} - -func (p *Parser) parse_sync() *pb.Sync { - span_start721 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("sync") - xs717 := []*pb.FragmentId{} - cond718 := p.matchLookaheadLiteral(":", 0) - for cond718 { - _t1404 := p.parse_fragment_id() - item719 := _t1404 - xs717 = append(xs717, item719) - cond718 = p.matchLookaheadLiteral(":", 0) - } - fragment_ids720 := xs717 - p.consumeLiteral(")") - _t1405 := &pb.Sync{Fragments: fragment_ids720} - result722 := _t1405 - p.recordSpan(int(span_start721), "Sync") - return result722 -======= - symbol719 := p.consumeTerminal("SYMBOL").Value.str - _t1419 := p.parse_raw_value() - raw_value720 := _t1419 - return []interface{}{symbol719, raw_value720} + symbol722 := p.consumeTerminal("SYMBOL").Value.str + _t1425 := p.parse_raw_value() + raw_value723 := _t1425 + return []interface{}{symbol722, raw_value723} } func (p *Parser) parse_raw_value() *pb.Value { - span_start734 := int64(p.spanStart()) - var _t1420 int64 + span_start737 := int64(p.spanStart()) + var _t1426 int64 if p.matchLookaheadLiteral("true", 0) { - _t1420 = 12 + _t1426 = 12 } else { - var _t1421 int64 + var _t1427 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1421 = 11 + _t1427 = 11 } else { - var _t1422 int64 + var _t1428 int64 if p.matchLookaheadLiteral("false", 0) { - _t1422 = 12 + _t1428 = 12 } else { - var _t1423 int64 + var _t1429 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1424 int64 + var _t1430 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1424 = 1 + _t1430 = 1 } else { - var _t1425 int64 + var _t1431 int64 if p.matchLookaheadLiteral("date", 1) { - _t1425 = 0 + _t1431 = 0 } else { - _t1425 = -1 + _t1431 = -1 } - _t1424 = _t1425 + _t1430 = _t1431 } - _t1423 = _t1424 + _t1429 = _t1430 } else { - var _t1426 int64 + var _t1432 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1426 = 7 + _t1432 = 7 } else { - var _t1427 int64 + var _t1433 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1427 = 8 + _t1433 = 8 } else { - var _t1428 int64 + var _t1434 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1428 = 2 + _t1434 = 2 } else { - var _t1429 int64 + var _t1435 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1429 = 3 + _t1435 = 3 } else { - var _t1430 int64 + var _t1436 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1430 = 9 + _t1436 = 9 } else { - var _t1431 int64 + var _t1437 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1431 = 4 + _t1437 = 4 } else { - var _t1432 int64 + var _t1438 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1432 = 5 + _t1438 = 5 } else { - var _t1433 int64 + var _t1439 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1433 = 6 + _t1439 = 6 } else { - var _t1434 int64 + var _t1440 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1434 = 10 + _t1440 = 10 } else { - _t1434 = -1 + _t1440 = -1 } - _t1433 = _t1434 + _t1439 = _t1440 } - _t1432 = _t1433 + _t1438 = _t1439 } - _t1431 = _t1432 + _t1437 = _t1438 } - _t1430 = _t1431 + _t1436 = _t1437 } - _t1429 = _t1430 + _t1435 = _t1436 } - _t1428 = _t1429 + _t1434 = _t1435 } - _t1427 = _t1428 + _t1433 = _t1434 } - _t1426 = _t1427 + _t1432 = _t1433 } - _t1423 = _t1426 + _t1429 = _t1432 } - _t1422 = _t1423 + _t1428 = _t1429 } - _t1421 = _t1422 + _t1427 = _t1428 } - _t1420 = _t1421 - } - prediction721 := _t1420 - var _t1435 *pb.Value - if prediction721 == 12 { - _t1436 := p.parse_boolean_value() - boolean_value733 := _t1436 - _t1437 := &pb.Value{} - _t1437.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value733} - _t1435 = _t1437 + _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 } else { - var _t1438 *pb.Value - if prediction721 == 11 { + var _t1444 *pb.Value + if prediction724 == 11 { p.consumeLiteral("missing") - _t1439 := &pb.MissingValue{} - _t1440 := &pb.Value{} - _t1440.Value = &pb.Value_MissingValue{MissingValue: _t1439} - _t1438 = _t1440 + _t1445 := &pb.MissingValue{} + _t1446 := &pb.Value{} + _t1446.Value = &pb.Value_MissingValue{MissingValue: _t1445} + _t1444 = _t1446 } else { - var _t1441 *pb.Value - if prediction721 == 10 { - decimal732 := p.consumeTerminal("DECIMAL").Value.decimal - _t1442 := &pb.Value{} - _t1442.Value = &pb.Value_DecimalValue{DecimalValue: decimal732} - _t1441 = _t1442 + 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 } else { - var _t1443 *pb.Value - if prediction721 == 9 { - int128731 := p.consumeTerminal("INT128").Value.int128 - _t1444 := &pb.Value{} - _t1444.Value = &pb.Value_Int128Value{Int128Value: int128731} - _t1443 = _t1444 + 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 } else { - var _t1445 *pb.Value - if prediction721 == 8 { - uint128730 := p.consumeTerminal("UINT128").Value.uint128 - _t1446 := &pb.Value{} - _t1446.Value = &pb.Value_Uint128Value{Uint128Value: uint128730} - _t1445 = _t1446 + 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 } else { - var _t1447 *pb.Value - if prediction721 == 7 { - uint32729 := p.consumeTerminal("UINT32").Value.u32 - _t1448 := &pb.Value{} - _t1448.Value = &pb.Value_Uint32Value{Uint32Value: uint32729} - _t1447 = _t1448 + 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 } else { - var _t1449 *pb.Value - if prediction721 == 6 { - float728 := p.consumeTerminal("FLOAT").Value.f64 - _t1450 := &pb.Value{} - _t1450.Value = &pb.Value_FloatValue{FloatValue: float728} - _t1449 = _t1450 + 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 } else { - var _t1451 *pb.Value - if prediction721 == 5 { - float32727 := p.consumeTerminal("FLOAT32").Value.f32 - _t1452 := &pb.Value{} - _t1452.Value = &pb.Value_Float32Value{Float32Value: float32727} - _t1451 = _t1452 + 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 } else { - var _t1453 *pb.Value - if prediction721 == 4 { - int726 := p.consumeTerminal("INT").Value.i64 - _t1454 := &pb.Value{} - _t1454.Value = &pb.Value_IntValue{IntValue: int726} - _t1453 = _t1454 + 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 } else { - var _t1455 *pb.Value - if prediction721 == 3 { - int32725 := p.consumeTerminal("INT32").Value.i32 - _t1456 := &pb.Value{} - _t1456.Value = &pb.Value_Int32Value{Int32Value: int32725} - _t1455 = _t1456 + 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 } else { - var _t1457 *pb.Value - if prediction721 == 2 { - string724 := p.consumeTerminal("STRING").Value.str - _t1458 := &pb.Value{} - _t1458.Value = &pb.Value_StringValue{StringValue: string724} - _t1457 = _t1458 + 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 } else { - var _t1459 *pb.Value - if prediction721 == 1 { - _t1460 := p.parse_raw_datetime() - raw_datetime723 := _t1460 - _t1461 := &pb.Value{} - _t1461.Value = &pb.Value_DatetimeValue{DatetimeValue: raw_datetime723} - _t1459 = _t1461 + 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 } else { - var _t1462 *pb.Value - if prediction721 == 0 { - _t1463 := p.parse_raw_date() - raw_date722 := _t1463 - _t1464 := &pb.Value{} - _t1464.Value = &pb.Value_DateValue{DateValue: raw_date722} - _t1462 = _t1464 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in raw_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1459 = _t1462 + _t1465 = _t1468 } - _t1457 = _t1459 + _t1463 = _t1465 } - _t1455 = _t1457 + _t1461 = _t1463 } - _t1453 = _t1455 + _t1459 = _t1461 } - _t1451 = _t1453 + _t1457 = _t1459 } - _t1449 = _t1451 + _t1455 = _t1457 } - _t1447 = _t1449 + _t1453 = _t1455 } - _t1445 = _t1447 + _t1451 = _t1453 } - _t1443 = _t1445 + _t1449 = _t1451 } - _t1441 = _t1443 + _t1447 = _t1449 } - _t1438 = _t1441 + _t1444 = _t1447 } - _t1435 = _t1438 + _t1441 = _t1444 } - result735 := _t1435 - p.recordSpan(int(span_start734), "Value") - return result735 + result738 := _t1441 + p.recordSpan(int(span_start737), "Value") + return result738 } func (p *Parser) parse_raw_date() *pb.DateValue { - span_start739 := int64(p.spanStart()) + span_start742 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("date") - int736 := p.consumeTerminal("INT").Value.i64 - int_3737 := p.consumeTerminal("INT").Value.i64 - int_4738 := p.consumeTerminal("INT").Value.i64 + int739 := p.consumeTerminal("INT").Value.i64 + int_3740 := p.consumeTerminal("INT").Value.i64 + int_4741 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1465 := &pb.DateValue{Year: int32(int736), Month: int32(int_3737), Day: int32(int_4738)} - result740 := _t1465 - p.recordSpan(int(span_start739), "DateValue") - return result740 + _t1471 := &pb.DateValue{Year: int32(int739), Month: int32(int_3740), Day: int32(int_4741)} + result743 := _t1471 + p.recordSpan(int(span_start742), "DateValue") + return result743 } func (p *Parser) parse_raw_datetime() *pb.DateTimeValue { - span_start748 := int64(p.spanStart()) + span_start751 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("datetime") - int741 := p.consumeTerminal("INT").Value.i64 - int_3742 := p.consumeTerminal("INT").Value.i64 - int_4743 := p.consumeTerminal("INT").Value.i64 - int_5744 := p.consumeTerminal("INT").Value.i64 - int_6745 := p.consumeTerminal("INT").Value.i64 - int_7746 := p.consumeTerminal("INT").Value.i64 - var _t1466 *int64 + 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 if p.matchLookaheadTerminal("INT", 0) { - _t1466 = ptr(p.consumeTerminal("INT").Value.i64) + _t1472 = ptr(p.consumeTerminal("INT").Value.i64) } - int_8747 := _t1466 + int_8750 := _t1472 p.consumeLiteral(")") - _t1467 := &pb.DateTimeValue{Year: int32(int741), Month: int32(int_3742), Day: int32(int_4743), Hour: int32(int_5744), Minute: int32(int_6745), Second: int32(int_7746), Microsecond: int32(deref(int_8747, 0))} - result749 := _t1467 - p.recordSpan(int(span_start748), "DateTimeValue") - return result749 + _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 } func (p *Parser) parse_boolean_value() bool { - var _t1468 int64 + var _t1474 int64 if p.matchLookaheadLiteral("true", 0) { - _t1468 = 0 + _t1474 = 0 } else { - var _t1469 int64 + var _t1475 int64 if p.matchLookaheadLiteral("false", 0) { - _t1469 = 1 + _t1475 = 1 } else { - _t1469 = -1 + _t1475 = -1 } - _t1468 = _t1469 + _t1474 = _t1475 } - prediction750 := _t1468 - var _t1470 bool - if prediction750 == 1 { + prediction753 := _t1474 + var _t1476 bool + if prediction753 == 1 { p.consumeLiteral("false") - _t1470 = false + _t1476 = false } else { - var _t1471 bool - if prediction750 == 0 { + var _t1477 bool + if prediction753 == 0 { p.consumeLiteral("true") - _t1471 = true + _t1477 = true } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in boolean_value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1470 = _t1471 + _t1476 = _t1477 } - return _t1470 + return _t1476 } func (p *Parser) parse_sync() *pb.Sync { - span_start755 := int64(p.spanStart()) + span_start758 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sync") - xs751 := []*pb.FragmentId{} - cond752 := p.matchLookaheadLiteral(":", 0) - for cond752 { - _t1472 := p.parse_fragment_id() - item753 := _t1472 - xs751 = append(xs751, item753) - cond752 = p.matchLookaheadLiteral(":", 0) - } - fragment_ids754 := xs751 - p.consumeLiteral(")") - _t1473 := &pb.Sync{Fragments: fragment_ids754} - result756 := _t1473 - p.recordSpan(int(span_start755), "Sync") - return result756 -} - -func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start758 := int64(p.spanStart()) - p.consumeLiteral(":") - symbol757 := p.consumeTerminal("SYMBOL").Value.str - result759 := &pb.FragmentId{Id: []byte(symbol757)} - p.recordSpan(int(span_start758), "FragmentId") + 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 + p.consumeLiteral(")") + _t1479 := &pb.Sync{Fragments: fragment_ids757} + result759 := _t1479 + p.recordSpan(int(span_start758), "Sync") return result759 ->>>>>>> origin/main } func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start724 := int64(p.spanStart()) + span_start761 := int64(p.spanStart()) p.consumeLiteral(":") - symbol723 := p.consumeTerminal("SYMBOL").Value.str - result725 := &pb.FragmentId{Id: []byte(symbol723)} - p.recordSpan(int(span_start724), "FragmentId") - return result725 + symbol760 := p.consumeTerminal("SYMBOL").Value.str + result762 := &pb.FragmentId{Id: []byte(symbol760)} + p.recordSpan(int(span_start761), "FragmentId") + return result762 } func (p *Parser) parse_epoch() *pb.Epoch { -<<<<<<< HEAD - span_start728 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("epoch") - var _t1406 []*pb.Write - if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t1407 := p.parse_epoch_writes() - _t1406 = _t1407 - } - epoch_writes726 := _t1406 - var _t1408 []*pb.Read - if p.matchLookaheadLiteral("(", 0) { - _t1409 := p.parse_epoch_reads() - _t1408 = _t1409 - } - epoch_reads727 := _t1408 - p.consumeLiteral(")") - _t1410 := epoch_writes726 - if epoch_writes726 == nil { - _t1410 = []*pb.Write{} - } - _t1411 := epoch_reads727 - if epoch_reads727 == nil { - _t1411 = []*pb.Read{} - } - _t1412 := &pb.Epoch{Writes: _t1410, Reads: _t1411} - result729 := _t1412 - p.recordSpan(int(span_start728), "Epoch") - return result729 -======= - span_start762 := int64(p.spanStart()) + span_start765 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("epoch") - var _t1474 []*pb.Write + var _t1480 []*pb.Write if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("writes", 1)) { - _t1475 := p.parse_epoch_writes() - _t1474 = _t1475 + _t1481 := p.parse_epoch_writes() + _t1480 = _t1481 } - epoch_writes760 := _t1474 - var _t1476 []*pb.Read + epoch_writes763 := _t1480 + var _t1482 []*pb.Read if p.matchLookaheadLiteral("(", 0) { - _t1477 := p.parse_epoch_reads() - _t1476 = _t1477 + _t1483 := p.parse_epoch_reads() + _t1482 = _t1483 } - epoch_reads761 := _t1476 + epoch_reads764 := _t1482 p.consumeLiteral(")") - _t1478 := epoch_writes760 - if epoch_writes760 == nil { - _t1478 = []*pb.Write{} + _t1484 := epoch_writes763 + if epoch_writes763 == nil { + _t1484 = []*pb.Write{} } - _t1479 := epoch_reads761 - if epoch_reads761 == nil { - _t1479 = []*pb.Read{} + _t1485 := epoch_reads764 + if epoch_reads764 == nil { + _t1485 = []*pb.Read{} } - _t1480 := &pb.Epoch{Writes: _t1478, Reads: _t1479} - result763 := _t1480 - p.recordSpan(int(span_start762), "Epoch") - return result763 ->>>>>>> origin/main + _t1486 := &pb.Epoch{Writes: _t1484, Reads: _t1485} + result766 := _t1486 + p.recordSpan(int(span_start765), "Epoch") + return result766 } func (p *Parser) parse_epoch_writes() []*pb.Write { p.consumeLiteral("(") p.consumeLiteral("writes") -<<<<<<< HEAD - xs730 := []*pb.Write{} - cond731 := p.matchLookaheadLiteral("(", 0) - for cond731 { - _t1413 := p.parse_write() - item732 := _t1413 - xs730 = append(xs730, item732) - cond731 = p.matchLookaheadLiteral("(", 0) - } - writes733 := xs730 + 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 p.consumeLiteral(")") - return writes733 + return writes770 } func (p *Parser) parse_write() *pb.Write { - span_start739 := int64(p.spanStart()) - var _t1414 int64 + span_start776 := int64(p.spanStart()) + var _t1488 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1415 int64 + var _t1489 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t1415 = 1 + _t1489 = 1 } else { - var _t1416 int64 + var _t1490 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t1416 = 3 + _t1490 = 3 } else { - var _t1417 int64 + var _t1491 int64 if p.matchLookaheadLiteral("define", 1) { - _t1417 = 0 + _t1491 = 0 } else { - var _t1418 int64 + var _t1492 int64 if p.matchLookaheadLiteral("context", 1) { - _t1418 = 2 + _t1492 = 2 } else { - _t1418 = -1 + _t1492 = -1 } - _t1417 = _t1418 + _t1491 = _t1492 } - _t1416 = _t1417 + _t1490 = _t1491 } - _t1415 = _t1416 + _t1489 = _t1490 } - _t1414 = _t1415 + _t1488 = _t1489 } else { - _t1414 = -1 - } - prediction734 := _t1414 - var _t1419 *pb.Write - if prediction734 == 3 { - _t1420 := p.parse_snapshot() - snapshot738 := _t1420 - _t1421 := &pb.Write{} - _t1421.WriteType = &pb.Write_Snapshot{Snapshot: snapshot738} - _t1419 = _t1421 + _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 } else { - var _t1422 *pb.Write - if prediction734 == 2 { - _t1423 := p.parse_context() - context737 := _t1423 - _t1424 := &pb.Write{} - _t1424.WriteType = &pb.Write_Context{Context: context737} - _t1422 = _t1424 + 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 } else { - var _t1425 *pb.Write - if prediction734 == 1 { - _t1426 := p.parse_undefine() - undefine736 := _t1426 - _t1427 := &pb.Write{} - _t1427.WriteType = &pb.Write_Undefine{Undefine: undefine736} - _t1425 = _t1427 + 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 } else { - var _t1428 *pb.Write - if prediction734 == 0 { - _t1429 := p.parse_define() - define735 := _t1429 - _t1430 := &pb.Write{} - _t1430.WriteType = &pb.Write_Define{Define: define735} - _t1428 = _t1430 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1425 = _t1428 + _t1499 = _t1502 } - _t1422 = _t1425 + _t1496 = _t1499 } - _t1419 = _t1422 + _t1493 = _t1496 } - result740 := _t1419 - p.recordSpan(int(span_start739), "Write") - return result740 + result777 := _t1493 + p.recordSpan(int(span_start776), "Write") + return result777 } func (p *Parser) parse_define() *pb.Define { - span_start742 := int64(p.spanStart()) + span_start779 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("define") - _t1431 := p.parse_fragment() - fragment741 := _t1431 + _t1505 := p.parse_fragment() + fragment778 := _t1505 p.consumeLiteral(")") - _t1432 := &pb.Define{Fragment: fragment741} - result743 := _t1432 - p.recordSpan(int(span_start742), "Define") - return result743 + _t1506 := &pb.Define{Fragment: fragment778} + result780 := _t1506 + p.recordSpan(int(span_start779), "Define") + return result780 } func (p *Parser) parse_fragment() *pb.Fragment { - span_start749 := int64(p.spanStart()) + span_start786 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("fragment") - _t1433 := p.parse_new_fragment_id() - new_fragment_id744 := _t1433 - xs745 := []*pb.Declaration{} - cond746 := p.matchLookaheadLiteral("(", 0) - for cond746 { - _t1434 := p.parse_declaration() - item747 := _t1434 - xs745 = append(xs745, item747) - cond746 = p.matchLookaheadLiteral("(", 0) - } - declarations748 := xs745 - p.consumeLiteral(")") - result750 := p.constructFragment(new_fragment_id744, declarations748) - p.recordSpan(int(span_start749), "Fragment") - return result750 -======= - xs764 := []*pb.Write{} - cond765 := p.matchLookaheadLiteral("(", 0) - for cond765 { - _t1481 := p.parse_write() - item766 := _t1481 - xs764 = append(xs764, item766) - cond765 = p.matchLookaheadLiteral("(", 0) - } - writes767 := xs764 - p.consumeLiteral(")") - return writes767 + _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 + p.consumeLiteral(")") + result787 := p.constructFragment(new_fragment_id781, declarations785) + p.recordSpan(int(span_start786), "Fragment") + return result787 } -func (p *Parser) parse_write() *pb.Write { - span_start773 := int64(p.spanStart()) - var _t1482 int64 +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 +} + +func (p *Parser) parse_declaration() *pb.Declaration { + span_start796 := int64(p.spanStart()) + var _t1510 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1483 int64 - if p.matchLookaheadLiteral("undefine", 1) { - _t1483 = 1 + var _t1511 int64 + if p.matchLookaheadLiteral("iceberg_data", 1) { + _t1511 = 3 } else { - var _t1484 int64 - if p.matchLookaheadLiteral("snapshot", 1) { - _t1484 = 3 + var _t1512 int64 + if p.matchLookaheadLiteral("functional_dependency", 1) { + _t1512 = 2 } else { - var _t1485 int64 - if p.matchLookaheadLiteral("define", 1) { - _t1485 = 0 + var _t1513 int64 + if p.matchLookaheadLiteral("edb", 1) { + _t1513 = 3 } else { - var _t1486 int64 - if p.matchLookaheadLiteral("context", 1) { - _t1486 = 2 + var _t1514 int64 + if p.matchLookaheadLiteral("def", 1) { + _t1514 = 0 } else { - _t1486 = -1 + var _t1515 int64 + if p.matchLookaheadLiteral("csv_data", 1) { + _t1515 = 3 + } else { + var _t1516 int64 + if p.matchLookaheadLiteral("betree_relation", 1) { + _t1516 = 3 + } else { + var _t1517 int64 + if p.matchLookaheadLiteral("algorithm", 1) { + _t1517 = 1 + } else { + _t1517 = -1 + } + _t1516 = _t1517 + } + _t1515 = _t1516 + } + _t1514 = _t1515 } - _t1485 = _t1486 + _t1513 = _t1514 } - _t1484 = _t1485 + _t1512 = _t1513 } - _t1483 = _t1484 + _t1511 = _t1512 } - _t1482 = _t1483 + _t1510 = _t1511 } else { - _t1482 = -1 - } - prediction768 := _t1482 - var _t1487 *pb.Write - if prediction768 == 3 { - _t1488 := p.parse_snapshot() - snapshot772 := _t1488 - _t1489 := &pb.Write{} - _t1489.WriteType = &pb.Write_Snapshot{Snapshot: snapshot772} - _t1487 = _t1489 + _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 } else { - var _t1490 *pb.Write - if prediction768 == 2 { - _t1491 := p.parse_context() - context771 := _t1491 - _t1492 := &pb.Write{} - _t1492.WriteType = &pb.Write_Context{Context: context771} - _t1490 = _t1492 + 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 } else { - var _t1493 *pb.Write - if prediction768 == 1 { - _t1494 := p.parse_undefine() - undefine770 := _t1494 - _t1495 := &pb.Write{} - _t1495.WriteType = &pb.Write_Undefine{Undefine: undefine770} - _t1493 = _t1495 + 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 } else { - var _t1496 *pb.Write - if prediction768 == 0 { - _t1497 := p.parse_define() - define769 := _t1497 - _t1498 := &pb.Write{} - _t1498.WriteType = &pb.Write_Define{Define: define769} - _t1496 = _t1498 + 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 } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in write", p.lookahead(0).Type, p.lookahead(0).Value)}) + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1493 = _t1496 + _t1524 = _t1527 } - _t1490 = _t1493 + _t1521 = _t1524 } - _t1487 = _t1490 + _t1518 = _t1521 } - result774 := _t1487 - p.recordSpan(int(span_start773), "Write") - return result774 + result797 := _t1518 + p.recordSpan(int(span_start796), "Declaration") + return result797 } -func (p *Parser) parse_define() *pb.Define { - span_start776 := int64(p.spanStart()) +func (p *Parser) parse_def() *pb.Def { + span_start801 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("define") - _t1499 := p.parse_fragment() - fragment775 := _t1499 + p.consumeLiteral("def") + _t1530 := p.parse_relation_id() + relation_id798 := _t1530 + _t1531 := p.parse_abstraction() + abstraction799 := _t1531 + var _t1532 []*pb.Attribute + if p.matchLookaheadLiteral("(", 0) { + _t1533 := p.parse_attrs() + _t1532 = _t1533 + } + attrs800 := _t1532 p.consumeLiteral(")") - _t1500 := &pb.Define{Fragment: fragment775} - result777 := _t1500 - p.recordSpan(int(span_start776), "Define") - return result777 -} - -func (p *Parser) parse_fragment() *pb.Fragment { - span_start783 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("fragment") - _t1501 := p.parse_new_fragment_id() - new_fragment_id778 := _t1501 - xs779 := []*pb.Declaration{} - cond780 := p.matchLookaheadLiteral("(", 0) - for cond780 { - _t1502 := p.parse_declaration() - item781 := _t1502 - xs779 = append(xs779, item781) - cond780 = p.matchLookaheadLiteral("(", 0) - } - declarations782 := xs779 - p.consumeLiteral(")") - result784 := p.constructFragment(new_fragment_id778, declarations782) - p.recordSpan(int(span_start783), "Fragment") - return result784 -} - -func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - span_start786 := int64(p.spanStart()) - _t1503 := p.parse_fragment_id() - fragment_id785 := _t1503 - p.startFragment(fragment_id785) - result787 := fragment_id785 - p.recordSpan(int(span_start786), "FragmentId") - return result787 ->>>>>>> origin/main -} - -func (p *Parser) parse_new_fragment_id() *pb.FragmentId { - span_start752 := int64(p.spanStart()) - _t1435 := p.parse_fragment_id() - fragment_id751 := _t1435 - p.startFragment(fragment_id751) - result753 := fragment_id751 - p.recordSpan(int(span_start752), "FragmentId") - return result753 -} - -func (p *Parser) parse_declaration() *pb.Declaration { -<<<<<<< HEAD - span_start759 := int64(p.spanStart()) - var _t1436 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1437 int64 - if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1437 = 3 - } else { - var _t1438 int64 - if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1438 = 2 - } else { - var _t1439 int64 - if p.matchLookaheadLiteral("edb", 1) { - _t1439 = 3 - } else { - var _t1440 int64 - if p.matchLookaheadLiteral("def", 1) { - _t1440 = 0 - } else { - var _t1441 int64 - if p.matchLookaheadLiteral("csv_data", 1) { - _t1441 = 3 - } else { - var _t1442 int64 - if p.matchLookaheadLiteral("betree_relation", 1) { - _t1442 = 3 - } else { - var _t1443 int64 - if p.matchLookaheadLiteral("algorithm", 1) { - _t1443 = 1 - } else { - _t1443 = -1 - } - _t1442 = _t1443 - } - _t1441 = _t1442 - } - _t1440 = _t1441 - } - _t1439 = _t1440 - } - _t1438 = _t1439 - } - _t1437 = _t1438 - } - _t1436 = _t1437 - } else { - _t1436 = -1 - } - prediction754 := _t1436 - var _t1444 *pb.Declaration - if prediction754 == 3 { - _t1445 := p.parse_data() - data758 := _t1445 - _t1446 := &pb.Declaration{} - _t1446.DeclarationType = &pb.Declaration_Data{Data: data758} - _t1444 = _t1446 - } else { - var _t1447 *pb.Declaration - if prediction754 == 2 { - _t1448 := p.parse_constraint() - constraint757 := _t1448 - _t1449 := &pb.Declaration{} - _t1449.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint757} - _t1447 = _t1449 - } else { - var _t1450 *pb.Declaration - if prediction754 == 1 { - _t1451 := p.parse_algorithm() - algorithm756 := _t1451 - _t1452 := &pb.Declaration{} - _t1452.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm756} - _t1450 = _t1452 - } else { - var _t1453 *pb.Declaration - if prediction754 == 0 { - _t1454 := p.parse_def() - def755 := _t1454 - _t1455 := &pb.Declaration{} - _t1455.DeclarationType = &pb.Declaration_Def{Def: def755} - _t1453 = _t1455 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1450 = _t1453 - } - _t1447 = _t1450 - } - _t1444 = _t1447 - } - result760 := _t1444 - p.recordSpan(int(span_start759), "Declaration") - return result760 -} - -func (p *Parser) parse_def() *pb.Def { - span_start764 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("def") - _t1456 := p.parse_relation_id() - relation_id761 := _t1456 - _t1457 := p.parse_abstraction() - abstraction762 := _t1457 - var _t1458 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1459 := p.parse_attrs() - _t1458 = _t1459 - } - attrs763 := _t1458 - p.consumeLiteral(")") - _t1460 := attrs763 - if attrs763 == nil { - _t1460 = []*pb.Attribute{} - } - _t1461 := &pb.Def{Name: relation_id761, Body: abstraction762, Attrs: _t1460} - result765 := _t1461 - p.recordSpan(int(span_start764), "Def") - return result765 -} - -func (p *Parser) parse_relation_id() *pb.RelationId { - span_start769 := int64(p.spanStart()) - var _t1462 int64 - if p.matchLookaheadLiteral(":", 0) { - _t1462 = 0 - } else { - var _t1463 int64 - if p.matchLookaheadTerminal("UINT128", 0) { - _t1463 = 1 - } else { - _t1463 = -1 - } - _t1462 = _t1463 - } - prediction766 := _t1462 - var _t1464 *pb.RelationId - if prediction766 == 1 { - uint128768 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128768 - _t1464 = &pb.RelationId{IdLow: uint128768.Low, IdHigh: uint128768.High} - } else { - var _t1465 *pb.RelationId - if prediction766 == 0 { - p.consumeLiteral(":") - symbol767 := p.consumeTerminal("SYMBOL").Value.str - _t1465 = p.relationIdFromString(symbol767) - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1464 = _t1465 - } - result770 := _t1464 - p.recordSpan(int(span_start769), "RelationId") - return result770 -} - -func (p *Parser) parse_abstraction() *pb.Abstraction { - span_start773 := int64(p.spanStart()) - p.consumeLiteral("(") - _t1466 := p.parse_bindings() - bindings771 := _t1466 - _t1467 := p.parse_formula() - formula772 := _t1467 - p.consumeLiteral(")") - _t1468 := &pb.Abstraction{Vars: listConcat(bindings771[0].([]*pb.Binding), bindings771[1].([]*pb.Binding)), Value: formula772} - result774 := _t1468 - p.recordSpan(int(span_start773), "Abstraction") - return result774 -======= - span_start793 := int64(p.spanStart()) - var _t1504 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1505 int64 - if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1505 = 3 - } else { - var _t1506 int64 - if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1506 = 2 - } else { - var _t1507 int64 - if p.matchLookaheadLiteral("edb", 1) { - _t1507 = 3 - } else { - var _t1508 int64 - if p.matchLookaheadLiteral("def", 1) { - _t1508 = 0 - } else { - var _t1509 int64 - if p.matchLookaheadLiteral("csv_data", 1) { - _t1509 = 3 - } else { - var _t1510 int64 - if p.matchLookaheadLiteral("betree_relation", 1) { - _t1510 = 3 - } else { - var _t1511 int64 - if p.matchLookaheadLiteral("algorithm", 1) { - _t1511 = 1 - } else { - _t1511 = -1 - } - _t1510 = _t1511 - } - _t1509 = _t1510 - } - _t1508 = _t1509 - } - _t1507 = _t1508 - } - _t1506 = _t1507 - } - _t1505 = _t1506 - } - _t1504 = _t1505 - } else { - _t1504 = -1 - } - prediction788 := _t1504 - var _t1512 *pb.Declaration - if prediction788 == 3 { - _t1513 := p.parse_data() - data792 := _t1513 - _t1514 := &pb.Declaration{} - _t1514.DeclarationType = &pb.Declaration_Data{Data: data792} - _t1512 = _t1514 - } else { - var _t1515 *pb.Declaration - if prediction788 == 2 { - _t1516 := p.parse_constraint() - constraint791 := _t1516 - _t1517 := &pb.Declaration{} - _t1517.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint791} - _t1515 = _t1517 - } else { - var _t1518 *pb.Declaration - if prediction788 == 1 { - _t1519 := p.parse_algorithm() - algorithm790 := _t1519 - _t1520 := &pb.Declaration{} - _t1520.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm790} - _t1518 = _t1520 - } else { - var _t1521 *pb.Declaration - if prediction788 == 0 { - _t1522 := p.parse_def() - def789 := _t1522 - _t1523 := &pb.Declaration{} - _t1523.DeclarationType = &pb.Declaration_Def{Def: def789} - _t1521 = _t1523 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1518 = _t1521 - } - _t1515 = _t1518 - } - _t1512 = _t1515 - } - result794 := _t1512 - p.recordSpan(int(span_start793), "Declaration") - return result794 -} - -func (p *Parser) parse_def() *pb.Def { - span_start798 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("def") - _t1524 := p.parse_relation_id() - relation_id795 := _t1524 - _t1525 := p.parse_abstraction() - abstraction796 := _t1525 - var _t1526 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1527 := p.parse_attrs() - _t1526 = _t1527 - } - attrs797 := _t1526 - p.consumeLiteral(")") - _t1528 := attrs797 - if attrs797 == nil { - _t1528 = []*pb.Attribute{} - } - _t1529 := &pb.Def{Name: relation_id795, Body: abstraction796, Attrs: _t1528} - result799 := _t1529 - p.recordSpan(int(span_start798), "Def") - return result799 + _t1534 := attrs800 + if attrs800 == nil { + _t1534 = []*pb.Attribute{} + } + _t1535 := &pb.Def{Name: relation_id798, Body: abstraction799, Attrs: _t1534} + result802 := _t1535 + p.recordSpan(int(span_start801), "Def") + return result802 } func (p *Parser) parse_relation_id() *pb.RelationId { - span_start803 := int64(p.spanStart()) - var _t1530 int64 + span_start806 := int64(p.spanStart()) + var _t1536 int64 if p.matchLookaheadLiteral(":", 0) { - _t1530 = 0 + _t1536 = 0 } else { - var _t1531 int64 + var _t1537 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1531 = 1 + _t1537 = 1 } else { - _t1531 = -1 + _t1537 = -1 } - _t1530 = _t1531 - } - prediction800 := _t1530 - var _t1532 *pb.RelationId - if prediction800 == 1 { - uint128802 := p.consumeTerminal("UINT128").Value.uint128 - _ = uint128802 - _t1532 = &pb.RelationId{IdLow: uint128802.Low, IdHigh: uint128802.High} + _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} } else { - var _t1533 *pb.RelationId - if prediction800 == 0 { + var _t1539 *pb.RelationId + if prediction803 == 0 { p.consumeLiteral(":") - symbol801 := p.consumeTerminal("SYMBOL").Value.str - _t1533 = p.relationIdFromString(symbol801) + symbol804 := p.consumeTerminal("SYMBOL").Value.str + _t1539 = p.relationIdFromString(symbol804) } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_id", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1532 = _t1533 + _t1538 = _t1539 } - result804 := _t1532 - p.recordSpan(int(span_start803), "RelationId") - return result804 + result807 := _t1538 + p.recordSpan(int(span_start806), "RelationId") + return result807 } func (p *Parser) parse_abstraction() *pb.Abstraction { - span_start807 := int64(p.spanStart()) + span_start810 := int64(p.spanStart()) p.consumeLiteral("(") - _t1534 := p.parse_bindings() - bindings805 := _t1534 - _t1535 := p.parse_formula() - formula806 := _t1535 + _t1540 := p.parse_bindings() + bindings808 := _t1540 + _t1541 := p.parse_formula() + formula809 := _t1541 p.consumeLiteral(")") - _t1536 := &pb.Abstraction{Vars: listConcat(bindings805[0].([]*pb.Binding), bindings805[1].([]*pb.Binding)), Value: formula806} - result808 := _t1536 - p.recordSpan(int(span_start807), "Abstraction") - return result808 ->>>>>>> origin/main + _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 } func (p *Parser) parse_bindings() []interface{} { p.consumeLiteral("[") -<<<<<<< HEAD - xs775 := []*pb.Binding{} - cond776 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond776 { - _t1469 := p.parse_binding() - item777 := _t1469 - xs775 = append(xs775, item777) - cond776 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings778 := xs775 - var _t1470 []*pb.Binding + 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 if p.matchLookaheadLiteral("|", 0) { - _t1471 := p.parse_value_bindings() - _t1470 = _t1471 + _t1545 := p.parse_value_bindings() + _t1544 = _t1545 } - value_bindings779 := _t1470 + value_bindings816 := _t1544 p.consumeLiteral("]") - _t1472 := value_bindings779 - if value_bindings779 == nil { - _t1472 = []*pb.Binding{} + _t1546 := value_bindings816 + if value_bindings816 == nil { + _t1546 = []*pb.Binding{} } - return []interface{}{bindings778, _t1472} + return []interface{}{bindings815, _t1546} } func (p *Parser) parse_binding() *pb.Binding { - span_start782 := int64(p.spanStart()) - symbol780 := p.consumeTerminal("SYMBOL").Value.str + span_start819 := int64(p.spanStart()) + symbol817 := p.consumeTerminal("SYMBOL").Value.str p.consumeLiteral("::") - _t1473 := p.parse_type() - type781 := _t1473 - _t1474 := &pb.Var{Name: symbol780} - _t1475 := &pb.Binding{Var: _t1474, Type: type781} - result783 := _t1475 - p.recordSpan(int(span_start782), "Binding") - return result783 + _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 } func (p *Parser) parse_type() *pb.Type { - span_start799 := int64(p.spanStart()) - var _t1476 int64 + span_start836 := int64(p.spanStart()) + var _t1550 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1476 = 0 + _t1550 = 0 } else { - var _t1477 int64 + var _t1551 int64 if p.matchLookaheadLiteral("UINT32", 0) { - _t1477 = 13 + _t1551 = 13 } else { - var _t1478 int64 + var _t1552 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t1478 = 4 + _t1552 = 4 } else { - var _t1479 int64 + var _t1553 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t1479 = 1 + _t1553 = 1 } else { - var _t1480 int64 + var _t1554 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t1480 = 8 + _t1554 = 8 } else { - var _t1481 int64 + var _t1555 int64 if p.matchLookaheadLiteral("INT32", 0) { - _t1481 = 11 + _t1555 = 11 } else { - var _t1482 int64 + var _t1556 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t1482 = 5 + _t1556 = 5 } else { - var _t1483 int64 + var _t1557 int64 if p.matchLookaheadLiteral("INT", 0) { - _t1483 = 2 + _t1557 = 2 } else { - var _t1484 int64 + var _t1558 int64 if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1484 = 12 + _t1558 = 12 } else { - var _t1485 int64 + var _t1559 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t1485 = 3 + _t1559 = 3 } else { - var _t1486 int64 + var _t1560 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t1486 = 7 + _t1560 = 7 } else { - var _t1487 int64 + var _t1561 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t1487 = 6 + _t1561 = 6 } else { - var _t1488 int64 + var _t1562 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1488 = 10 + _t1562 = 10 } else { - var _t1489 int64 + var _t1563 int64 if p.matchLookaheadLiteral("(", 0) { - _t1489 = 9 + _t1563 = 9 } else { - _t1489 = -1 + _t1563 = -1 } - _t1488 = _t1489 + _t1562 = _t1563 } - _t1487 = _t1488 + _t1561 = _t1562 } - _t1486 = _t1487 + _t1560 = _t1561 } - _t1485 = _t1486 + _t1559 = _t1560 } - _t1484 = _t1485 + _t1558 = _t1559 } - _t1483 = _t1484 + _t1557 = _t1558 } - _t1482 = _t1483 + _t1556 = _t1557 } - _t1481 = _t1482 + _t1555 = _t1556 } - _t1480 = _t1481 + _t1554 = _t1555 } - _t1479 = _t1480 + _t1553 = _t1554 } - _t1478 = _t1479 + _t1552 = _t1553 } - _t1477 = _t1478 + _t1551 = _t1552 } - _t1476 = _t1477 - } - prediction784 := _t1476 - var _t1490 *pb.Type - if prediction784 == 13 { - _t1491 := p.parse_uint32_type() - uint32_type798 := _t1491 - _t1492 := &pb.Type{} - _t1492.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type798} - _t1490 = _t1492 + _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 } else { - var _t1493 *pb.Type - if prediction784 == 12 { - _t1494 := p.parse_float32_type() - float32_type797 := _t1494 - _t1495 := &pb.Type{} - _t1495.Type = &pb.Type_Float32Type{Float32Type: float32_type797} - _t1493 = _t1495 + 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 } else { - var _t1496 *pb.Type - if prediction784 == 11 { - _t1497 := p.parse_int32_type() - int32_type796 := _t1497 - _t1498 := &pb.Type{} - _t1498.Type = &pb.Type_Int32Type{Int32Type: int32_type796} - _t1496 = _t1498 + 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 } else { - var _t1499 *pb.Type - if prediction784 == 10 { - _t1500 := p.parse_boolean_type() - boolean_type795 := _t1500 - _t1501 := &pb.Type{} - _t1501.Type = &pb.Type_BooleanType{BooleanType: boolean_type795} - _t1499 = _t1501 + 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 } else { - var _t1502 *pb.Type - if prediction784 == 9 { - _t1503 := p.parse_decimal_type() - decimal_type794 := _t1503 - _t1504 := &pb.Type{} - _t1504.Type = &pb.Type_DecimalType{DecimalType: decimal_type794} - _t1502 = _t1504 + 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 } else { - var _t1505 *pb.Type - if prediction784 == 8 { - _t1506 := p.parse_missing_type() - missing_type793 := _t1506 - _t1507 := &pb.Type{} - _t1507.Type = &pb.Type_MissingType{MissingType: missing_type793} - _t1505 = _t1507 + 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 } else { - var _t1508 *pb.Type - if prediction784 == 7 { - _t1509 := p.parse_datetime_type() - datetime_type792 := _t1509 - _t1510 := &pb.Type{} - _t1510.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type792} - _t1508 = _t1510 + 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 } else { - var _t1511 *pb.Type - if prediction784 == 6 { - _t1512 := p.parse_date_type() - date_type791 := _t1512 - _t1513 := &pb.Type{} - _t1513.Type = &pb.Type_DateType{DateType: date_type791} - _t1511 = _t1513 + 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 } else { - var _t1514 *pb.Type - if prediction784 == 5 { - _t1515 := p.parse_int128_type() - int128_type790 := _t1515 - _t1516 := &pb.Type{} - _t1516.Type = &pb.Type_Int128Type{Int128Type: int128_type790} - _t1514 = _t1516 + 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 } else { - var _t1517 *pb.Type - if prediction784 == 4 { - _t1518 := p.parse_uint128_type() - uint128_type789 := _t1518 - _t1519 := &pb.Type{} - _t1519.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type789} - _t1517 = _t1519 + 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 } else { - var _t1520 *pb.Type - if prediction784 == 3 { - _t1521 := p.parse_float_type() - float_type788 := _t1521 - _t1522 := &pb.Type{} - _t1522.Type = &pb.Type_FloatType{FloatType: float_type788} - _t1520 = _t1522 + 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 } else { - var _t1523 *pb.Type - if prediction784 == 2 { - _t1524 := p.parse_int_type() - int_type787 := _t1524 - _t1525 := &pb.Type{} - _t1525.Type = &pb.Type_IntType{IntType: int_type787} - _t1523 = _t1525 + 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 } else { - var _t1526 *pb.Type - if prediction784 == 1 { - _t1527 := p.parse_string_type() - string_type786 := _t1527 - _t1528 := &pb.Type{} - _t1528.Type = &pb.Type_StringType{StringType: string_type786} - _t1526 = _t1528 + 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 } else { - var _t1529 *pb.Type - if prediction784 == 0 { - _t1530 := p.parse_unspecified_type() - unspecified_type785 := _t1530 - _t1531 := &pb.Type{} - _t1531.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type785} - _t1529 = _t1531 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1526 = _t1529 + _t1600 = _t1603 } - _t1523 = _t1526 + _t1597 = _t1600 } - _t1520 = _t1523 + _t1594 = _t1597 } - _t1517 = _t1520 + _t1591 = _t1594 } - _t1514 = _t1517 + _t1588 = _t1591 } - _t1511 = _t1514 + _t1585 = _t1588 } - _t1508 = _t1511 + _t1582 = _t1585 } - _t1505 = _t1508 + _t1579 = _t1582 } - _t1502 = _t1505 + _t1576 = _t1579 } - _t1499 = _t1502 + _t1573 = _t1576 } - _t1496 = _t1499 + _t1570 = _t1573 } - _t1493 = _t1496 + _t1567 = _t1570 } - _t1490 = _t1493 + _t1564 = _t1567 } - result800 := _t1490 - p.recordSpan(int(span_start799), "Type") - return result800 + result837 := _t1564 + p.recordSpan(int(span_start836), "Type") + return result837 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start801 := int64(p.spanStart()) + span_start838 := int64(p.spanStart()) p.consumeLiteral("UNKNOWN") - _t1532 := &pb.UnspecifiedType{} - result802 := _t1532 - p.recordSpan(int(span_start801), "UnspecifiedType") - return result802 + _t1606 := &pb.UnspecifiedType{} + result839 := _t1606 + p.recordSpan(int(span_start838), "UnspecifiedType") + return result839 } func (p *Parser) parse_string_type() *pb.StringType { - span_start803 := int64(p.spanStart()) + span_start840 := int64(p.spanStart()) p.consumeLiteral("STRING") - _t1533 := &pb.StringType{} - result804 := _t1533 - p.recordSpan(int(span_start803), "StringType") - return result804 + _t1607 := &pb.StringType{} + result841 := _t1607 + p.recordSpan(int(span_start840), "StringType") + return result841 } func (p *Parser) parse_int_type() *pb.IntType { - span_start805 := int64(p.spanStart()) + span_start842 := int64(p.spanStart()) p.consumeLiteral("INT") - _t1534 := &pb.IntType{} - result806 := _t1534 - p.recordSpan(int(span_start805), "IntType") - return result806 + _t1608 := &pb.IntType{} + result843 := _t1608 + p.recordSpan(int(span_start842), "IntType") + return result843 } func (p *Parser) parse_float_type() *pb.FloatType { - span_start807 := int64(p.spanStart()) + span_start844 := int64(p.spanStart()) p.consumeLiteral("FLOAT") - _t1535 := &pb.FloatType{} - result808 := _t1535 - p.recordSpan(int(span_start807), "FloatType") - return result808 + _t1609 := &pb.FloatType{} + result845 := _t1609 + p.recordSpan(int(span_start844), "FloatType") + return result845 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start809 := int64(p.spanStart()) + span_start846 := int64(p.spanStart()) p.consumeLiteral("UINT128") - _t1536 := &pb.UInt128Type{} - result810 := _t1536 - p.recordSpan(int(span_start809), "UInt128Type") - return result810 + _t1610 := &pb.UInt128Type{} + result847 := _t1610 + p.recordSpan(int(span_start846), "UInt128Type") + return result847 } func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start811 := int64(p.spanStart()) + span_start848 := int64(p.spanStart()) p.consumeLiteral("INT128") - _t1537 := &pb.Int128Type{} - result812 := _t1537 - p.recordSpan(int(span_start811), "Int128Type") - return result812 + _t1611 := &pb.Int128Type{} + result849 := _t1611 + p.recordSpan(int(span_start848), "Int128Type") + return result849 } func (p *Parser) parse_date_type() *pb.DateType { - span_start813 := int64(p.spanStart()) + span_start850 := int64(p.spanStart()) p.consumeLiteral("DATE") - _t1538 := &pb.DateType{} - result814 := _t1538 - p.recordSpan(int(span_start813), "DateType") - return result814 + _t1612 := &pb.DateType{} + result851 := _t1612 + p.recordSpan(int(span_start850), "DateType") + return result851 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start815 := int64(p.spanStart()) + span_start852 := int64(p.spanStart()) p.consumeLiteral("DATETIME") - _t1539 := &pb.DateTimeType{} - result816 := _t1539 - p.recordSpan(int(span_start815), "DateTimeType") - return result816 + _t1613 := &pb.DateTimeType{} + result853 := _t1613 + p.recordSpan(int(span_start852), "DateTimeType") + return result853 } func (p *Parser) parse_missing_type() *pb.MissingType { - span_start817 := int64(p.spanStart()) + span_start854 := int64(p.spanStart()) p.consumeLiteral("MISSING") - _t1540 := &pb.MissingType{} - result818 := _t1540 - p.recordSpan(int(span_start817), "MissingType") - return result818 + _t1614 := &pb.MissingType{} + result855 := _t1614 + p.recordSpan(int(span_start854), "MissingType") + return result855 } func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start821 := int64(p.spanStart()) + span_start858 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int819 := p.consumeTerminal("INT").Value.i64 - int_3820 := p.consumeTerminal("INT").Value.i64 + int856 := p.consumeTerminal("INT").Value.i64 + int_3857 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1541 := &pb.DecimalType{Precision: int32(int819), Scale: int32(int_3820)} - result822 := _t1541 - p.recordSpan(int(span_start821), "DecimalType") - return result822 + _t1615 := &pb.DecimalType{Precision: int32(int856), Scale: int32(int_3857)} + result859 := _t1615 + p.recordSpan(int(span_start858), "DecimalType") + return result859 } func (p *Parser) parse_boolean_type() *pb.BooleanType { - span_start823 := int64(p.spanStart()) + span_start860 := int64(p.spanStart()) p.consumeLiteral("BOOLEAN") - _t1542 := &pb.BooleanType{} - result824 := _t1542 - p.recordSpan(int(span_start823), "BooleanType") - return result824 + _t1616 := &pb.BooleanType{} + result861 := _t1616 + p.recordSpan(int(span_start860), "BooleanType") + return result861 } func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start825 := int64(p.spanStart()) + span_start862 := int64(p.spanStart()) p.consumeLiteral("INT32") - _t1543 := &pb.Int32Type{} - result826 := _t1543 - p.recordSpan(int(span_start825), "Int32Type") - return result826 + _t1617 := &pb.Int32Type{} + result863 := _t1617 + p.recordSpan(int(span_start862), "Int32Type") + return result863 } func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start827 := int64(p.spanStart()) + span_start864 := int64(p.spanStart()) p.consumeLiteral("FLOAT32") - _t1544 := &pb.Float32Type{} - result828 := _t1544 - p.recordSpan(int(span_start827), "Float32Type") - return result828 + _t1618 := &pb.Float32Type{} + result865 := _t1618 + p.recordSpan(int(span_start864), "Float32Type") + return result865 } func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start829 := int64(p.spanStart()) + span_start866 := int64(p.spanStart()) p.consumeLiteral("UINT32") - _t1545 := &pb.UInt32Type{} - result830 := _t1545 - p.recordSpan(int(span_start829), "UInt32Type") - return result830 -======= - xs809 := []*pb.Binding{} - cond810 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond810 { - _t1537 := p.parse_binding() - item811 := _t1537 - xs809 = append(xs809, item811) - cond810 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings812 := xs809 - var _t1538 []*pb.Binding - if p.matchLookaheadLiteral("|", 0) { - _t1539 := p.parse_value_bindings() - _t1538 = _t1539 - } - value_bindings813 := _t1538 - p.consumeLiteral("]") - _t1540 := value_bindings813 - if value_bindings813 == nil { - _t1540 = []*pb.Binding{} - } - return []interface{}{bindings812, _t1540} + _t1619 := &pb.UInt32Type{} + result867 := _t1619 + p.recordSpan(int(span_start866), "UInt32Type") + return result867 } -func (p *Parser) parse_binding() *pb.Binding { - span_start816 := int64(p.spanStart()) - symbol814 := p.consumeTerminal("SYMBOL").Value.str - p.consumeLiteral("::") - _t1541 := p.parse_type() - type815 := _t1541 - _t1542 := &pb.Var{Name: symbol814} - _t1543 := &pb.Binding{Var: _t1542, Type: type815} - result817 := _t1543 - p.recordSpan(int(span_start816), "Binding") - return result817 +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) + } + bindings871 := xs868 + return bindings871 } -func (p *Parser) parse_type() *pb.Type { - span_start833 := int64(p.spanStart()) - var _t1544 int64 - if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1544 = 0 - } else { - var _t1545 int64 - if p.matchLookaheadLiteral("UINT32", 0) { - _t1545 = 13 +func (p *Parser) parse_formula() *pb.Formula { + span_start886 := int64(p.spanStart()) + var _t1621 int64 + if p.matchLookaheadLiteral("(", 0) { + var _t1622 int64 + if p.matchLookaheadLiteral("true", 1) { + _t1622 = 0 } else { - var _t1546 int64 - if p.matchLookaheadLiteral("UINT128", 0) { - _t1546 = 4 + var _t1623 int64 + if p.matchLookaheadLiteral("relatom", 1) { + _t1623 = 11 } else { - var _t1547 int64 - if p.matchLookaheadLiteral("STRING", 0) { - _t1547 = 1 + var _t1624 int64 + if p.matchLookaheadLiteral("reduce", 1) { + _t1624 = 3 } else { - var _t1548 int64 - if p.matchLookaheadLiteral("MISSING", 0) { - _t1548 = 8 + var _t1625 int64 + if p.matchLookaheadLiteral("primitive", 1) { + _t1625 = 10 } else { - var _t1549 int64 - if p.matchLookaheadLiteral("INT32", 0) { - _t1549 = 11 + var _t1626 int64 + if p.matchLookaheadLiteral("pragma", 1) { + _t1626 = 9 } else { - var _t1550 int64 - if p.matchLookaheadLiteral("INT128", 0) { - _t1550 = 5 + var _t1627 int64 + if p.matchLookaheadLiteral("or", 1) { + _t1627 = 5 } else { - var _t1551 int64 - if p.matchLookaheadLiteral("INT", 0) { - _t1551 = 2 + var _t1628 int64 + if p.matchLookaheadLiteral("not", 1) { + _t1628 = 6 } else { - var _t1552 int64 - if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1552 = 12 + var _t1629 int64 + if p.matchLookaheadLiteral("ffi", 1) { + _t1629 = 7 } else { - var _t1553 int64 - if p.matchLookaheadLiteral("FLOAT", 0) { - _t1553 = 3 + var _t1630 int64 + if p.matchLookaheadLiteral("false", 1) { + _t1630 = 1 } else { - var _t1554 int64 - if p.matchLookaheadLiteral("DATETIME", 0) { - _t1554 = 7 + var _t1631 int64 + if p.matchLookaheadLiteral("exists", 1) { + _t1631 = 2 } else { - var _t1555 int64 - if p.matchLookaheadLiteral("DATE", 0) { - _t1555 = 6 + var _t1632 int64 + if p.matchLookaheadLiteral("cast", 1) { + _t1632 = 12 } else { - var _t1556 int64 - if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1556 = 10 + var _t1633 int64 + if p.matchLookaheadLiteral("atom", 1) { + _t1633 = 8 } else { - var _t1557 int64 - if p.matchLookaheadLiteral("(", 0) { - _t1557 = 9 + var _t1634 int64 + if p.matchLookaheadLiteral("and", 1) { + _t1634 = 4 } else { - _t1557 = -1 + var _t1635 int64 + if p.matchLookaheadLiteral(">=", 1) { + _t1635 = 10 + } else { + var _t1636 int64 + if p.matchLookaheadLiteral(">", 1) { + _t1636 = 10 + } else { + var _t1637 int64 + if p.matchLookaheadLiteral("=", 1) { + _t1637 = 10 + } else { + var _t1638 int64 + if p.matchLookaheadLiteral("<=", 1) { + _t1638 = 10 + } else { + var _t1639 int64 + if p.matchLookaheadLiteral("<", 1) { + _t1639 = 10 + } else { + var _t1640 int64 + if p.matchLookaheadLiteral("/", 1) { + _t1640 = 10 + } else { + var _t1641 int64 + if p.matchLookaheadLiteral("-", 1) { + _t1641 = 10 + } else { + var _t1642 int64 + if p.matchLookaheadLiteral("+", 1) { + _t1642 = 10 + } else { + var _t1643 int64 + if p.matchLookaheadLiteral("*", 1) { + _t1643 = 10 + } else { + _t1643 = -1 + } + _t1642 = _t1643 + } + _t1641 = _t1642 + } + _t1640 = _t1641 + } + _t1639 = _t1640 + } + _t1638 = _t1639 + } + _t1637 = _t1638 + } + _t1636 = _t1637 + } + _t1635 = _t1636 + } + _t1634 = _t1635 } - _t1556 = _t1557 + _t1633 = _t1634 } - _t1555 = _t1556 + _t1632 = _t1633 } - _t1554 = _t1555 + _t1631 = _t1632 } - _t1553 = _t1554 + _t1630 = _t1631 } - _t1552 = _t1553 + _t1629 = _t1630 } - _t1551 = _t1552 + _t1628 = _t1629 } - _t1550 = _t1551 + _t1627 = _t1628 } - _t1549 = _t1550 + _t1626 = _t1627 } - _t1548 = _t1549 + _t1625 = _t1626 } - _t1547 = _t1548 + _t1624 = _t1625 } - _t1546 = _t1547 + _t1623 = _t1624 } - _t1545 = _t1546 + _t1622 = _t1623 } - _t1544 = _t1545 - } - prediction818 := _t1544 - var _t1558 *pb.Type - if prediction818 == 13 { - _t1559 := p.parse_uint32_type() - uint32_type832 := _t1559 - _t1560 := &pb.Type{} - _t1560.Type = &pb.Type_Uint32Type{Uint32Type: uint32_type832} - _t1558 = _t1560 + _t1621 = _t1622 + } 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 } else { - var _t1561 *pb.Type - if prediction818 == 12 { - _t1562 := p.parse_float32_type() - float32_type831 := _t1562 - _t1563 := &pb.Type{} - _t1563.Type = &pb.Type_Float32Type{Float32Type: float32_type831} - _t1561 = _t1563 + 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 } else { - var _t1564 *pb.Type - if prediction818 == 11 { - _t1565 := p.parse_int32_type() - int32_type830 := _t1565 - _t1566 := &pb.Type{} - _t1566.Type = &pb.Type_Int32Type{Int32Type: int32_type830} - _t1564 = _t1566 + 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 } else { - var _t1567 *pb.Type - if prediction818 == 10 { - _t1568 := p.parse_boolean_type() - boolean_type829 := _t1568 - _t1569 := &pb.Type{} - _t1569.Type = &pb.Type_BooleanType{BooleanType: boolean_type829} - _t1567 = _t1569 + 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 } else { - var _t1570 *pb.Type - if prediction818 == 9 { - _t1571 := p.parse_decimal_type() - decimal_type828 := _t1571 - _t1572 := &pb.Type{} - _t1572.Type = &pb.Type_DecimalType{DecimalType: decimal_type828} - _t1570 = _t1572 + 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 } else { - var _t1573 *pb.Type - if prediction818 == 8 { - _t1574 := p.parse_missing_type() - missing_type827 := _t1574 - _t1575 := &pb.Type{} - _t1575.Type = &pb.Type_MissingType{MissingType: missing_type827} - _t1573 = _t1575 + 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 } else { - var _t1576 *pb.Type - if prediction818 == 7 { - _t1577 := p.parse_datetime_type() - datetime_type826 := _t1577 - _t1578 := &pb.Type{} - _t1578.Type = &pb.Type_DatetimeType{DatetimeType: datetime_type826} - _t1576 = _t1578 + 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 } else { - var _t1579 *pb.Type - if prediction818 == 6 { - _t1580 := p.parse_date_type() - date_type825 := _t1580 - _t1581 := &pb.Type{} - _t1581.Type = &pb.Type_DateType{DateType: date_type825} - _t1579 = _t1581 + 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 } else { - var _t1582 *pb.Type - if prediction818 == 5 { - _t1583 := p.parse_int128_type() - int128_type824 := _t1583 - _t1584 := &pb.Type{} - _t1584.Type = &pb.Type_Int128Type{Int128Type: int128_type824} - _t1582 = _t1584 + 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 } else { - var _t1585 *pb.Type - if prediction818 == 4 { - _t1586 := p.parse_uint128_type() - uint128_type823 := _t1586 - _t1587 := &pb.Type{} - _t1587.Type = &pb.Type_Uint128Type{Uint128Type: uint128_type823} - _t1585 = _t1587 + 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 } else { - var _t1588 *pb.Type - if prediction818 == 3 { - _t1589 := p.parse_float_type() - float_type822 := _t1589 - _t1590 := &pb.Type{} - _t1590.Type = &pb.Type_FloatType{FloatType: float_type822} - _t1588 = _t1590 + 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 } else { - var _t1591 *pb.Type - if prediction818 == 2 { - _t1592 := p.parse_int_type() - int_type821 := _t1592 - _t1593 := &pb.Type{} - _t1593.Type = &pb.Type_IntType{IntType: int_type821} - _t1591 = _t1593 + 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 } else { - var _t1594 *pb.Type - if prediction818 == 1 { - _t1595 := p.parse_string_type() - string_type820 := _t1595 - _t1596 := &pb.Type{} - _t1596.Type = &pb.Type_StringType{StringType: string_type820} - _t1594 = _t1596 + 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 } else { - var _t1597 *pb.Type - if prediction818 == 0 { - _t1598 := p.parse_unspecified_type() - unspecified_type819 := _t1598 - _t1599 := &pb.Type{} - _t1599.Type = &pb.Type_UnspecifiedType{UnspecifiedType: unspecified_type819} - _t1597 = _t1599 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in type", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1594 = _t1597 + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1591 = _t1594 + _t1677 = _t1680 } - _t1588 = _t1591 + _t1674 = _t1677 } - _t1585 = _t1588 + _t1671 = _t1674 } - _t1582 = _t1585 + _t1668 = _t1671 } - _t1579 = _t1582 + _t1665 = _t1668 } - _t1576 = _t1579 + _t1662 = _t1665 } - _t1573 = _t1576 + _t1659 = _t1662 } - _t1570 = _t1573 + _t1656 = _t1659 } - _t1567 = _t1570 + _t1653 = _t1656 } - _t1564 = _t1567 + _t1650 = _t1653 } - _t1561 = _t1564 + _t1647 = _t1650 } - _t1558 = _t1561 + _t1644 = _t1647 } - result834 := _t1558 - p.recordSpan(int(span_start833), "Type") - return result834 -} - -func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start835 := int64(p.spanStart()) - p.consumeLiteral("UNKNOWN") - _t1600 := &pb.UnspecifiedType{} - result836 := _t1600 - p.recordSpan(int(span_start835), "UnspecifiedType") - return result836 -} - -func (p *Parser) parse_string_type() *pb.StringType { - span_start837 := int64(p.spanStart()) - p.consumeLiteral("STRING") - _t1601 := &pb.StringType{} - result838 := _t1601 - p.recordSpan(int(span_start837), "StringType") - return result838 -} - -func (p *Parser) parse_int_type() *pb.IntType { - span_start839 := int64(p.spanStart()) - p.consumeLiteral("INT") - _t1602 := &pb.IntType{} - result840 := _t1602 - p.recordSpan(int(span_start839), "IntType") - return result840 -} - -func (p *Parser) parse_float_type() *pb.FloatType { - span_start841 := int64(p.spanStart()) - p.consumeLiteral("FLOAT") - _t1603 := &pb.FloatType{} - result842 := _t1603 - p.recordSpan(int(span_start841), "FloatType") - return result842 -} - -func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start843 := int64(p.spanStart()) - p.consumeLiteral("UINT128") - _t1604 := &pb.UInt128Type{} - result844 := _t1604 - p.recordSpan(int(span_start843), "UInt128Type") - return result844 -} - -func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start845 := int64(p.spanStart()) - p.consumeLiteral("INT128") - _t1605 := &pb.Int128Type{} - result846 := _t1605 - p.recordSpan(int(span_start845), "Int128Type") - return result846 + result887 := _t1644 + p.recordSpan(int(span_start886), "Formula") + return result887 } -func (p *Parser) parse_date_type() *pb.DateType { - span_start847 := int64(p.spanStart()) - p.consumeLiteral("DATE") - _t1606 := &pb.DateType{} - result848 := _t1606 - p.recordSpan(int(span_start847), "DateType") - return result848 +func (p *Parser) parse_true() *pb.Conjunction { + span_start888 := 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 } -func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start849 := int64(p.spanStart()) - p.consumeLiteral("DATETIME") - _t1607 := &pb.DateTimeType{} - result850 := _t1607 - p.recordSpan(int(span_start849), "DateTimeType") - return result850 +func (p *Parser) parse_false() *pb.Disjunction { + span_start890 := 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 } -func (p *Parser) parse_missing_type() *pb.MissingType { - span_start851 := int64(p.spanStart()) - p.consumeLiteral("MISSING") - _t1608 := &pb.MissingType{} - result852 := _t1608 - p.recordSpan(int(span_start851), "MissingType") - return result852 +func (p *Parser) parse_exists() *pb.Exists { + span_start894 := int64(p.spanStart()) + p.consumeLiteral("(") + p.consumeLiteral("exists") + _t1685 := p.parse_bindings() + bindings892 := _t1685 + _t1686 := p.parse_formula() + formula893 := _t1686 + 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 } -func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start855 := int64(p.spanStart()) +func (p *Parser) parse_reduce() *pb.Reduce { + span_start899 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("DECIMAL") - int853 := p.consumeTerminal("INT").Value.i64 - int_3854 := p.consumeTerminal("INT").Value.i64 + p.consumeLiteral("reduce") + _t1689 := p.parse_abstraction() + abstraction896 := _t1689 + _t1690 := p.parse_abstraction() + abstraction_3897 := _t1690 + _t1691 := p.parse_terms() + terms898 := _t1691 p.consumeLiteral(")") - _t1609 := &pb.DecimalType{Precision: int32(int853), Scale: int32(int_3854)} - result856 := _t1609 - p.recordSpan(int(span_start855), "DecimalType") - return result856 + _t1692 := &pb.Reduce{Op: abstraction896, Body: abstraction_3897, Terms: terms898} + result900 := _t1692 + p.recordSpan(int(span_start899), "Reduce") + return result900 } -func (p *Parser) parse_boolean_type() *pb.BooleanType { - span_start857 := int64(p.spanStart()) - p.consumeLiteral("BOOLEAN") - _t1610 := &pb.BooleanType{} - result858 := _t1610 - p.recordSpan(int(span_start857), "BooleanType") - return result858 -} - -func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start859 := int64(p.spanStart()) - p.consumeLiteral("INT32") - _t1611 := &pb.Int32Type{} - result860 := _t1611 - p.recordSpan(int(span_start859), "Int32Type") - return result860 -} - -func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start861 := int64(p.spanStart()) - p.consumeLiteral("FLOAT32") - _t1612 := &pb.Float32Type{} - result862 := _t1612 - p.recordSpan(int(span_start861), "Float32Type") - return result862 -} - -func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start863 := int64(p.spanStart()) - p.consumeLiteral("UINT32") - _t1613 := &pb.UInt32Type{} - result864 := _t1613 - p.recordSpan(int(span_start863), "UInt32Type") - return result864 ->>>>>>> origin/main -} - -func (p *Parser) parse_value_bindings() []*pb.Binding { - p.consumeLiteral("|") -<<<<<<< HEAD - xs831 := []*pb.Binding{} - cond832 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond832 { - _t1546 := p.parse_binding() - item833 := _t1546 - xs831 = append(xs831, item833) - cond832 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings834 := xs831 - return bindings834 -} - -func (p *Parser) parse_formula() *pb.Formula { - span_start849 := int64(p.spanStart()) - var _t1547 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1548 int64 - if p.matchLookaheadLiteral("true", 1) { - _t1548 = 0 - } else { - var _t1549 int64 - if p.matchLookaheadLiteral("relatom", 1) { - _t1549 = 11 - } else { - var _t1550 int64 - if p.matchLookaheadLiteral("reduce", 1) { - _t1550 = 3 - } else { - var _t1551 int64 - if p.matchLookaheadLiteral("primitive", 1) { - _t1551 = 10 - } else { - var _t1552 int64 - if p.matchLookaheadLiteral("pragma", 1) { - _t1552 = 9 - } else { - var _t1553 int64 - if p.matchLookaheadLiteral("or", 1) { - _t1553 = 5 - } else { - var _t1554 int64 - if p.matchLookaheadLiteral("not", 1) { - _t1554 = 6 - } else { - var _t1555 int64 - if p.matchLookaheadLiteral("ffi", 1) { - _t1555 = 7 - } else { - var _t1556 int64 - if p.matchLookaheadLiteral("false", 1) { - _t1556 = 1 - } else { - var _t1557 int64 - if p.matchLookaheadLiteral("exists", 1) { - _t1557 = 2 - } else { - var _t1558 int64 - if p.matchLookaheadLiteral("cast", 1) { - _t1558 = 12 - } else { - var _t1559 int64 - if p.matchLookaheadLiteral("atom", 1) { - _t1559 = 8 - } else { - var _t1560 int64 - if p.matchLookaheadLiteral("and", 1) { - _t1560 = 4 - } else { - var _t1561 int64 - if p.matchLookaheadLiteral(">=", 1) { - _t1561 = 10 - } else { - var _t1562 int64 - if p.matchLookaheadLiteral(">", 1) { - _t1562 = 10 - } else { - var _t1563 int64 - if p.matchLookaheadLiteral("=", 1) { - _t1563 = 10 - } else { - var _t1564 int64 - if p.matchLookaheadLiteral("<=", 1) { - _t1564 = 10 - } else { - var _t1565 int64 - if p.matchLookaheadLiteral("<", 1) { - _t1565 = 10 - } else { - var _t1566 int64 - if p.matchLookaheadLiteral("/", 1) { - _t1566 = 10 - } else { - var _t1567 int64 - if p.matchLookaheadLiteral("-", 1) { - _t1567 = 10 - } else { - var _t1568 int64 - if p.matchLookaheadLiteral("+", 1) { - _t1568 = 10 - } else { - var _t1569 int64 - if p.matchLookaheadLiteral("*", 1) { - _t1569 = 10 - } else { - _t1569 = -1 - } - _t1568 = _t1569 - } - _t1567 = _t1568 - } - _t1566 = _t1567 - } - _t1565 = _t1566 - } - _t1564 = _t1565 - } - _t1563 = _t1564 - } - _t1562 = _t1563 - } - _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 - } - _t1548 = _t1549 - } - _t1547 = _t1548 - } else { - _t1547 = -1 - } - prediction835 := _t1547 - var _t1570 *pb.Formula - if prediction835 == 12 { - _t1571 := p.parse_cast() - cast848 := _t1571 - _t1572 := &pb.Formula{} - _t1572.FormulaType = &pb.Formula_Cast{Cast: cast848} - _t1570 = _t1572 - } else { - var _t1573 *pb.Formula - if prediction835 == 11 { - _t1574 := p.parse_rel_atom() - rel_atom847 := _t1574 - _t1575 := &pb.Formula{} - _t1575.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom847} - _t1573 = _t1575 - } else { - var _t1576 *pb.Formula - if prediction835 == 10 { - _t1577 := p.parse_primitive() - primitive846 := _t1577 - _t1578 := &pb.Formula{} - _t1578.FormulaType = &pb.Formula_Primitive{Primitive: primitive846} - _t1576 = _t1578 - } else { - var _t1579 *pb.Formula - if prediction835 == 9 { - _t1580 := p.parse_pragma() - pragma845 := _t1580 - _t1581 := &pb.Formula{} - _t1581.FormulaType = &pb.Formula_Pragma{Pragma: pragma845} - _t1579 = _t1581 - } else { - var _t1582 *pb.Formula - if prediction835 == 8 { - _t1583 := p.parse_atom() - atom844 := _t1583 - _t1584 := &pb.Formula{} - _t1584.FormulaType = &pb.Formula_Atom{Atom: atom844} - _t1582 = _t1584 - } else { - var _t1585 *pb.Formula - if prediction835 == 7 { - _t1586 := p.parse_ffi() - ffi843 := _t1586 - _t1587 := &pb.Formula{} - _t1587.FormulaType = &pb.Formula_Ffi{Ffi: ffi843} - _t1585 = _t1587 - } else { - var _t1588 *pb.Formula - if prediction835 == 6 { - _t1589 := p.parse_not() - not842 := _t1589 - _t1590 := &pb.Formula{} - _t1590.FormulaType = &pb.Formula_Not{Not: not842} - _t1588 = _t1590 - } else { - var _t1591 *pb.Formula - if prediction835 == 5 { - _t1592 := p.parse_disjunction() - disjunction841 := _t1592 - _t1593 := &pb.Formula{} - _t1593.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction841} - _t1591 = _t1593 - } else { - var _t1594 *pb.Formula - if prediction835 == 4 { - _t1595 := p.parse_conjunction() - conjunction840 := _t1595 - _t1596 := &pb.Formula{} - _t1596.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction840} - _t1594 = _t1596 - } else { - var _t1597 *pb.Formula - if prediction835 == 3 { - _t1598 := p.parse_reduce() - reduce839 := _t1598 - _t1599 := &pb.Formula{} - _t1599.FormulaType = &pb.Formula_Reduce{Reduce: reduce839} - _t1597 = _t1599 - } else { - var _t1600 *pb.Formula - if prediction835 == 2 { - _t1601 := p.parse_exists() - exists838 := _t1601 - _t1602 := &pb.Formula{} - _t1602.FormulaType = &pb.Formula_Exists{Exists: exists838} - _t1600 = _t1602 - } else { - var _t1603 *pb.Formula - if prediction835 == 1 { - _t1604 := p.parse_false() - false837 := _t1604 - _t1605 := &pb.Formula{} - _t1605.FormulaType = &pb.Formula_Disjunction{Disjunction: false837} - _t1603 = _t1605 - } else { - var _t1606 *pb.Formula - if prediction835 == 0 { - _t1607 := p.parse_true() - true836 := _t1607 - _t1608 := &pb.Formula{} - _t1608.FormulaType = &pb.Formula_Conjunction{Conjunction: true836} - _t1606 = _t1608 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1603 = _t1606 - } - _t1600 = _t1603 - } - _t1597 = _t1600 - } - _t1594 = _t1597 - } - _t1591 = _t1594 - } - _t1588 = _t1591 - } - _t1585 = _t1588 - } - _t1582 = _t1585 - } - _t1579 = _t1582 - } - _t1576 = _t1579 - } - _t1573 = _t1576 - } - _t1570 = _t1573 - } - result850 := _t1570 - p.recordSpan(int(span_start849), "Formula") - return result850 -} - -func (p *Parser) parse_true() *pb.Conjunction { - span_start851 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("true") - p.consumeLiteral(")") - _t1609 := &pb.Conjunction{Args: []*pb.Formula{}} - result852 := _t1609 - p.recordSpan(int(span_start851), "Conjunction") - return result852 -} - -func (p *Parser) parse_false() *pb.Disjunction { - span_start853 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("false") - p.consumeLiteral(")") - _t1610 := &pb.Disjunction{Args: []*pb.Formula{}} - result854 := _t1610 - p.recordSpan(int(span_start853), "Disjunction") - return result854 -} - -func (p *Parser) parse_exists() *pb.Exists { - span_start857 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("exists") - _t1611 := p.parse_bindings() - bindings855 := _t1611 - _t1612 := p.parse_formula() - formula856 := _t1612 - p.consumeLiteral(")") - _t1613 := &pb.Abstraction{Vars: listConcat(bindings855[0].([]*pb.Binding), bindings855[1].([]*pb.Binding)), Value: formula856} - _t1614 := &pb.Exists{Body: _t1613} - result858 := _t1614 - p.recordSpan(int(span_start857), "Exists") - return result858 -} - -func (p *Parser) parse_reduce() *pb.Reduce { - span_start862 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("reduce") - _t1615 := p.parse_abstraction() - abstraction859 := _t1615 - _t1616 := p.parse_abstraction() - abstraction_3860 := _t1616 - _t1617 := p.parse_terms() - terms861 := _t1617 - p.consumeLiteral(")") - _t1618 := &pb.Reduce{Op: abstraction859, Body: abstraction_3860, Terms: terms861} - result863 := _t1618 - p.recordSpan(int(span_start862), "Reduce") - return result863 -======= - xs865 := []*pb.Binding{} - cond866 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond866 { - _t1614 := p.parse_binding() - item867 := _t1614 - xs865 = append(xs865, item867) - cond866 = p.matchLookaheadTerminal("SYMBOL", 0) - } - bindings868 := xs865 - return bindings868 -} - -func (p *Parser) parse_formula() *pb.Formula { - span_start883 := int64(p.spanStart()) - var _t1615 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1616 int64 - if p.matchLookaheadLiteral("true", 1) { - _t1616 = 0 - } else { - var _t1617 int64 - if p.matchLookaheadLiteral("relatom", 1) { - _t1617 = 11 - } else { - var _t1618 int64 - if p.matchLookaheadLiteral("reduce", 1) { - _t1618 = 3 - } else { - var _t1619 int64 - if p.matchLookaheadLiteral("primitive", 1) { - _t1619 = 10 - } else { - var _t1620 int64 - if p.matchLookaheadLiteral("pragma", 1) { - _t1620 = 9 - } else { - var _t1621 int64 - if p.matchLookaheadLiteral("or", 1) { - _t1621 = 5 - } else { - var _t1622 int64 - if p.matchLookaheadLiteral("not", 1) { - _t1622 = 6 - } else { - var _t1623 int64 - if p.matchLookaheadLiteral("ffi", 1) { - _t1623 = 7 - } else { - var _t1624 int64 - if p.matchLookaheadLiteral("false", 1) { - _t1624 = 1 - } else { - var _t1625 int64 - if p.matchLookaheadLiteral("exists", 1) { - _t1625 = 2 - } else { - var _t1626 int64 - if p.matchLookaheadLiteral("cast", 1) { - _t1626 = 12 - } else { - var _t1627 int64 - if p.matchLookaheadLiteral("atom", 1) { - _t1627 = 8 - } else { - var _t1628 int64 - if p.matchLookaheadLiteral("and", 1) { - _t1628 = 4 - } else { - var _t1629 int64 - if p.matchLookaheadLiteral(">=", 1) { - _t1629 = 10 - } else { - var _t1630 int64 - if p.matchLookaheadLiteral(">", 1) { - _t1630 = 10 - } else { - var _t1631 int64 - if p.matchLookaheadLiteral("=", 1) { - _t1631 = 10 - } else { - var _t1632 int64 - if p.matchLookaheadLiteral("<=", 1) { - _t1632 = 10 - } else { - var _t1633 int64 - if p.matchLookaheadLiteral("<", 1) { - _t1633 = 10 - } else { - var _t1634 int64 - if p.matchLookaheadLiteral("/", 1) { - _t1634 = 10 - } else { - var _t1635 int64 - if p.matchLookaheadLiteral("-", 1) { - _t1635 = 10 - } else { - var _t1636 int64 - if p.matchLookaheadLiteral("+", 1) { - _t1636 = 10 - } else { - var _t1637 int64 - if p.matchLookaheadLiteral("*", 1) { - _t1637 = 10 - } else { - _t1637 = -1 - } - _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 - } - _t1615 = _t1616 - } else { - _t1615 = -1 - } - prediction869 := _t1615 - var _t1638 *pb.Formula - if prediction869 == 12 { - _t1639 := p.parse_cast() - cast882 := _t1639 - _t1640 := &pb.Formula{} - _t1640.FormulaType = &pb.Formula_Cast{Cast: cast882} - _t1638 = _t1640 - } else { - var _t1641 *pb.Formula - if prediction869 == 11 { - _t1642 := p.parse_rel_atom() - rel_atom881 := _t1642 - _t1643 := &pb.Formula{} - _t1643.FormulaType = &pb.Formula_RelAtom{RelAtom: rel_atom881} - _t1641 = _t1643 - } else { - var _t1644 *pb.Formula - if prediction869 == 10 { - _t1645 := p.parse_primitive() - primitive880 := _t1645 - _t1646 := &pb.Formula{} - _t1646.FormulaType = &pb.Formula_Primitive{Primitive: primitive880} - _t1644 = _t1646 - } else { - var _t1647 *pb.Formula - if prediction869 == 9 { - _t1648 := p.parse_pragma() - pragma879 := _t1648 - _t1649 := &pb.Formula{} - _t1649.FormulaType = &pb.Formula_Pragma{Pragma: pragma879} - _t1647 = _t1649 - } else { - var _t1650 *pb.Formula - if prediction869 == 8 { - _t1651 := p.parse_atom() - atom878 := _t1651 - _t1652 := &pb.Formula{} - _t1652.FormulaType = &pb.Formula_Atom{Atom: atom878} - _t1650 = _t1652 - } else { - var _t1653 *pb.Formula - if prediction869 == 7 { - _t1654 := p.parse_ffi() - ffi877 := _t1654 - _t1655 := &pb.Formula{} - _t1655.FormulaType = &pb.Formula_Ffi{Ffi: ffi877} - _t1653 = _t1655 - } else { - var _t1656 *pb.Formula - if prediction869 == 6 { - _t1657 := p.parse_not() - not876 := _t1657 - _t1658 := &pb.Formula{} - _t1658.FormulaType = &pb.Formula_Not{Not: not876} - _t1656 = _t1658 - } else { - var _t1659 *pb.Formula - if prediction869 == 5 { - _t1660 := p.parse_disjunction() - disjunction875 := _t1660 - _t1661 := &pb.Formula{} - _t1661.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction875} - _t1659 = _t1661 - } else { - var _t1662 *pb.Formula - if prediction869 == 4 { - _t1663 := p.parse_conjunction() - conjunction874 := _t1663 - _t1664 := &pb.Formula{} - _t1664.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction874} - _t1662 = _t1664 - } else { - var _t1665 *pb.Formula - if prediction869 == 3 { - _t1666 := p.parse_reduce() - reduce873 := _t1666 - _t1667 := &pb.Formula{} - _t1667.FormulaType = &pb.Formula_Reduce{Reduce: reduce873} - _t1665 = _t1667 - } else { - var _t1668 *pb.Formula - if prediction869 == 2 { - _t1669 := p.parse_exists() - exists872 := _t1669 - _t1670 := &pb.Formula{} - _t1670.FormulaType = &pb.Formula_Exists{Exists: exists872} - _t1668 = _t1670 - } else { - var _t1671 *pb.Formula - if prediction869 == 1 { - _t1672 := p.parse_false() - false871 := _t1672 - _t1673 := &pb.Formula{} - _t1673.FormulaType = &pb.Formula_Disjunction{Disjunction: false871} - _t1671 = _t1673 - } else { - var _t1674 *pb.Formula - if prediction869 == 0 { - _t1675 := p.parse_true() - true870 := _t1675 - _t1676 := &pb.Formula{} - _t1676.FormulaType = &pb.Formula_Conjunction{Conjunction: true870} - _t1674 = _t1676 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1671 = _t1674 - } - _t1668 = _t1671 - } - _t1665 = _t1668 - } - _t1662 = _t1665 - } - _t1659 = _t1662 - } - _t1656 = _t1659 - } - _t1653 = _t1656 - } - _t1650 = _t1653 - } - _t1647 = _t1650 - } - _t1644 = _t1647 - } - _t1641 = _t1644 - } - _t1638 = _t1641 - } - result884 := _t1638 - p.recordSpan(int(span_start883), "Formula") - return result884 -} - -func (p *Parser) parse_true() *pb.Conjunction { - span_start885 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("true") - p.consumeLiteral(")") - _t1677 := &pb.Conjunction{Args: []*pb.Formula{}} - result886 := _t1677 - p.recordSpan(int(span_start885), "Conjunction") - return result886 -} - -func (p *Parser) parse_false() *pb.Disjunction { - span_start887 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("false") - p.consumeLiteral(")") - _t1678 := &pb.Disjunction{Args: []*pb.Formula{}} - result888 := _t1678 - p.recordSpan(int(span_start887), "Disjunction") - return result888 -} - -func (p *Parser) parse_exists() *pb.Exists { - span_start891 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("exists") - _t1679 := p.parse_bindings() - bindings889 := _t1679 - _t1680 := p.parse_formula() - formula890 := _t1680 - p.consumeLiteral(")") - _t1681 := &pb.Abstraction{Vars: listConcat(bindings889[0].([]*pb.Binding), bindings889[1].([]*pb.Binding)), Value: formula890} - _t1682 := &pb.Exists{Body: _t1681} - result892 := _t1682 - p.recordSpan(int(span_start891), "Exists") - return result892 -} - -func (p *Parser) parse_reduce() *pb.Reduce { - span_start896 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("reduce") - _t1683 := p.parse_abstraction() - abstraction893 := _t1683 - _t1684 := p.parse_abstraction() - abstraction_3894 := _t1684 - _t1685 := p.parse_terms() - terms895 := _t1685 - p.consumeLiteral(")") - _t1686 := &pb.Reduce{Op: abstraction893, Body: abstraction_3894, Terms: terms895} - result897 := _t1686 - p.recordSpan(int(span_start896), "Reduce") - return result897 ->>>>>>> origin/main -} - -func (p *Parser) parse_terms() []*pb.Term { - p.consumeLiteral("(") - p.consumeLiteral("terms") -<<<<<<< HEAD - xs864 := []*pb.Term{} - cond865 := (((((((((((((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 cond865 { - _t1619 := p.parse_term() - item866 := _t1619 - xs864 = append(xs864, item866) - cond865 = (((((((((((((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)) - } - terms867 := xs864 - p.consumeLiteral(")") - return terms867 -} - -func (p *Parser) parse_term() *pb.Term { - span_start871 := int64(p.spanStart()) - var _t1620 int64 - if p.matchLookaheadLiteral("true", 0) { - _t1620 = 1 - } else { - var _t1621 int64 - if p.matchLookaheadLiteral("missing", 0) { - _t1621 = 1 - } else { - var _t1622 int64 - if p.matchLookaheadLiteral("false", 0) { - _t1622 = 1 - } else { - var _t1623 int64 - if p.matchLookaheadLiteral("(", 0) { - _t1623 = 1 - } else { - var _t1624 int64 - if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1624 = 0 - } else { - var _t1625 int64 - if p.matchLookaheadTerminal("UINT32", 0) { - _t1625 = 1 - } else { - var _t1626 int64 - if p.matchLookaheadTerminal("UINT128", 0) { - _t1626 = 1 - } else { - var _t1627 int64 - if p.matchLookaheadTerminal("STRING", 0) { - _t1627 = 1 - } else { - var _t1628 int64 - if p.matchLookaheadTerminal("INT32", 0) { - _t1628 = 1 - } else { - var _t1629 int64 - if p.matchLookaheadTerminal("INT128", 0) { - _t1629 = 1 - } else { - var _t1630 int64 - if p.matchLookaheadTerminal("INT", 0) { - _t1630 = 1 - } else { - var _t1631 int64 - if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1631 = 1 - } else { - var _t1632 int64 - if p.matchLookaheadTerminal("FLOAT", 0) { - _t1632 = 1 - } else { - var _t1633 int64 - if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1633 = 1 - } else { - _t1633 = -1 - } - _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 - } - prediction868 := _t1620 - var _t1634 *pb.Term - if prediction868 == 1 { - _t1635 := p.parse_value() - value870 := _t1635 - _t1636 := &pb.Term{} - _t1636.TermType = &pb.Term_Constant{Constant: value870} - _t1634 = _t1636 - } else { - var _t1637 *pb.Term - if prediction868 == 0 { - _t1638 := p.parse_var() - var869 := _t1638 - _t1639 := &pb.Term{} - _t1639.TermType = &pb.Term_Var{Var: var869} - _t1637 = _t1639 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1634 = _t1637 - } - result872 := _t1634 - p.recordSpan(int(span_start871), "Term") - return result872 -======= - xs898 := []*pb.Term{} - cond899 := (((((((((((((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 cond899 { - _t1687 := p.parse_term() - item900 := _t1687 - xs898 = append(xs898, item900) - cond899 = (((((((((((((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)) - } - terms901 := xs898 - p.consumeLiteral(")") - return terms901 +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 + p.consumeLiteral(")") + return terms904 } func (p *Parser) parse_term() *pb.Term { - span_start905 := int64(p.spanStart()) - var _t1688 int64 + span_start908 := int64(p.spanStart()) + var _t1694 int64 if p.matchLookaheadLiteral("true", 0) { - _t1688 = 1 + _t1694 = 1 } else { - var _t1689 int64 + var _t1695 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1689 = 1 + _t1695 = 1 } else { - var _t1690 int64 + var _t1696 int64 if p.matchLookaheadLiteral("false", 0) { - _t1690 = 1 + _t1696 = 1 } else { - var _t1691 int64 + var _t1697 int64 if p.matchLookaheadLiteral("(", 0) { - _t1691 = 1 + _t1697 = 1 } else { - var _t1692 int64 + var _t1698 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1692 = 0 + _t1698 = 0 } else { - var _t1693 int64 + var _t1699 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1693 = 1 + _t1699 = 1 } else { - var _t1694 int64 + var _t1700 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1694 = 1 + _t1700 = 1 } else { - var _t1695 int64 + var _t1701 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1695 = 1 + _t1701 = 1 } else { - var _t1696 int64 + var _t1702 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1696 = 1 + _t1702 = 1 } else { - var _t1697 int64 + var _t1703 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1697 = 1 + _t1703 = 1 } else { - var _t1698 int64 + var _t1704 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1698 = 1 + _t1704 = 1 } else { - var _t1699 int64 + var _t1705 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1699 = 1 + _t1705 = 1 } else { - var _t1700 int64 + var _t1706 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1700 = 1 + _t1706 = 1 } else { - var _t1701 int64 + var _t1707 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1701 = 1 + _t1707 = 1 } else { - _t1701 = -1 + _t1707 = -1 } - _t1700 = _t1701 + _t1706 = _t1707 } - _t1699 = _t1700 + _t1705 = _t1706 } - _t1698 = _t1699 + _t1704 = _t1705 } - _t1697 = _t1698 + _t1703 = _t1704 } - _t1696 = _t1697 + _t1702 = _t1703 } - _t1695 = _t1696 + _t1701 = _t1702 } - _t1694 = _t1695 + _t1700 = _t1701 } - _t1693 = _t1694 + _t1699 = _t1700 } - _t1692 = _t1693 + _t1698 = _t1699 } - _t1691 = _t1692 + _t1697 = _t1698 } - _t1690 = _t1691 + _t1696 = _t1697 } - _t1689 = _t1690 + _t1695 = _t1696 } - _t1688 = _t1689 - } - prediction902 := _t1688 - var _t1702 *pb.Term - if prediction902 == 1 { - _t1703 := p.parse_value() - value904 := _t1703 - _t1704 := &pb.Term{} - _t1704.TermType = &pb.Term_Constant{Constant: value904} - _t1702 = _t1704 + _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 } else { - var _t1705 *pb.Term - if prediction902 == 0 { - _t1706 := p.parse_var() - var903 := _t1706 - _t1707 := &pb.Term{} - _t1707.TermType = &pb.Term_Var{Var: var903} - _t1705 = _t1707 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1702 = _t1705 + _t1708 = _t1711 } - result906 := _t1702 - p.recordSpan(int(span_start905), "Term") - return result906 -} - -func (p *Parser) parse_var() *pb.Var { - span_start908 := int64(p.spanStart()) - symbol907 := p.consumeTerminal("SYMBOL").Value.str - _t1708 := &pb.Var{Name: symbol907} result909 := _t1708 - p.recordSpan(int(span_start908), "Var") + p.recordSpan(int(span_start908), "Term") return result909 ->>>>>>> origin/main } func (p *Parser) parse_var() *pb.Var { - span_start874 := int64(p.spanStart()) - symbol873 := p.consumeTerminal("SYMBOL").Value.str - _t1640 := &pb.Var{Name: symbol873} - result875 := _t1640 - p.recordSpan(int(span_start874), "Var") - return result875 + 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 } func (p *Parser) parse_value() *pb.Value { -<<<<<<< HEAD - span_start889 := int64(p.spanStart()) - var _t1641 int64 - if p.matchLookaheadLiteral("true", 0) { - _t1641 = 12 - } else { - var _t1642 int64 - if p.matchLookaheadLiteral("missing", 0) { - _t1642 = 11 - } else { - var _t1643 int64 - if p.matchLookaheadLiteral("false", 0) { - _t1643 = 12 - } else { - var _t1644 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1645 int64 - if p.matchLookaheadLiteral("datetime", 1) { - _t1645 = 1 - } else { - var _t1646 int64 - if p.matchLookaheadLiteral("date", 1) { - _t1646 = 0 - } else { - _t1646 = -1 - } - _t1645 = _t1646 - } - _t1644 = _t1645 - } else { - var _t1647 int64 - if p.matchLookaheadTerminal("UINT32", 0) { - _t1647 = 7 - } else { - var _t1648 int64 - if p.matchLookaheadTerminal("UINT128", 0) { - _t1648 = 8 - } else { - var _t1649 int64 - if p.matchLookaheadTerminal("STRING", 0) { - _t1649 = 2 - } else { - var _t1650 int64 - if p.matchLookaheadTerminal("INT32", 0) { - _t1650 = 3 - } else { - var _t1651 int64 - if p.matchLookaheadTerminal("INT128", 0) { - _t1651 = 9 - } else { - var _t1652 int64 - if p.matchLookaheadTerminal("INT", 0) { - _t1652 = 4 - } else { - var _t1653 int64 - if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1653 = 5 - } else { - var _t1654 int64 - if p.matchLookaheadTerminal("FLOAT", 0) { - _t1654 = 6 - } else { - var _t1655 int64 - if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1655 = 10 - } else { - _t1655 = -1 - } - _t1654 = _t1655 - } - _t1653 = _t1654 - } - _t1652 = _t1653 - } - _t1651 = _t1652 - } - _t1650 = _t1651 - } - _t1649 = _t1650 - } - _t1648 = _t1649 - } - _t1647 = _t1648 - } - _t1644 = _t1647 - } - _t1643 = _t1644 - } - _t1642 = _t1643 - } - _t1641 = _t1642 - } - prediction876 := _t1641 - var _t1656 *pb.Value - if prediction876 == 12 { - _t1657 := p.parse_boolean_value() - boolean_value888 := _t1657 - _t1658 := &pb.Value{} - _t1658.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value888} - _t1656 = _t1658 - } else { - var _t1659 *pb.Value - if prediction876 == 11 { - p.consumeLiteral("missing") - _t1660 := &pb.MissingValue{} - _t1661 := &pb.Value{} - _t1661.Value = &pb.Value_MissingValue{MissingValue: _t1660} - _t1659 = _t1661 - } else { - var _t1662 *pb.Value - if prediction876 == 10 { - formatted_decimal887 := p.consumeTerminal("DECIMAL").Value.decimal - _t1663 := &pb.Value{} - _t1663.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal887} - _t1662 = _t1663 - } else { - var _t1664 *pb.Value - if prediction876 == 9 { - formatted_int128886 := p.consumeTerminal("INT128").Value.int128 - _t1665 := &pb.Value{} - _t1665.Value = &pb.Value_Int128Value{Int128Value: formatted_int128886} - _t1664 = _t1665 - } else { - var _t1666 *pb.Value - if prediction876 == 8 { - formatted_uint128885 := p.consumeTerminal("UINT128").Value.uint128 - _t1667 := &pb.Value{} - _t1667.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128885} - _t1666 = _t1667 - } else { - var _t1668 *pb.Value - if prediction876 == 7 { - formatted_uint32884 := p.consumeTerminal("UINT32").Value.u32 - _t1669 := &pb.Value{} - _t1669.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32884} - _t1668 = _t1669 - } else { - var _t1670 *pb.Value - if prediction876 == 6 { - formatted_float883 := p.consumeTerminal("FLOAT").Value.f64 - _t1671 := &pb.Value{} - _t1671.Value = &pb.Value_FloatValue{FloatValue: formatted_float883} - _t1670 = _t1671 - } else { - var _t1672 *pb.Value - if prediction876 == 5 { - formatted_float32882 := p.consumeTerminal("FLOAT32").Value.f32 - _t1673 := &pb.Value{} - _t1673.Value = &pb.Value_Float32Value{Float32Value: formatted_float32882} - _t1672 = _t1673 - } else { - var _t1674 *pb.Value - if prediction876 == 4 { - formatted_int881 := p.consumeTerminal("INT").Value.i64 - _t1675 := &pb.Value{} - _t1675.Value = &pb.Value_IntValue{IntValue: formatted_int881} - _t1674 = _t1675 - } else { - var _t1676 *pb.Value - if prediction876 == 3 { - formatted_int32880 := p.consumeTerminal("INT32").Value.i32 - _t1677 := &pb.Value{} - _t1677.Value = &pb.Value_Int32Value{Int32Value: formatted_int32880} - _t1676 = _t1677 - } else { - var _t1678 *pb.Value - if prediction876 == 2 { - formatted_string879 := p.consumeTerminal("STRING").Value.str - _t1679 := &pb.Value{} - _t1679.Value = &pb.Value_StringValue{StringValue: formatted_string879} - _t1678 = _t1679 - } else { - var _t1680 *pb.Value - if prediction876 == 1 { - _t1681 := p.parse_datetime() - datetime878 := _t1681 - _t1682 := &pb.Value{} - _t1682.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime878} - _t1680 = _t1682 - } else { - var _t1683 *pb.Value - if prediction876 == 0 { - _t1684 := p.parse_date() - date877 := _t1684 - _t1685 := &pb.Value{} - _t1685.Value = &pb.Value_DateValue{DateValue: date877} - _t1683 = _t1685 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1680 = _t1683 - } - _t1678 = _t1680 - } - _t1676 = _t1678 - } - _t1674 = _t1676 - } - _t1672 = _t1674 - } - _t1670 = _t1672 - } - _t1668 = _t1670 - } - _t1666 = _t1668 - } - _t1664 = _t1666 - } - _t1662 = _t1664 - } - _t1659 = _t1662 - } - _t1656 = _t1659 - } - result890 := _t1656 - p.recordSpan(int(span_start889), "Value") - return result890 -} - -func (p *Parser) parse_date() *pb.DateValue { - span_start894 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("date") - formatted_int891 := p.consumeTerminal("INT").Value.i64 - formatted_int_3892 := p.consumeTerminal("INT").Value.i64 - formatted_int_4893 := p.consumeTerminal("INT").Value.i64 - p.consumeLiteral(")") - _t1686 := &pb.DateValue{Year: int32(formatted_int891), Month: int32(formatted_int_3892), Day: int32(formatted_int_4893)} - result895 := _t1686 - p.recordSpan(int(span_start894), "DateValue") - return result895 -} - -func (p *Parser) parse_datetime() *pb.DateTimeValue { - span_start903 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("datetime") - formatted_int896 := p.consumeTerminal("INT").Value.i64 - formatted_int_3897 := p.consumeTerminal("INT").Value.i64 - formatted_int_4898 := p.consumeTerminal("INT").Value.i64 - formatted_int_5899 := p.consumeTerminal("INT").Value.i64 - formatted_int_6900 := p.consumeTerminal("INT").Value.i64 - formatted_int_7901 := p.consumeTerminal("INT").Value.i64 - var _t1687 *int64 - if p.matchLookaheadTerminal("INT", 0) { - _t1687 = ptr(p.consumeTerminal("INT").Value.i64) - } - formatted_int_8902 := _t1687 - p.consumeLiteral(")") - _t1688 := &pb.DateTimeValue{Year: int32(formatted_int896), Month: int32(formatted_int_3897), Day: int32(formatted_int_4898), Hour: int32(formatted_int_5899), Minute: int32(formatted_int_6900), Second: int32(formatted_int_7901), Microsecond: int32(deref(formatted_int_8902, 0))} - result904 := _t1688 - p.recordSpan(int(span_start903), "DateTimeValue") - return result904 -} - -func (p *Parser) parse_conjunction() *pb.Conjunction { - span_start909 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("and") - xs905 := []*pb.Formula{} - cond906 := p.matchLookaheadLiteral("(", 0) - for cond906 { - _t1689 := p.parse_formula() - item907 := _t1689 - xs905 = append(xs905, item907) - cond906 = p.matchLookaheadLiteral("(", 0) - } - formulas908 := xs905 - p.consumeLiteral(")") - _t1690 := &pb.Conjunction{Args: formulas908} - result910 := _t1690 - p.recordSpan(int(span_start909), "Conjunction") - return result910 -} - -func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start915 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("or") - xs911 := []*pb.Formula{} - cond912 := p.matchLookaheadLiteral("(", 0) - for cond912 { - _t1691 := p.parse_formula() - item913 := _t1691 - xs911 = append(xs911, item913) - cond912 = p.matchLookaheadLiteral("(", 0) - } - formulas914 := xs911 - p.consumeLiteral(")") - _t1692 := &pb.Disjunction{Args: formulas914} - result916 := _t1692 - p.recordSpan(int(span_start915), "Disjunction") - return result916 -======= - span_start923 := int64(p.spanStart()) - var _t1709 int64 + span_start926 := int64(p.spanStart()) + var _t1715 int64 if p.matchLookaheadLiteral("true", 0) { - _t1709 = 12 + _t1715 = 12 } else { - var _t1710 int64 + var _t1716 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1710 = 11 + _t1716 = 11 } else { - var _t1711 int64 + var _t1717 int64 if p.matchLookaheadLiteral("false", 0) { - _t1711 = 12 + _t1717 = 12 } else { - var _t1712 int64 + var _t1718 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1713 int64 + var _t1719 int64 if p.matchLookaheadLiteral("datetime", 1) { - _t1713 = 1 + _t1719 = 1 } else { - var _t1714 int64 + var _t1720 int64 if p.matchLookaheadLiteral("date", 1) { - _t1714 = 0 + _t1720 = 0 } else { - _t1714 = -1 + _t1720 = -1 } - _t1713 = _t1714 + _t1719 = _t1720 } - _t1712 = _t1713 + _t1718 = _t1719 } else { - var _t1715 int64 + var _t1721 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1715 = 7 + _t1721 = 7 } else { - var _t1716 int64 + var _t1722 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1716 = 8 + _t1722 = 8 } else { - var _t1717 int64 + var _t1723 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1717 = 2 + _t1723 = 2 } else { - var _t1718 int64 + var _t1724 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1718 = 3 + _t1724 = 3 } else { - var _t1719 int64 + var _t1725 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1719 = 9 + _t1725 = 9 } else { - var _t1720 int64 + var _t1726 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1720 = 4 + _t1726 = 4 } else { - var _t1721 int64 + var _t1727 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1721 = 5 + _t1727 = 5 } else { - var _t1722 int64 + var _t1728 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1722 = 6 + _t1728 = 6 } else { - var _t1723 int64 + var _t1729 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1723 = 10 + _t1729 = 10 } else { - _t1723 = -1 + _t1729 = -1 } - _t1722 = _t1723 + _t1728 = _t1729 } - _t1721 = _t1722 + _t1727 = _t1728 } - _t1720 = _t1721 + _t1726 = _t1727 } - _t1719 = _t1720 + _t1725 = _t1726 } - _t1718 = _t1719 + _t1724 = _t1725 } - _t1717 = _t1718 + _t1723 = _t1724 } - _t1716 = _t1717 + _t1722 = _t1723 } - _t1715 = _t1716 + _t1721 = _t1722 } - _t1712 = _t1715 + _t1718 = _t1721 } - _t1711 = _t1712 + _t1717 = _t1718 } - _t1710 = _t1711 + _t1716 = _t1717 } - _t1709 = _t1710 - } - prediction910 := _t1709 - var _t1724 *pb.Value - if prediction910 == 12 { - _t1725 := p.parse_boolean_value() - boolean_value922 := _t1725 - _t1726 := &pb.Value{} - _t1726.Value = &pb.Value_BooleanValue{BooleanValue: boolean_value922} - _t1724 = _t1726 + _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 } else { - var _t1727 *pb.Value - if prediction910 == 11 { + var _t1733 *pb.Value + if prediction913 == 11 { p.consumeLiteral("missing") - _t1728 := &pb.MissingValue{} - _t1729 := &pb.Value{} - _t1729.Value = &pb.Value_MissingValue{MissingValue: _t1728} - _t1727 = _t1729 + _t1734 := &pb.MissingValue{} + _t1735 := &pb.Value{} + _t1735.Value = &pb.Value_MissingValue{MissingValue: _t1734} + _t1733 = _t1735 } else { - var _t1730 *pb.Value - if prediction910 == 10 { - formatted_decimal921 := p.consumeTerminal("DECIMAL").Value.decimal - _t1731 := &pb.Value{} - _t1731.Value = &pb.Value_DecimalValue{DecimalValue: formatted_decimal921} - _t1730 = _t1731 + 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 } else { - var _t1732 *pb.Value - if prediction910 == 9 { - formatted_int128920 := p.consumeTerminal("INT128").Value.int128 - _t1733 := &pb.Value{} - _t1733.Value = &pb.Value_Int128Value{Int128Value: formatted_int128920} - _t1732 = _t1733 + 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 } else { - var _t1734 *pb.Value - if prediction910 == 8 { - formatted_uint128919 := p.consumeTerminal("UINT128").Value.uint128 - _t1735 := &pb.Value{} - _t1735.Value = &pb.Value_Uint128Value{Uint128Value: formatted_uint128919} - _t1734 = _t1735 + 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 } else { - var _t1736 *pb.Value - if prediction910 == 7 { - formatted_uint32918 := p.consumeTerminal("UINT32").Value.u32 - _t1737 := &pb.Value{} - _t1737.Value = &pb.Value_Uint32Value{Uint32Value: formatted_uint32918} - _t1736 = _t1737 + 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 } else { - var _t1738 *pb.Value - if prediction910 == 6 { - formatted_float917 := p.consumeTerminal("FLOAT").Value.f64 - _t1739 := &pb.Value{} - _t1739.Value = &pb.Value_FloatValue{FloatValue: formatted_float917} - _t1738 = _t1739 + 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 } else { - var _t1740 *pb.Value - if prediction910 == 5 { - formatted_float32916 := p.consumeTerminal("FLOAT32").Value.f32 - _t1741 := &pb.Value{} - _t1741.Value = &pb.Value_Float32Value{Float32Value: formatted_float32916} - _t1740 = _t1741 + 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 } else { - var _t1742 *pb.Value - if prediction910 == 4 { - formatted_int915 := p.consumeTerminal("INT").Value.i64 - _t1743 := &pb.Value{} - _t1743.Value = &pb.Value_IntValue{IntValue: formatted_int915} - _t1742 = _t1743 + 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 } else { - var _t1744 *pb.Value - if prediction910 == 3 { - formatted_int32914 := p.consumeTerminal("INT32").Value.i32 - _t1745 := &pb.Value{} - _t1745.Value = &pb.Value_Int32Value{Int32Value: formatted_int32914} - _t1744 = _t1745 + 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 } else { - var _t1746 *pb.Value - if prediction910 == 2 { - formatted_string913 := p.consumeTerminal("STRING").Value.str - _t1747 := &pb.Value{} - _t1747.Value = &pb.Value_StringValue{StringValue: formatted_string913} - _t1746 = _t1747 + 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 } else { - var _t1748 *pb.Value - if prediction910 == 1 { - _t1749 := p.parse_datetime() - datetime912 := _t1749 - _t1750 := &pb.Value{} - _t1750.Value = &pb.Value_DatetimeValue{DatetimeValue: datetime912} - _t1748 = _t1750 + 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 } else { - var _t1751 *pb.Value - if prediction910 == 0 { - _t1752 := p.parse_date() - date911 := _t1752 - _t1753 := &pb.Value{} - _t1753.Value = &pb.Value_DateValue{DateValue: date911} - _t1751 = _t1753 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in value", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1748 = _t1751 + _t1754 = _t1757 } - _t1746 = _t1748 - } - _t1744 = _t1746 - } - _t1742 = _t1744 - } - _t1740 = _t1742 - } - _t1738 = _t1740 - } - _t1736 = _t1738 - } - _t1734 = _t1736 - } - _t1732 = _t1734 - } - _t1730 = _t1732 - } - _t1727 = _t1730 - } - _t1724 = _t1727 - } - result924 := _t1724 - p.recordSpan(int(span_start923), "Value") - return result924 -} - -func (p *Parser) parse_date() *pb.DateValue { - span_start928 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("date") - formatted_int925 := p.consumeTerminal("INT").Value.i64 - formatted_int_3926 := p.consumeTerminal("INT").Value.i64 - formatted_int_4927 := p.consumeTerminal("INT").Value.i64 - p.consumeLiteral(")") - _t1754 := &pb.DateValue{Year: int32(formatted_int925), Month: int32(formatted_int_3926), Day: int32(formatted_int_4927)} - result929 := _t1754 - p.recordSpan(int(span_start928), "DateValue") - return result929 -} - -func (p *Parser) parse_datetime() *pb.DateTimeValue { - span_start937 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("datetime") - formatted_int930 := p.consumeTerminal("INT").Value.i64 - formatted_int_3931 := p.consumeTerminal("INT").Value.i64 - formatted_int_4932 := p.consumeTerminal("INT").Value.i64 - formatted_int_5933 := p.consumeTerminal("INT").Value.i64 - formatted_int_6934 := p.consumeTerminal("INT").Value.i64 - formatted_int_7935 := p.consumeTerminal("INT").Value.i64 - var _t1755 *int64 - if p.matchLookaheadTerminal("INT", 0) { - _t1755 = ptr(p.consumeTerminal("INT").Value.i64) - } - formatted_int_8936 := _t1755 - p.consumeLiteral(")") - _t1756 := &pb.DateTimeValue{Year: int32(formatted_int930), Month: int32(formatted_int_3931), Day: int32(formatted_int_4932), Hour: int32(formatted_int_5933), Minute: int32(formatted_int_6934), Second: int32(formatted_int_7935), Microsecond: int32(deref(formatted_int_8936, 0))} - result938 := _t1756 - p.recordSpan(int(span_start937), "DateTimeValue") - return result938 -} - -func (p *Parser) parse_conjunction() *pb.Conjunction { - span_start943 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("and") - xs939 := []*pb.Formula{} - cond940 := p.matchLookaheadLiteral("(", 0) - for cond940 { - _t1757 := p.parse_formula() - item941 := _t1757 - xs939 = append(xs939, item941) - cond940 = p.matchLookaheadLiteral("(", 0) - } - formulas942 := xs939 - p.consumeLiteral(")") - _t1758 := &pb.Conjunction{Args: formulas942} - result944 := _t1758 - p.recordSpan(int(span_start943), "Conjunction") - return result944 -} - -func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start949 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("or") - xs945 := []*pb.Formula{} - cond946 := p.matchLookaheadLiteral("(", 0) - for cond946 { - _t1759 := p.parse_formula() - item947 := _t1759 - xs945 = append(xs945, item947) - cond946 = p.matchLookaheadLiteral("(", 0) - } - formulas948 := xs945 - p.consumeLiteral(")") - _t1760 := &pb.Disjunction{Args: formulas948} - result950 := _t1760 - p.recordSpan(int(span_start949), "Disjunction") - return result950 -} - -func (p *Parser) parse_not() *pb.Not { - span_start952 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("not") - _t1761 := p.parse_formula() - formula951 := _t1761 - p.consumeLiteral(")") - _t1762 := &pb.Not{Arg: formula951} - result953 := _t1762 - p.recordSpan(int(span_start952), "Not") - return result953 ->>>>>>> origin/main -} - -func (p *Parser) parse_not() *pb.Not { - span_start918 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("not") - _t1693 := p.parse_formula() - formula917 := _t1693 - p.consumeLiteral(")") - _t1694 := &pb.Not{Arg: formula917} - result919 := _t1694 - p.recordSpan(int(span_start918), "Not") - return result919 -} - -func (p *Parser) parse_ffi() *pb.FFI { -<<<<<<< HEAD - span_start923 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("ffi") - _t1695 := p.parse_name() - name920 := _t1695 - _t1696 := p.parse_ffi_args() - ffi_args921 := _t1696 - _t1697 := p.parse_terms() - terms922 := _t1697 - p.consumeLiteral(")") - _t1698 := &pb.FFI{Name: name920, Args: ffi_args921, Terms: terms922} - result924 := _t1698 - p.recordSpan(int(span_start923), "FFI") - return result924 -======= - span_start957 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("ffi") - _t1763 := p.parse_name() - name954 := _t1763 - _t1764 := p.parse_ffi_args() - ffi_args955 := _t1764 - _t1765 := p.parse_terms() - terms956 := _t1765 - p.consumeLiteral(")") - _t1766 := &pb.FFI{Name: name954, Args: ffi_args955, Terms: terms956} - result958 := _t1766 - p.recordSpan(int(span_start957), "FFI") - return result958 ->>>>>>> origin/main -} - -func (p *Parser) parse_name() string { - p.consumeLiteral(":") -<<<<<<< HEAD - symbol925 := p.consumeTerminal("SYMBOL").Value.str - return symbol925 -======= - symbol959 := p.consumeTerminal("SYMBOL").Value.str - return symbol959 ->>>>>>> origin/main -} - -func (p *Parser) parse_ffi_args() []*pb.Abstraction { - p.consumeLiteral("(") - p.consumeLiteral("args") -<<<<<<< HEAD - xs926 := []*pb.Abstraction{} - cond927 := p.matchLookaheadLiteral("(", 0) - for cond927 { - _t1699 := p.parse_abstraction() - item928 := _t1699 - xs926 = append(xs926, item928) - cond927 = p.matchLookaheadLiteral("(", 0) - } - abstractions929 := xs926 - p.consumeLiteral(")") - return abstractions929 -} - -func (p *Parser) parse_atom() *pb.Atom { - span_start935 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("atom") - _t1700 := p.parse_relation_id() - relation_id930 := _t1700 - xs931 := []*pb.Term{} - cond932 := (((((((((((((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 cond932 { - _t1701 := p.parse_term() - item933 := _t1701 - xs931 = append(xs931, item933) - cond932 = (((((((((((((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)) - } - terms934 := xs931 - p.consumeLiteral(")") - _t1702 := &pb.Atom{Name: relation_id930, Terms: terms934} - result936 := _t1702 - p.recordSpan(int(span_start935), "Atom") - return result936 -} - -func (p *Parser) parse_pragma() *pb.Pragma { - span_start942 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("pragma") - _t1703 := p.parse_name() - name937 := _t1703 - xs938 := []*pb.Term{} - cond939 := (((((((((((((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 cond939 { - _t1704 := p.parse_term() - item940 := _t1704 - xs938 = append(xs938, item940) - cond939 = (((((((((((((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)) - } - terms941 := xs938 - p.consumeLiteral(")") - _t1705 := &pb.Pragma{Name: name937, Terms: terms941} - result943 := _t1705 - p.recordSpan(int(span_start942), "Pragma") - return result943 -} - -func (p *Parser) parse_primitive() *pb.Primitive { - span_start959 := int64(p.spanStart()) - var _t1706 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1707 int64 - if p.matchLookaheadLiteral("primitive", 1) { - _t1707 = 9 - } else { - var _t1708 int64 - if p.matchLookaheadLiteral(">=", 1) { - _t1708 = 4 - } else { - var _t1709 int64 - if p.matchLookaheadLiteral(">", 1) { - _t1709 = 3 - } else { - var _t1710 int64 - if p.matchLookaheadLiteral("=", 1) { - _t1710 = 0 - } else { - var _t1711 int64 - if p.matchLookaheadLiteral("<=", 1) { - _t1711 = 2 - } else { - var _t1712 int64 - if p.matchLookaheadLiteral("<", 1) { - _t1712 = 1 - } else { - var _t1713 int64 - if p.matchLookaheadLiteral("/", 1) { - _t1713 = 8 - } else { - var _t1714 int64 - if p.matchLookaheadLiteral("-", 1) { - _t1714 = 6 - } else { - var _t1715 int64 - if p.matchLookaheadLiteral("+", 1) { - _t1715 = 5 - } else { - var _t1716 int64 - if p.matchLookaheadLiteral("*", 1) { - _t1716 = 7 - } else { - _t1716 = -1 + _t1752 = _t1754 } - _t1715 = _t1716 - } - _t1714 = _t1715 - } - _t1713 = _t1714 - } - _t1712 = _t1713 - } - _t1711 = _t1712 - } - _t1710 = _t1711 - } - _t1709 = _t1710 - } - _t1708 = _t1709 - } - _t1707 = _t1708 - } - _t1706 = _t1707 - } else { - _t1706 = -1 - } - prediction944 := _t1706 - var _t1717 *pb.Primitive - if prediction944 == 9 { - p.consumeLiteral("(") - p.consumeLiteral("primitive") - _t1718 := p.parse_name() - name954 := _t1718 - xs955 := []*pb.RelTerm{} - cond956 := ((((((((((((((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 cond956 { - _t1719 := p.parse_rel_term() - item957 := _t1719 - xs955 = append(xs955, item957) - cond956 = ((((((((((((((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_terms958 := xs955 - p.consumeLiteral(")") - _t1720 := &pb.Primitive{Name: name954, Terms: rel_terms958} - _t1717 = _t1720 - } else { - var _t1721 *pb.Primitive - if prediction944 == 8 { - _t1722 := p.parse_divide() - divide953 := _t1722 - _t1721 = divide953 - } else { - var _t1723 *pb.Primitive - if prediction944 == 7 { - _t1724 := p.parse_multiply() - multiply952 := _t1724 - _t1723 = multiply952 - } else { - var _t1725 *pb.Primitive - if prediction944 == 6 { - _t1726 := p.parse_minus() - minus951 := _t1726 - _t1725 = minus951 - } else { - var _t1727 *pb.Primitive - if prediction944 == 5 { - _t1728 := p.parse_add() - add950 := _t1728 - _t1727 = add950 - } else { - var _t1729 *pb.Primitive - if prediction944 == 4 { - _t1730 := p.parse_gt_eq() - gt_eq949 := _t1730 - _t1729 = gt_eq949 - } else { - var _t1731 *pb.Primitive - if prediction944 == 3 { - _t1732 := p.parse_gt() - gt948 := _t1732 - _t1731 = gt948 - } else { - var _t1733 *pb.Primitive - if prediction944 == 2 { - _t1734 := p.parse_lt_eq() - lt_eq947 := _t1734 - _t1733 = lt_eq947 - } else { - var _t1735 *pb.Primitive - if prediction944 == 1 { - _t1736 := p.parse_lt() - lt946 := _t1736 - _t1735 = lt946 - } else { - var _t1737 *pb.Primitive - if prediction944 == 0 { - _t1738 := p.parse_eq() - eq945 := _t1738 - _t1737 = eq945 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) + _t1750 = _t1752 } - _t1735 = _t1737 + _t1748 = _t1750 } - _t1733 = _t1735 + _t1746 = _t1748 } - _t1731 = _t1733 + _t1744 = _t1746 } - _t1729 = _t1731 + _t1742 = _t1744 } - _t1727 = _t1729 + _t1740 = _t1742 } - _t1725 = _t1727 + _t1738 = _t1740 } - _t1723 = _t1725 + _t1736 = _t1738 } - _t1721 = _t1723 + _t1733 = _t1736 } - _t1717 = _t1721 - } - result960 := _t1717 - p.recordSpan(int(span_start959), "Primitive") - return result960 -} - -func (p *Parser) parse_eq() *pb.Primitive { - span_start963 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("=") - _t1739 := p.parse_term() - term961 := _t1739 - _t1740 := p.parse_term() - term_3962 := _t1740 - p.consumeLiteral(")") - _t1741 := &pb.RelTerm{} - _t1741.RelTermType = &pb.RelTerm_Term{Term: term961} - _t1742 := &pb.RelTerm{} - _t1742.RelTermType = &pb.RelTerm_Term{Term: term_3962} - _t1743 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1741, _t1742}} - result964 := _t1743 - p.recordSpan(int(span_start963), "Primitive") - return result964 -} - -func (p *Parser) parse_lt() *pb.Primitive { - span_start967 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("<") - _t1744 := p.parse_term() - term965 := _t1744 - _t1745 := p.parse_term() - term_3966 := _t1745 - p.consumeLiteral(")") - _t1746 := &pb.RelTerm{} - _t1746.RelTermType = &pb.RelTerm_Term{Term: term965} - _t1747 := &pb.RelTerm{} - _t1747.RelTermType = &pb.RelTerm_Term{Term: term_3966} - _t1748 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1746, _t1747}} - result968 := _t1748 - p.recordSpan(int(span_start967), "Primitive") - return result968 + _t1730 = _t1733 + } + result927 := _t1730 + p.recordSpan(int(span_start926), "Value") + return result927 } -func (p *Parser) parse_lt_eq() *pb.Primitive { - span_start971 := int64(p.spanStart()) +func (p *Parser) parse_date() *pb.DateValue { + span_start931 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("<=") - _t1749 := p.parse_term() - term969 := _t1749 - _t1750 := p.parse_term() - term_3970 := _t1750 + 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 p.consumeLiteral(")") - _t1751 := &pb.RelTerm{} - _t1751.RelTermType = &pb.RelTerm_Term{Term: term969} - _t1752 := &pb.RelTerm{} - _t1752.RelTermType = &pb.RelTerm_Term{Term: term_3970} - _t1753 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1751, _t1752}} - result972 := _t1753 - p.recordSpan(int(span_start971), "Primitive") - return result972 + _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 } -func (p *Parser) parse_gt() *pb.Primitive { - span_start975 := int64(p.spanStart()) +func (p *Parser) parse_datetime() *pb.DateTimeValue { + span_start940 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral(">") - _t1754 := p.parse_term() - term973 := _t1754 - _t1755 := p.parse_term() - term_3974 := _t1755 + 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 + if p.matchLookaheadTerminal("INT", 0) { + _t1761 = ptr(p.consumeTerminal("INT").Value.i64) + } + formatted_int_8939 := _t1761 p.consumeLiteral(")") - _t1756 := &pb.RelTerm{} - _t1756.RelTermType = &pb.RelTerm_Term{Term: term973} - _t1757 := &pb.RelTerm{} - _t1757.RelTermType = &pb.RelTerm_Term{Term: term_3974} - _t1758 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1756, _t1757}} - result976 := _t1758 - p.recordSpan(int(span_start975), "Primitive") - return result976 + _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 } -func (p *Parser) parse_gt_eq() *pb.Primitive { - span_start979 := int64(p.spanStart()) +func (p *Parser) parse_conjunction() *pb.Conjunction { + span_start946 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral(">=") - _t1759 := p.parse_term() - term977 := _t1759 - _t1760 := p.parse_term() - term_3978 := _t1760 + 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 p.consumeLiteral(")") - _t1761 := &pb.RelTerm{} - _t1761.RelTermType = &pb.RelTerm_Term{Term: term977} - _t1762 := &pb.RelTerm{} - _t1762.RelTermType = &pb.RelTerm_Term{Term: term_3978} - _t1763 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1761, _t1762}} - result980 := _t1763 - p.recordSpan(int(span_start979), "Primitive") - return result980 + _t1764 := &pb.Conjunction{Args: formulas945} + result947 := _t1764 + p.recordSpan(int(span_start946), "Conjunction") + return result947 } -func (p *Parser) parse_add() *pb.Primitive { - span_start984 := int64(p.spanStart()) +func (p *Parser) parse_disjunction() *pb.Disjunction { + span_start952 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("+") - _t1764 := p.parse_term() - term981 := _t1764 - _t1765 := p.parse_term() - term_3982 := _t1765 - _t1766 := p.parse_term() - term_4983 := _t1766 - p.consumeLiteral(")") - _t1767 := &pb.RelTerm{} - _t1767.RelTermType = &pb.RelTerm_Term{Term: term981} - _t1768 := &pb.RelTerm{} - _t1768.RelTermType = &pb.RelTerm_Term{Term: term_3982} - _t1769 := &pb.RelTerm{} - _t1769.RelTermType = &pb.RelTerm_Term{Term: term_4983} - _t1770 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1767, _t1768, _t1769}} - result985 := _t1770 - p.recordSpan(int(span_start984), "Primitive") - return result985 + 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 + p.consumeLiteral(")") + _t1766 := &pb.Disjunction{Args: formulas951} + result953 := _t1766 + p.recordSpan(int(span_start952), "Disjunction") + return result953 } -func (p *Parser) parse_minus() *pb.Primitive { - span_start989 := int64(p.spanStart()) +func (p *Parser) parse_not() *pb.Not { + span_start955 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("-") - _t1771 := p.parse_term() - term986 := _t1771 - _t1772 := p.parse_term() - term_3987 := _t1772 - _t1773 := p.parse_term() - term_4988 := _t1773 + p.consumeLiteral("not") + _t1767 := p.parse_formula() + formula954 := _t1767 p.consumeLiteral(")") - _t1774 := &pb.RelTerm{} - _t1774.RelTermType = &pb.RelTerm_Term{Term: term986} - _t1775 := &pb.RelTerm{} - _t1775.RelTermType = &pb.RelTerm_Term{Term: term_3987} - _t1776 := &pb.RelTerm{} - _t1776.RelTermType = &pb.RelTerm_Term{Term: term_4988} - _t1777 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1774, _t1775, _t1776}} - result990 := _t1777 - p.recordSpan(int(span_start989), "Primitive") - return result990 + _t1768 := &pb.Not{Arg: formula954} + result956 := _t1768 + p.recordSpan(int(span_start955), "Not") + return result956 } -func (p *Parser) parse_multiply() *pb.Primitive { - span_start994 := int64(p.spanStart()) +func (p *Parser) parse_ffi() *pb.FFI { + span_start960 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("*") - _t1778 := p.parse_term() - term991 := _t1778 - _t1779 := p.parse_term() - term_3992 := _t1779 - _t1780 := p.parse_term() - term_4993 := _t1780 + p.consumeLiteral("ffi") + _t1769 := p.parse_name() + name957 := _t1769 + _t1770 := p.parse_ffi_args() + ffi_args958 := _t1770 + _t1771 := p.parse_terms() + terms959 := _t1771 p.consumeLiteral(")") - _t1781 := &pb.RelTerm{} - _t1781.RelTermType = &pb.RelTerm_Term{Term: term991} - _t1782 := &pb.RelTerm{} - _t1782.RelTermType = &pb.RelTerm_Term{Term: term_3992} - _t1783 := &pb.RelTerm{} - _t1783.RelTermType = &pb.RelTerm_Term{Term: term_4993} - _t1784 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1781, _t1782, _t1783}} - result995 := _t1784 - p.recordSpan(int(span_start994), "Primitive") - return result995 + _t1772 := &pb.FFI{Name: name957, Args: ffi_args958, Terms: terms959} + result961 := _t1772 + p.recordSpan(int(span_start960), "FFI") + return result961 } -func (p *Parser) parse_divide() *pb.Primitive { - span_start999 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("/") - _t1785 := p.parse_term() - term996 := _t1785 - _t1786 := p.parse_term() - term_3997 := _t1786 - _t1787 := p.parse_term() - term_4998 := _t1787 - p.consumeLiteral(")") - _t1788 := &pb.RelTerm{} - _t1788.RelTermType = &pb.RelTerm_Term{Term: term996} - _t1789 := &pb.RelTerm{} - _t1789.RelTermType = &pb.RelTerm_Term{Term: term_3997} - _t1790 := &pb.RelTerm{} - _t1790.RelTermType = &pb.RelTerm_Term{Term: term_4998} - _t1791 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1788, _t1789, _t1790}} - result1000 := _t1791 - p.recordSpan(int(span_start999), "Primitive") - return result1000 +func (p *Parser) parse_name() string { + p.consumeLiteral(":") + symbol962 := p.consumeTerminal("SYMBOL").Value.str + return symbol962 } -func (p *Parser) parse_rel_term() *pb.RelTerm { - span_start1004 := int64(p.spanStart()) - var _t1792 int64 - if p.matchLookaheadLiteral("true", 0) { - _t1792 = 1 - } else { - var _t1793 int64 - if p.matchLookaheadLiteral("missing", 0) { - _t1793 = 1 - } else { - var _t1794 int64 - if p.matchLookaheadLiteral("false", 0) { - _t1794 = 1 - } else { - var _t1795 int64 - if p.matchLookaheadLiteral("(", 0) { - _t1795 = 1 - } else { - var _t1796 int64 - if p.matchLookaheadLiteral("#", 0) { - _t1796 = 0 - } else { - var _t1797 int64 - if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1797 = 1 - } else { - var _t1798 int64 - if p.matchLookaheadTerminal("UINT32", 0) { - _t1798 = 1 - } else { - var _t1799 int64 - if p.matchLookaheadTerminal("UINT128", 0) { - _t1799 = 1 - } else { - var _t1800 int64 - if p.matchLookaheadTerminal("STRING", 0) { - _t1800 = 1 - } else { - var _t1801 int64 - if p.matchLookaheadTerminal("INT32", 0) { - _t1801 = 1 - } else { - var _t1802 int64 - if p.matchLookaheadTerminal("INT128", 0) { - _t1802 = 1 - } else { - var _t1803 int64 - if p.matchLookaheadTerminal("INT", 0) { - _t1803 = 1 - } else { - var _t1804 int64 - if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1804 = 1 - } else { - var _t1805 int64 - if p.matchLookaheadTerminal("FLOAT", 0) { - _t1805 = 1 - } else { - var _t1806 int64 - if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1806 = 1 - } else { - _t1806 = -1 - } - _t1805 = _t1806 - } - _t1804 = _t1805 - } - _t1803 = _t1804 - } - _t1802 = _t1803 - } - _t1801 = _t1802 - } - _t1800 = _t1801 - } - _t1799 = _t1800 - } - _t1798 = _t1799 - } - _t1797 = _t1798 - } - _t1796 = _t1797 - } - _t1795 = _t1796 - } - _t1794 = _t1795 - } - _t1793 = _t1794 - } - _t1792 = _t1793 - } - prediction1001 := _t1792 - var _t1807 *pb.RelTerm - if prediction1001 == 1 { - _t1808 := p.parse_term() - term1003 := _t1808 - _t1809 := &pb.RelTerm{} - _t1809.RelTermType = &pb.RelTerm_Term{Term: term1003} - _t1807 = _t1809 - } else { - var _t1810 *pb.RelTerm - if prediction1001 == 0 { - _t1811 := p.parse_specialized_value() - specialized_value1002 := _t1811 - _t1812 := &pb.RelTerm{} - _t1812.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1002} - _t1810 = _t1812 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1807 = _t1810 +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) } - result1005 := _t1807 - p.recordSpan(int(span_start1004), "RelTerm") - return result1005 -======= - xs960 := []*pb.Abstraction{} - cond961 := p.matchLookaheadLiteral("(", 0) - for cond961 { - _t1767 := p.parse_abstraction() - item962 := _t1767 - xs960 = append(xs960, item962) - cond961 = p.matchLookaheadLiteral("(", 0) - } - abstractions963 := xs960 + abstractions966 := xs963 p.consumeLiteral(")") - return abstractions963 + return abstractions966 } func (p *Parser) parse_atom() *pb.Atom { - span_start969 := int64(p.spanStart()) + span_start972 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("atom") - _t1768 := p.parse_relation_id() - relation_id964 := _t1768 - xs965 := []*pb.Term{} - cond966 := (((((((((((((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 cond966 { - _t1769 := p.parse_term() - item967 := _t1769 - xs965 = append(xs965, item967) - cond966 = (((((((((((((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)) - } - terms968 := xs965 + _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 p.consumeLiteral(")") - _t1770 := &pb.Atom{Name: relation_id964, Terms: terms968} - result970 := _t1770 - p.recordSpan(int(span_start969), "Atom") - return result970 + _t1776 := &pb.Atom{Name: relation_id967, Terms: terms971} + result973 := _t1776 + p.recordSpan(int(span_start972), "Atom") + return result973 } func (p *Parser) parse_pragma() *pb.Pragma { - span_start976 := int64(p.spanStart()) + span_start979 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("pragma") - _t1771 := p.parse_name() - name971 := _t1771 - xs972 := []*pb.Term{} - cond973 := (((((((((((((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 cond973 { - _t1772 := p.parse_term() - item974 := _t1772 - xs972 = append(xs972, item974) - cond973 = (((((((((((((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)) - } - terms975 := xs972 - p.consumeLiteral(")") - _t1773 := &pb.Pragma{Name: name971, Terms: terms975} - result977 := _t1773 - p.recordSpan(int(span_start976), "Pragma") - return result977 + _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 + p.consumeLiteral(")") + _t1779 := &pb.Pragma{Name: name974, Terms: terms978} + result980 := _t1779 + p.recordSpan(int(span_start979), "Pragma") + return result980 } func (p *Parser) parse_primitive() *pb.Primitive { - span_start993 := int64(p.spanStart()) - var _t1774 int64 + span_start996 := int64(p.spanStart()) + var _t1780 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1775 int64 + var _t1781 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1775 = 9 + _t1781 = 9 } else { - var _t1776 int64 + var _t1782 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1776 = 4 + _t1782 = 4 } else { - var _t1777 int64 + var _t1783 int64 if p.matchLookaheadLiteral(">", 1) { - _t1777 = 3 + _t1783 = 3 } else { - var _t1778 int64 + var _t1784 int64 if p.matchLookaheadLiteral("=", 1) { - _t1778 = 0 + _t1784 = 0 } else { - var _t1779 int64 + var _t1785 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1779 = 2 + _t1785 = 2 } else { - var _t1780 int64 + var _t1786 int64 if p.matchLookaheadLiteral("<", 1) { - _t1780 = 1 + _t1786 = 1 } else { - var _t1781 int64 + var _t1787 int64 if p.matchLookaheadLiteral("/", 1) { - _t1781 = 8 + _t1787 = 8 } else { - var _t1782 int64 + var _t1788 int64 if p.matchLookaheadLiteral("-", 1) { - _t1782 = 6 + _t1788 = 6 } else { - var _t1783 int64 + var _t1789 int64 if p.matchLookaheadLiteral("+", 1) { - _t1783 = 5 + _t1789 = 5 } else { - var _t1784 int64 + var _t1790 int64 if p.matchLookaheadLiteral("*", 1) { - _t1784 = 7 + _t1790 = 7 } else { - _t1784 = -1 + _t1790 = -1 } - _t1783 = _t1784 + _t1789 = _t1790 } - _t1782 = _t1783 + _t1788 = _t1789 } - _t1781 = _t1782 + _t1787 = _t1788 } - _t1780 = _t1781 + _t1786 = _t1787 } - _t1779 = _t1780 + _t1785 = _t1786 } - _t1778 = _t1779 + _t1784 = _t1785 } - _t1777 = _t1778 + _t1783 = _t1784 } - _t1776 = _t1777 + _t1782 = _t1783 } - _t1775 = _t1776 + _t1781 = _t1782 } - _t1774 = _t1775 + _t1780 = _t1781 } else { - _t1774 = -1 + _t1780 = -1 } - prediction978 := _t1774 - var _t1785 *pb.Primitive - if prediction978 == 9 { + prediction981 := _t1780 + var _t1791 *pb.Primitive + if prediction981 == 9 { p.consumeLiteral("(") p.consumeLiteral("primitive") - _t1786 := p.parse_name() - name988 := _t1786 - xs989 := []*pb.RelTerm{} - cond990 := ((((((((((((((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 cond990 { - _t1787 := p.parse_rel_term() - item991 := _t1787 - xs989 = append(xs989, item991) - cond990 = ((((((((((((((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)) + _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)) } - rel_terms992 := xs989 + rel_terms995 := xs992 p.consumeLiteral(")") - _t1788 := &pb.Primitive{Name: name988, Terms: rel_terms992} - _t1785 = _t1788 + _t1794 := &pb.Primitive{Name: name991, Terms: rel_terms995} + _t1791 = _t1794 } else { - var _t1789 *pb.Primitive - if prediction978 == 8 { - _t1790 := p.parse_divide() - divide987 := _t1790 - _t1789 = divide987 + var _t1795 *pb.Primitive + if prediction981 == 8 { + _t1796 := p.parse_divide() + divide990 := _t1796 + _t1795 = divide990 } else { - var _t1791 *pb.Primitive - if prediction978 == 7 { - _t1792 := p.parse_multiply() - multiply986 := _t1792 - _t1791 = multiply986 + var _t1797 *pb.Primitive + if prediction981 == 7 { + _t1798 := p.parse_multiply() + multiply989 := _t1798 + _t1797 = multiply989 } else { - var _t1793 *pb.Primitive - if prediction978 == 6 { - _t1794 := p.parse_minus() - minus985 := _t1794 - _t1793 = minus985 + var _t1799 *pb.Primitive + if prediction981 == 6 { + _t1800 := p.parse_minus() + minus988 := _t1800 + _t1799 = minus988 } else { - var _t1795 *pb.Primitive - if prediction978 == 5 { - _t1796 := p.parse_add() - add984 := _t1796 - _t1795 = add984 + var _t1801 *pb.Primitive + if prediction981 == 5 { + _t1802 := p.parse_add() + add987 := _t1802 + _t1801 = add987 } else { - var _t1797 *pb.Primitive - if prediction978 == 4 { - _t1798 := p.parse_gt_eq() - gt_eq983 := _t1798 - _t1797 = gt_eq983 + var _t1803 *pb.Primitive + if prediction981 == 4 { + _t1804 := p.parse_gt_eq() + gt_eq986 := _t1804 + _t1803 = gt_eq986 } else { - var _t1799 *pb.Primitive - if prediction978 == 3 { - _t1800 := p.parse_gt() - gt982 := _t1800 - _t1799 = gt982 + var _t1805 *pb.Primitive + if prediction981 == 3 { + _t1806 := p.parse_gt() + gt985 := _t1806 + _t1805 = gt985 } else { - var _t1801 *pb.Primitive - if prediction978 == 2 { - _t1802 := p.parse_lt_eq() - lt_eq981 := _t1802 - _t1801 = lt_eq981 + var _t1807 *pb.Primitive + if prediction981 == 2 { + _t1808 := p.parse_lt_eq() + lt_eq984 := _t1808 + _t1807 = lt_eq984 } else { - var _t1803 *pb.Primitive - if prediction978 == 1 { - _t1804 := p.parse_lt() - lt980 := _t1804 - _t1803 = lt980 + var _t1809 *pb.Primitive + if prediction981 == 1 { + _t1810 := p.parse_lt() + lt983 := _t1810 + _t1809 = lt983 } else { - var _t1805 *pb.Primitive - if prediction978 == 0 { - _t1806 := p.parse_eq() - eq979 := _t1806 - _t1805 = eq979 + var _t1811 *pb.Primitive + if prediction981 == 0 { + _t1812 := p.parse_eq() + eq982 := _t1812 + _t1811 = eq982 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in primitive", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1803 = _t1805 + _t1809 = _t1811 } - _t1801 = _t1803 + _t1807 = _t1809 } - _t1799 = _t1801 + _t1805 = _t1807 } - _t1797 = _t1799 + _t1803 = _t1805 } - _t1795 = _t1797 + _t1801 = _t1803 } - _t1793 = _t1795 + _t1799 = _t1801 } - _t1791 = _t1793 + _t1797 = _t1799 } - _t1789 = _t1791 + _t1795 = _t1797 } - _t1785 = _t1789 + _t1791 = _t1795 } - result994 := _t1785 - p.recordSpan(int(span_start993), "Primitive") - return result994 + result997 := _t1791 + p.recordSpan(int(span_start996), "Primitive") + return result997 } func (p *Parser) parse_eq() *pb.Primitive { - span_start997 := int64(p.spanStart()) + span_start1000 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("=") - _t1807 := p.parse_term() - term995 := _t1807 - _t1808 := p.parse_term() - term_3996 := _t1808 - p.consumeLiteral(")") - _t1809 := &pb.RelTerm{} - _t1809.RelTermType = &pb.RelTerm_Term{Term: term995} - _t1810 := &pb.RelTerm{} - _t1810.RelTermType = &pb.RelTerm_Term{Term: term_3996} - _t1811 := &pb.Primitive{Name: "rel_primitive_eq", Terms: []*pb.RelTerm{_t1809, _t1810}} - result998 := _t1811 - p.recordSpan(int(span_start997), "Primitive") - return result998 -} - -func (p *Parser) parse_lt() *pb.Primitive { - span_start1001 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("<") - _t1812 := p.parse_term() - term999 := _t1812 _t1813 := p.parse_term() - term_31000 := _t1813 + term998 := _t1813 + _t1814 := p.parse_term() + term_3999 := _t1814 p.consumeLiteral(")") - _t1814 := &pb.RelTerm{} - _t1814.RelTermType = &pb.RelTerm_Term{Term: term999} _t1815 := &pb.RelTerm{} - _t1815.RelTermType = &pb.RelTerm_Term{Term: term_31000} - _t1816 := &pb.Primitive{Name: "rel_primitive_lt_monotype", Terms: []*pb.RelTerm{_t1814, _t1815}} - result1002 := _t1816 - p.recordSpan(int(span_start1001), "Primitive") - return result1002 + _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 } -func (p *Parser) parse_lt_eq() *pb.Primitive { - span_start1005 := int64(p.spanStart()) +func (p *Parser) parse_lt() *pb.Primitive { + span_start1004 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("<=") - _t1817 := p.parse_term() - term1003 := _t1817 + p.consumeLiteral("<") _t1818 := p.parse_term() - term_31004 := _t1818 + term1002 := _t1818 + _t1819 := p.parse_term() + term_31003 := _t1819 p.consumeLiteral(")") - _t1819 := &pb.RelTerm{} - _t1819.RelTermType = &pb.RelTerm_Term{Term: term1003} _t1820 := &pb.RelTerm{} - _t1820.RelTermType = &pb.RelTerm_Term{Term: term_31004} - _t1821 := &pb.Primitive{Name: "rel_primitive_lt_eq_monotype", Terms: []*pb.RelTerm{_t1819, _t1820}} - result1006 := _t1821 - p.recordSpan(int(span_start1005), "Primitive") - return result1006 + _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 } -func (p *Parser) parse_gt() *pb.Primitive { - span_start1009 := int64(p.spanStart()) +func (p *Parser) parse_lt_eq() *pb.Primitive { + span_start1008 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral(">") - _t1822 := p.parse_term() - term1007 := _t1822 + p.consumeLiteral("<=") _t1823 := p.parse_term() - term_31008 := _t1823 + term1006 := _t1823 + _t1824 := p.parse_term() + term_31007 := _t1824 p.consumeLiteral(")") - _t1824 := &pb.RelTerm{} - _t1824.RelTermType = &pb.RelTerm_Term{Term: term1007} _t1825 := &pb.RelTerm{} - _t1825.RelTermType = &pb.RelTerm_Term{Term: term_31008} - _t1826 := &pb.Primitive{Name: "rel_primitive_gt_monotype", Terms: []*pb.RelTerm{_t1824, _t1825}} - result1010 := _t1826 - p.recordSpan(int(span_start1009), "Primitive") - return result1010 + _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 } -func (p *Parser) parse_gt_eq() *pb.Primitive { - span_start1013 := int64(p.spanStart()) +func (p *Parser) parse_gt() *pb.Primitive { + span_start1012 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral(">=") - _t1827 := p.parse_term() - term1011 := _t1827 + p.consumeLiteral(">") _t1828 := p.parse_term() - term_31012 := _t1828 + term1010 := _t1828 + _t1829 := p.parse_term() + term_31011 := _t1829 p.consumeLiteral(")") - _t1829 := &pb.RelTerm{} - _t1829.RelTermType = &pb.RelTerm_Term{Term: term1011} _t1830 := &pb.RelTerm{} - _t1830.RelTermType = &pb.RelTerm_Term{Term: term_31012} - _t1831 := &pb.Primitive{Name: "rel_primitive_gt_eq_monotype", Terms: []*pb.RelTerm{_t1829, _t1830}} - result1014 := _t1831 - p.recordSpan(int(span_start1013), "Primitive") - return result1014 + _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 } -func (p *Parser) parse_add() *pb.Primitive { - span_start1018 := int64(p.spanStart()) +func (p *Parser) parse_gt_eq() *pb.Primitive { + span_start1016 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("+") - _t1832 := p.parse_term() - term1015 := _t1832 + p.consumeLiteral(">=") _t1833 := p.parse_term() - term_31016 := _t1833 + term1014 := _t1833 _t1834 := p.parse_term() - term_41017 := _t1834 + term_31015 := _t1834 p.consumeLiteral(")") _t1835 := &pb.RelTerm{} - _t1835.RelTermType = &pb.RelTerm_Term{Term: term1015} + _t1835.RelTermType = &pb.RelTerm_Term{Term: term1014} _t1836 := &pb.RelTerm{} - _t1836.RelTermType = &pb.RelTerm_Term{Term: term_31016} - _t1837 := &pb.RelTerm{} - _t1837.RelTermType = &pb.RelTerm_Term{Term: term_41017} - _t1838 := &pb.Primitive{Name: "rel_primitive_add_monotype", Terms: []*pb.RelTerm{_t1835, _t1836, _t1837}} - result1019 := _t1838 - p.recordSpan(int(span_start1018), "Primitive") - return result1019 + _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 } -func (p *Parser) parse_minus() *pb.Primitive { - span_start1023 := int64(p.spanStart()) +func (p *Parser) parse_add() *pb.Primitive { + span_start1021 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("-") + p.consumeLiteral("+") + _t1838 := p.parse_term() + term1018 := _t1838 _t1839 := p.parse_term() - term1020 := _t1839 + term_31019 := _t1839 _t1840 := p.parse_term() - term_31021 := _t1840 - _t1841 := p.parse_term() - term_41022 := _t1841 + term_41020 := _t1840 p.consumeLiteral(")") + _t1841 := &pb.RelTerm{} + _t1841.RelTermType = &pb.RelTerm_Term{Term: term1018} _t1842 := &pb.RelTerm{} - _t1842.RelTermType = &pb.RelTerm_Term{Term: term1020} + _t1842.RelTermType = &pb.RelTerm_Term{Term: term_31019} _t1843 := &pb.RelTerm{} - _t1843.RelTermType = &pb.RelTerm_Term{Term: term_31021} - _t1844 := &pb.RelTerm{} - _t1844.RelTermType = &pb.RelTerm_Term{Term: term_41022} - _t1845 := &pb.Primitive{Name: "rel_primitive_subtract_monotype", Terms: []*pb.RelTerm{_t1842, _t1843, _t1844}} - result1024 := _t1845 - p.recordSpan(int(span_start1023), "Primitive") - return result1024 + _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 } -func (p *Parser) parse_multiply() *pb.Primitive { - span_start1028 := int64(p.spanStart()) +func (p *Parser) parse_minus() *pb.Primitive { + span_start1026 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("*") + p.consumeLiteral("-") + _t1845 := p.parse_term() + term1023 := _t1845 _t1846 := p.parse_term() - term1025 := _t1846 + term_31024 := _t1846 _t1847 := p.parse_term() - term_31026 := _t1847 - _t1848 := p.parse_term() - term_41027 := _t1848 + term_41025 := _t1847 p.consumeLiteral(")") + _t1848 := &pb.RelTerm{} + _t1848.RelTermType = &pb.RelTerm_Term{Term: term1023} _t1849 := &pb.RelTerm{} - _t1849.RelTermType = &pb.RelTerm_Term{Term: term1025} + _t1849.RelTermType = &pb.RelTerm_Term{Term: term_31024} _t1850 := &pb.RelTerm{} - _t1850.RelTermType = &pb.RelTerm_Term{Term: term_31026} - _t1851 := &pb.RelTerm{} - _t1851.RelTermType = &pb.RelTerm_Term{Term: term_41027} - _t1852 := &pb.Primitive{Name: "rel_primitive_multiply_monotype", Terms: []*pb.RelTerm{_t1849, _t1850, _t1851}} - result1029 := _t1852 - p.recordSpan(int(span_start1028), "Primitive") - return result1029 + _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 } -func (p *Parser) parse_divide() *pb.Primitive { - span_start1033 := int64(p.spanStart()) +func (p *Parser) parse_multiply() *pb.Primitive { + span_start1031 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("/") + p.consumeLiteral("*") + _t1852 := p.parse_term() + term1028 := _t1852 _t1853 := p.parse_term() - term1030 := _t1853 + term_31029 := _t1853 _t1854 := p.parse_term() - term_31031 := _t1854 - _t1855 := p.parse_term() - term_41032 := _t1855 + term_41030 := _t1854 p.consumeLiteral(")") + _t1855 := &pb.RelTerm{} + _t1855.RelTermType = &pb.RelTerm_Term{Term: term1028} _t1856 := &pb.RelTerm{} - _t1856.RelTermType = &pb.RelTerm_Term{Term: term1030} + _t1856.RelTermType = &pb.RelTerm_Term{Term: term_31029} _t1857 := &pb.RelTerm{} - _t1857.RelTermType = &pb.RelTerm_Term{Term: term_31031} - _t1858 := &pb.RelTerm{} - _t1858.RelTermType = &pb.RelTerm_Term{Term: term_41032} - _t1859 := &pb.Primitive{Name: "rel_primitive_divide_monotype", Terms: []*pb.RelTerm{_t1856, _t1857, _t1858}} - result1034 := _t1859 - p.recordSpan(int(span_start1033), "Primitive") - return result1034 + _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 +} + +func (p *Parser) parse_divide() *pb.Primitive { + span_start1036 := 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 + 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 } func (p *Parser) parse_rel_term() *pb.RelTerm { - span_start1038 := int64(p.spanStart()) - var _t1860 int64 + span_start1041 := int64(p.spanStart()) + var _t1866 int64 if p.matchLookaheadLiteral("true", 0) { - _t1860 = 1 + _t1866 = 1 } else { - var _t1861 int64 + var _t1867 int64 if p.matchLookaheadLiteral("missing", 0) { - _t1861 = 1 + _t1867 = 1 } else { - var _t1862 int64 + var _t1868 int64 if p.matchLookaheadLiteral("false", 0) { - _t1862 = 1 + _t1868 = 1 } else { - var _t1863 int64 + var _t1869 int64 if p.matchLookaheadLiteral("(", 0) { - _t1863 = 1 + _t1869 = 1 } else { - var _t1864 int64 + var _t1870 int64 if p.matchLookaheadLiteral("#", 0) { - _t1864 = 0 + _t1870 = 0 } else { - var _t1865 int64 + var _t1871 int64 if p.matchLookaheadTerminal("SYMBOL", 0) { - _t1865 = 1 + _t1871 = 1 } else { - var _t1866 int64 + var _t1872 int64 if p.matchLookaheadTerminal("UINT32", 0) { - _t1866 = 1 + _t1872 = 1 } else { - var _t1867 int64 + var _t1873 int64 if p.matchLookaheadTerminal("UINT128", 0) { - _t1867 = 1 + _t1873 = 1 } else { - var _t1868 int64 + var _t1874 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t1868 = 1 + _t1874 = 1 } else { - var _t1869 int64 + var _t1875 int64 if p.matchLookaheadTerminal("INT32", 0) { - _t1869 = 1 + _t1875 = 1 } else { - var _t1870 int64 + var _t1876 int64 if p.matchLookaheadTerminal("INT128", 0) { - _t1870 = 1 + _t1876 = 1 } else { - var _t1871 int64 + var _t1877 int64 if p.matchLookaheadTerminal("INT", 0) { - _t1871 = 1 + _t1877 = 1 } else { - var _t1872 int64 + var _t1878 int64 if p.matchLookaheadTerminal("FLOAT32", 0) { - _t1872 = 1 + _t1878 = 1 } else { - var _t1873 int64 + var _t1879 int64 if p.matchLookaheadTerminal("FLOAT", 0) { - _t1873 = 1 + _t1879 = 1 } else { - var _t1874 int64 + var _t1880 int64 if p.matchLookaheadTerminal("DECIMAL", 0) { - _t1874 = 1 + _t1880 = 1 } else { - _t1874 = -1 + _t1880 = -1 } - _t1873 = _t1874 + _t1879 = _t1880 } - _t1872 = _t1873 + _t1878 = _t1879 } - _t1871 = _t1872 + _t1877 = _t1878 } - _t1870 = _t1871 + _t1876 = _t1877 } - _t1869 = _t1870 + _t1875 = _t1876 } - _t1868 = _t1869 + _t1874 = _t1875 } - _t1867 = _t1868 + _t1873 = _t1874 } - _t1866 = _t1867 + _t1872 = _t1873 } - _t1865 = _t1866 + _t1871 = _t1872 } - _t1864 = _t1865 + _t1870 = _t1871 } - _t1863 = _t1864 + _t1869 = _t1870 } - _t1862 = _t1863 + _t1868 = _t1869 } - _t1861 = _t1862 + _t1867 = _t1868 } - _t1860 = _t1861 - } - prediction1035 := _t1860 - var _t1875 *pb.RelTerm - if prediction1035 == 1 { - _t1876 := p.parse_term() - term1037 := _t1876 - _t1877 := &pb.RelTerm{} - _t1877.RelTermType = &pb.RelTerm_Term{Term: term1037} - _t1875 = _t1877 + _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 } else { - var _t1878 *pb.RelTerm - if prediction1035 == 0 { - _t1879 := p.parse_specialized_value() - specialized_value1036 := _t1879 - _t1880 := &pb.RelTerm{} - _t1880.RelTermType = &pb.RelTerm_SpecializedValue{SpecializedValue: specialized_value1036} - _t1878 = _t1880 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in rel_term", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1875 = _t1878 + _t1881 = _t1884 } - result1039 := _t1875 - p.recordSpan(int(span_start1038), "RelTerm") - return result1039 -} - -func (p *Parser) parse_specialized_value() *pb.Value { - span_start1041 := int64(p.spanStart()) - p.consumeLiteral("#") - _t1881 := p.parse_raw_value() - raw_value1040 := _t1881 - result1042 := raw_value1040 - p.recordSpan(int(span_start1041), "Value") + result1042 := _t1881 + p.recordSpan(int(span_start1041), "RelTerm") return result1042 ->>>>>>> origin/main } func (p *Parser) parse_specialized_value() *pb.Value { - span_start1007 := int64(p.spanStart()) + span_start1044 := int64(p.spanStart()) p.consumeLiteral("#") - _t1813 := p.parse_raw_value() - raw_value1006 := _t1813 - result1008 := raw_value1006 - p.recordSpan(int(span_start1007), "Value") - return result1008 + _t1887 := p.parse_raw_value() + raw_value1043 := _t1887 + result1045 := raw_value1043 + p.recordSpan(int(span_start1044), "Value") + return result1045 } func (p *Parser) parse_rel_atom() *pb.RelAtom { -<<<<<<< HEAD - span_start1014 := int64(p.spanStart()) + span_start1051 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relatom") - _t1814 := p.parse_name() - name1009 := _t1814 - xs1010 := []*pb.RelTerm{} - cond1011 := ((((((((((((((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 cond1011 { - _t1815 := p.parse_rel_term() - item1012 := _t1815 - xs1010 = append(xs1010, item1012) - cond1011 = ((((((((((((((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_terms1013 := xs1010 - p.consumeLiteral(")") - _t1816 := &pb.RelAtom{Name: name1009, Terms: rel_terms1013} - result1015 := _t1816 - p.recordSpan(int(span_start1014), "RelAtom") - return result1015 -} - -func (p *Parser) parse_cast() *pb.Cast { - span_start1018 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("cast") - _t1817 := p.parse_term() - term1016 := _t1817 - _t1818 := p.parse_term() - term_31017 := _t1818 - p.consumeLiteral(")") - _t1819 := &pb.Cast{Input: term1016, Result: term_31017} - result1019 := _t1819 - p.recordSpan(int(span_start1018), "Cast") - return result1019 -======= - span_start1048 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("relatom") - _t1882 := p.parse_name() - name1043 := _t1882 - xs1044 := []*pb.RelTerm{} - cond1045 := ((((((((((((((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 cond1045 { - _t1883 := p.parse_rel_term() - item1046 := _t1883 - xs1044 = append(xs1044, item1046) - cond1045 = ((((((((((((((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_terms1047 := xs1044 + _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 p.consumeLiteral(")") - _t1884 := &pb.RelAtom{Name: name1043, Terms: rel_terms1047} - result1049 := _t1884 - p.recordSpan(int(span_start1048), "RelAtom") - return result1049 + _t1890 := &pb.RelAtom{Name: name1046, Terms: rel_terms1050} + result1052 := _t1890 + p.recordSpan(int(span_start1051), "RelAtom") + return result1052 } func (p *Parser) parse_cast() *pb.Cast { - span_start1052 := int64(p.spanStart()) + span_start1055 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("cast") - _t1885 := p.parse_term() - term1050 := _t1885 - _t1886 := p.parse_term() - term_31051 := _t1886 + _t1891 := p.parse_term() + term1053 := _t1891 + _t1892 := p.parse_term() + term_31054 := _t1892 p.consumeLiteral(")") - _t1887 := &pb.Cast{Input: term1050, Result: term_31051} - result1053 := _t1887 - p.recordSpan(int(span_start1052), "Cast") - return result1053 ->>>>>>> origin/main + _t1893 := &pb.Cast{Input: term1053, Result: term_31054} + result1056 := _t1893 + p.recordSpan(int(span_start1055), "Cast") + return result1056 } func (p *Parser) parse_attrs() []*pb.Attribute { p.consumeLiteral("(") p.consumeLiteral("attrs") -<<<<<<< HEAD - xs1020 := []*pb.Attribute{} - cond1021 := p.matchLookaheadLiteral("(", 0) - for cond1021 { - _t1820 := p.parse_attribute() - item1022 := _t1820 - xs1020 = append(xs1020, item1022) - cond1021 = p.matchLookaheadLiteral("(", 0) - } - attributes1023 := xs1020 - p.consumeLiteral(")") - return attributes1023 -} - -func (p *Parser) parse_attribute() *pb.Attribute { - span_start1029 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("attribute") - _t1821 := p.parse_name() - name1024 := _t1821 - xs1025 := []*pb.Value{} - cond1026 := ((((((((((((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 cond1026 { - _t1822 := p.parse_raw_value() - item1027 := _t1822 - xs1025 = append(xs1025, item1027) - cond1026 = ((((((((((((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_values1028 := xs1025 - p.consumeLiteral(")") - _t1823 := &pb.Attribute{Name: name1024, Args: raw_values1028} - result1030 := _t1823 - p.recordSpan(int(span_start1029), "Attribute") - return result1030 -} - -func (p *Parser) parse_algorithm() *pb.Algorithm { - span_start1037 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("algorithm") - xs1031 := []*pb.RelationId{} - cond1032 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1032 { - _t1824 := p.parse_relation_id() - item1033 := _t1824 - xs1031 = append(xs1031, item1033) - cond1032 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1034 := xs1031 - _t1825 := p.parse_script() - script1035 := _t1825 - var _t1826 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1827 := p.parse_attrs() - _t1826 = _t1827 - } - attrs1036 := _t1826 - p.consumeLiteral(")") - _t1828 := attrs1036 - if attrs1036 == nil { - _t1828 = []*pb.Attribute{} - } - _t1829 := &pb.Algorithm{Global: relation_ids1034, Body: script1035, Attrs: _t1828} - result1038 := _t1829 - p.recordSpan(int(span_start1037), "Algorithm") - return result1038 -} - -func (p *Parser) parse_script() *pb.Script { - span_start1043 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("script") - xs1039 := []*pb.Construct{} - cond1040 := p.matchLookaheadLiteral("(", 0) - for cond1040 { - _t1830 := p.parse_construct() - item1041 := _t1830 - xs1039 = append(xs1039, item1041) - cond1040 = p.matchLookaheadLiteral("(", 0) - } - constructs1042 := xs1039 - p.consumeLiteral(")") - _t1831 := &pb.Script{Constructs: constructs1042} - result1044 := _t1831 - p.recordSpan(int(span_start1043), "Script") - return result1044 -} - -func (p *Parser) parse_construct() *pb.Construct { - span_start1048 := int64(p.spanStart()) - var _t1832 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1833 int64 - if p.matchLookaheadLiteral("upsert", 1) { - _t1833 = 1 - } else { - var _t1834 int64 - if p.matchLookaheadLiteral("monus", 1) { - _t1834 = 1 - } else { - var _t1835 int64 - if p.matchLookaheadLiteral("monoid", 1) { - _t1835 = 1 - } else { - var _t1836 int64 - if p.matchLookaheadLiteral("loop", 1) { - _t1836 = 0 - } else { - var _t1837 int64 - if p.matchLookaheadLiteral("break", 1) { - _t1837 = 1 - } else { - var _t1838 int64 - if p.matchLookaheadLiteral("assign", 1) { - _t1838 = 1 - } else { - _t1838 = -1 - } - _t1837 = _t1838 - } - _t1836 = _t1837 - } - _t1835 = _t1836 - } - _t1834 = _t1835 - } - _t1833 = _t1834 - } - _t1832 = _t1833 - } else { - _t1832 = -1 - } - prediction1045 := _t1832 - var _t1839 *pb.Construct - if prediction1045 == 1 { - _t1840 := p.parse_instruction() - instruction1047 := _t1840 - _t1841 := &pb.Construct{} - _t1841.ConstructType = &pb.Construct_Instruction{Instruction: instruction1047} - _t1839 = _t1841 - } else { - var _t1842 *pb.Construct - if prediction1045 == 0 { - _t1843 := p.parse_loop() - loop1046 := _t1843 - _t1844 := &pb.Construct{} - _t1844.ConstructType = &pb.Construct_Loop{Loop: loop1046} - _t1842 = _t1844 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1839 = _t1842 - } - result1049 := _t1839 - p.recordSpan(int(span_start1048), "Construct") - return result1049 -} - -func (p *Parser) parse_loop() *pb.Loop { - span_start1053 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("loop") - _t1845 := p.parse_init() - init1050 := _t1845 - _t1846 := p.parse_script() - script1051 := _t1846 - var _t1847 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1848 := p.parse_attrs() - _t1847 = _t1848 + xs1057 := []*pb.Attribute{} + cond1058 := p.matchLookaheadLiteral("(", 0) + for cond1058 { + _t1894 := p.parse_attribute() + item1059 := _t1894 + xs1057 = append(xs1057, item1059) + cond1058 = p.matchLookaheadLiteral("(", 0) } - attrs1052 := _t1847 - p.consumeLiteral(")") - _t1849 := attrs1052 - if attrs1052 == nil { - _t1849 = []*pb.Attribute{} - } - _t1850 := &pb.Loop{Init: init1050, Body: script1051, Attrs: _t1849} - result1054 := _t1850 - p.recordSpan(int(span_start1053), "Loop") - return result1054 -======= - xs1054 := []*pb.Attribute{} - cond1055 := p.matchLookaheadLiteral("(", 0) - for cond1055 { - _t1888 := p.parse_attribute() - item1056 := _t1888 - xs1054 = append(xs1054, item1056) - cond1055 = p.matchLookaheadLiteral("(", 0) - } - attributes1057 := xs1054 + attributes1060 := xs1057 p.consumeLiteral(")") - return attributes1057 + return attributes1060 } func (p *Parser) parse_attribute() *pb.Attribute { - span_start1063 := int64(p.spanStart()) + span_start1066 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("attribute") - _t1889 := p.parse_name() - name1058 := _t1889 - xs1059 := []*pb.Value{} - cond1060 := ((((((((((((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 cond1060 { - _t1890 := p.parse_raw_value() - item1061 := _t1890 - xs1059 = append(xs1059, item1061) - cond1060 = ((((((((((((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_values1062 := xs1059 + _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 p.consumeLiteral(")") - _t1891 := &pb.Attribute{Name: name1058, Args: raw_values1062} - result1064 := _t1891 - p.recordSpan(int(span_start1063), "Attribute") - return result1064 + _t1897 := &pb.Attribute{Name: name1061, Args: raw_values1065} + result1067 := _t1897 + p.recordSpan(int(span_start1066), "Attribute") + return result1067 } func (p *Parser) parse_algorithm() *pb.Algorithm { - span_start1071 := int64(p.spanStart()) + span_start1074 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("algorithm") - xs1065 := []*pb.RelationId{} - cond1066 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1066 { - _t1892 := p.parse_relation_id() - item1067 := _t1892 - xs1065 = append(xs1065, item1067) - cond1066 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1068 := xs1065 - _t1893 := p.parse_script() - script1069 := _t1893 - var _t1894 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1895 := p.parse_attrs() - _t1894 = _t1895 - } - attrs1070 := _t1894 - p.consumeLiteral(")") - _t1896 := attrs1070 - if attrs1070 == nil { - _t1896 = []*pb.Attribute{} - } - _t1897 := &pb.Algorithm{Global: relation_ids1068, Body: script1069, Attrs: _t1896} - result1072 := _t1897 - p.recordSpan(int(span_start1071), "Algorithm") - return result1072 -} - -func (p *Parser) parse_script() *pb.Script { - span_start1077 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("script") - xs1073 := []*pb.Construct{} - cond1074 := p.matchLookaheadLiteral("(", 0) - for cond1074 { - _t1898 := p.parse_construct() - item1075 := _t1898 - xs1073 = append(xs1073, item1075) - cond1074 = p.matchLookaheadLiteral("(", 0) - } - constructs1076 := xs1073 - p.consumeLiteral(")") - _t1899 := &pb.Script{Constructs: constructs1076} - result1078 := _t1899 - p.recordSpan(int(span_start1077), "Script") - return result1078 -} - -func (p *Parser) parse_construct() *pb.Construct { - span_start1082 := int64(p.spanStart()) - var _t1900 int64 + 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 if p.matchLookaheadLiteral("(", 0) { - var _t1901 int64 - if p.matchLookaheadLiteral("upsert", 1) { - _t1901 = 1 - } else { - var _t1902 int64 - if p.matchLookaheadLiteral("monus", 1) { - _t1902 = 1 - } else { - var _t1903 int64 - if p.matchLookaheadLiteral("monoid", 1) { - _t1903 = 1 - } else { - var _t1904 int64 - if p.matchLookaheadLiteral("loop", 1) { - _t1904 = 0 - } else { - var _t1905 int64 - if p.matchLookaheadLiteral("break", 1) { - _t1905 = 1 - } else { - var _t1906 int64 - if p.matchLookaheadLiteral("assign", 1) { - _t1906 = 1 - } else { - _t1906 = -1 - } - _t1905 = _t1906 - } - _t1904 = _t1905 - } - _t1903 = _t1904 - } - _t1902 = _t1903 - } - _t1901 = _t1902 - } + _t1901 := p.parse_attrs() _t1900 = _t1901 - } else { - _t1900 = -1 - } - prediction1079 := _t1900 - var _t1907 *pb.Construct - if prediction1079 == 1 { - _t1908 := p.parse_instruction() - instruction1081 := _t1908 - _t1909 := &pb.Construct{} - _t1909.ConstructType = &pb.Construct_Instruction{Instruction: instruction1081} - _t1907 = _t1909 - } else { - var _t1910 *pb.Construct - if prediction1079 == 0 { - _t1911 := p.parse_loop() - loop1080 := _t1911 - _t1912 := &pb.Construct{} - _t1912.ConstructType = &pb.Construct_Loop{Loop: loop1080} - _t1910 = _t1912 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1907 = _t1910 - } - result1083 := _t1907 - p.recordSpan(int(span_start1082), "Construct") - return result1083 -} - -func (p *Parser) parse_loop() *pb.Loop { - span_start1087 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("loop") - _t1913 := p.parse_init() - init1084 := _t1913 - _t1914 := p.parse_script() - script1085 := _t1914 - var _t1915 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1916 := p.parse_attrs() - _t1915 = _t1916 } - attrs1086 := _t1915 + attrs1073 := _t1900 p.consumeLiteral(")") - _t1917 := attrs1086 - if attrs1086 == nil { - _t1917 = []*pb.Attribute{} + _t1902 := attrs1073 + if attrs1073 == nil { + _t1902 = []*pb.Attribute{} } - _t1918 := &pb.Loop{Init: init1084, Body: script1085, Attrs: _t1917} - result1088 := _t1918 - p.recordSpan(int(span_start1087), "Loop") - return result1088 ->>>>>>> origin/main + _t1903 := &pb.Algorithm{Global: relation_ids1071, Body: script1072, Attrs: _t1902} + result1075 := _t1903 + p.recordSpan(int(span_start1074), "Algorithm") + return result1075 } -func (p *Parser) parse_init() []*pb.Instruction { +func (p *Parser) parse_script() *pb.Script { + span_start1080 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("init") -<<<<<<< HEAD - xs1055 := []*pb.Instruction{} - cond1056 := p.matchLookaheadLiteral("(", 0) - for cond1056 { - _t1851 := p.parse_instruction() - item1057 := _t1851 - xs1055 = append(xs1055, item1057) - cond1056 = p.matchLookaheadLiteral("(", 0) - } - instructions1058 := xs1055 + 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 p.consumeLiteral(")") - return instructions1058 + _t1905 := &pb.Script{Constructs: constructs1079} + result1081 := _t1905 + p.recordSpan(int(span_start1080), "Script") + return result1081 } -func (p *Parser) parse_instruction() *pb.Instruction { - span_start1065 := int64(p.spanStart()) - var _t1852 int64 +func (p *Parser) parse_construct() *pb.Construct { + span_start1085 := int64(p.spanStart()) + var _t1906 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1853 int64 + var _t1907 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1853 = 1 + _t1907 = 1 } else { - var _t1854 int64 + var _t1908 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1854 = 4 + _t1908 = 1 } else { - var _t1855 int64 + var _t1909 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1855 = 3 + _t1909 = 1 } else { - var _t1856 int64 - if p.matchLookaheadLiteral("break", 1) { - _t1856 = 2 + var _t1910 int64 + if p.matchLookaheadLiteral("loop", 1) { + _t1910 = 0 } else { - var _t1857 int64 - if p.matchLookaheadLiteral("assign", 1) { - _t1857 = 0 + var _t1911 int64 + if p.matchLookaheadLiteral("break", 1) { + _t1911 = 1 } else { - _t1857 = -1 + var _t1912 int64 + if p.matchLookaheadLiteral("assign", 1) { + _t1912 = 1 + } else { + _t1912 = -1 + } + _t1911 = _t1912 } - _t1856 = _t1857 + _t1910 = _t1911 } - _t1855 = _t1856 + _t1909 = _t1910 } - _t1854 = _t1855 + _t1908 = _t1909 } - _t1853 = _t1854 + _t1907 = _t1908 } - _t1852 = _t1853 + _t1906 = _t1907 } else { - _t1852 = -1 - } - prediction1059 := _t1852 - var _t1858 *pb.Instruction - if prediction1059 == 4 { - _t1859 := p.parse_monus_def() - monus_def1064 := _t1859 - _t1860 := &pb.Instruction{} - _t1860.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1064} - _t1858 = _t1860 + _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 } else { - var _t1861 *pb.Instruction - if prediction1059 == 3 { - _t1862 := p.parse_monoid_def() - monoid_def1063 := _t1862 - _t1863 := &pb.Instruction{} - _t1863.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1063} - _t1861 = _t1863 + 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 } else { - var _t1864 *pb.Instruction - if prediction1059 == 2 { - _t1865 := p.parse_break() - break1062 := _t1865 - _t1866 := &pb.Instruction{} - _t1866.InstrType = &pb.Instruction_Break{Break: break1062} - _t1864 = _t1866 - } else { - var _t1867 *pb.Instruction - if prediction1059 == 1 { - _t1868 := p.parse_upsert() - upsert1061 := _t1868 - _t1869 := &pb.Instruction{} - _t1869.InstrType = &pb.Instruction_Upsert{Upsert: upsert1061} - _t1867 = _t1869 - } else { - var _t1870 *pb.Instruction - if prediction1059 == 0 { - _t1871 := p.parse_assign() - assign1060 := _t1871 - _t1872 := &pb.Instruction{} - _t1872.InstrType = &pb.Instruction_Assign{Assign: assign1060} - _t1870 = _t1872 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1867 = _t1870 - } - _t1864 = _t1867 - } - _t1861 = _t1864 + panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1858 = _t1861 + _t1913 = _t1916 } - result1066 := _t1858 - p.recordSpan(int(span_start1065), "Instruction") - return result1066 + result1086 := _t1913 + p.recordSpan(int(span_start1085), "Construct") + return result1086 } -func (p *Parser) parse_assign() *pb.Assign { - span_start1070 := int64(p.spanStart()) +func (p *Parser) parse_loop() *pb.Loop { + span_start1090 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("assign") - _t1873 := p.parse_relation_id() - relation_id1067 := _t1873 - _t1874 := p.parse_abstraction() - abstraction1068 := _t1874 - var _t1875 []*pb.Attribute -======= - xs1089 := []*pb.Instruction{} - cond1090 := p.matchLookaheadLiteral("(", 0) - for cond1090 { - _t1919 := p.parse_instruction() - item1091 := _t1919 - xs1089 = append(xs1089, item1091) - cond1090 = p.matchLookaheadLiteral("(", 0) - } - instructions1092 := xs1089 + p.consumeLiteral("loop") + _t1919 := p.parse_init() + init1087 := _t1919 + _t1920 := p.parse_script() + script1088 := _t1920 + var _t1921 []*pb.Attribute + if p.matchLookaheadLiteral("(", 0) { + _t1922 := p.parse_attrs() + _t1921 = _t1922 + } + attrs1089 := _t1921 + p.consumeLiteral(")") + _t1923 := attrs1089 + if attrs1089 == nil { + _t1923 = []*pb.Attribute{} + } + _t1924 := &pb.Loop{Init: init1087, Body: script1088, Attrs: _t1923} + result1091 := _t1924 + p.recordSpan(int(span_start1090), "Loop") + return result1091 +} + +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 p.consumeLiteral(")") - return instructions1092 + return instructions1095 } func (p *Parser) parse_instruction() *pb.Instruction { - span_start1099 := int64(p.spanStart()) - var _t1920 int64 + span_start1102 := int64(p.spanStart()) + var _t1926 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1921 int64 + var _t1927 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1921 = 1 + _t1927 = 1 } else { - var _t1922 int64 + var _t1928 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1922 = 4 + _t1928 = 4 } else { - var _t1923 int64 + var _t1929 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1923 = 3 + _t1929 = 3 } else { - var _t1924 int64 + var _t1930 int64 if p.matchLookaheadLiteral("break", 1) { - _t1924 = 2 + _t1930 = 2 } else { - var _t1925 int64 + var _t1931 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1925 = 0 + _t1931 = 0 } else { - _t1925 = -1 + _t1931 = -1 } - _t1924 = _t1925 + _t1930 = _t1931 } - _t1923 = _t1924 + _t1929 = _t1930 } - _t1922 = _t1923 + _t1928 = _t1929 } - _t1921 = _t1922 + _t1927 = _t1928 } - _t1920 = _t1921 + _t1926 = _t1927 } else { - _t1920 = -1 - } - prediction1093 := _t1920 - var _t1926 *pb.Instruction - if prediction1093 == 4 { - _t1927 := p.parse_monus_def() - monus_def1098 := _t1927 - _t1928 := &pb.Instruction{} - _t1928.InstrType = &pb.Instruction_MonusDef{MonusDef: monus_def1098} - _t1926 = _t1928 + _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 } else { - var _t1929 *pb.Instruction - if prediction1093 == 3 { - _t1930 := p.parse_monoid_def() - monoid_def1097 := _t1930 - _t1931 := &pb.Instruction{} - _t1931.InstrType = &pb.Instruction_MonoidDef{MonoidDef: monoid_def1097} - _t1929 = _t1931 + 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 } else { - var _t1932 *pb.Instruction - if prediction1093 == 2 { - _t1933 := p.parse_break() - break1096 := _t1933 - _t1934 := &pb.Instruction{} - _t1934.InstrType = &pb.Instruction_Break{Break: break1096} - _t1932 = _t1934 + 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 } else { - var _t1935 *pb.Instruction - if prediction1093 == 1 { - _t1936 := p.parse_upsert() - upsert1095 := _t1936 - _t1937 := &pb.Instruction{} - _t1937.InstrType = &pb.Instruction_Upsert{Upsert: upsert1095} - _t1935 = _t1937 + 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 } else { - var _t1938 *pb.Instruction - if prediction1093 == 0 { - _t1939 := p.parse_assign() - assign1094 := _t1939 - _t1940 := &pb.Instruction{} - _t1940.InstrType = &pb.Instruction_Assign{Assign: assign1094} - _t1938 = _t1940 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in instruction", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1935 = _t1938 + _t1941 = _t1944 } - _t1932 = _t1935 + _t1938 = _t1941 } - _t1929 = _t1932 + _t1935 = _t1938 } - _t1926 = _t1929 + _t1932 = _t1935 } - result1100 := _t1926 - p.recordSpan(int(span_start1099), "Instruction") - return result1100 + result1103 := _t1932 + p.recordSpan(int(span_start1102), "Instruction") + return result1103 } func (p *Parser) parse_assign() *pb.Assign { - span_start1104 := int64(p.spanStart()) + span_start1107 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("assign") - _t1941 := p.parse_relation_id() - relation_id1101 := _t1941 - _t1942 := p.parse_abstraction() - abstraction1102 := _t1942 - var _t1943 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1944 := p.parse_attrs() - _t1943 = _t1944 - } - attrs1103 := _t1943 - p.consumeLiteral(")") - _t1945 := attrs1103 - if attrs1103 == nil { - _t1945 = []*pb.Attribute{} - } - _t1946 := &pb.Assign{Name: relation_id1101, Body: abstraction1102, Attrs: _t1945} - result1105 := _t1946 - p.recordSpan(int(span_start1104), "Assign") - return result1105 -} - -func (p *Parser) parse_upsert() *pb.Upsert { - span_start1109 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("upsert") _t1947 := p.parse_relation_id() - relation_id1106 := _t1947 - _t1948 := p.parse_abstraction_with_arity() - abstraction_with_arity1107 := _t1948 + relation_id1104 := _t1947 + _t1948 := p.parse_abstraction() + abstraction1105 := _t1948 var _t1949 []*pb.Attribute ->>>>>>> origin/main if p.matchLookaheadLiteral("(", 0) { _t1950 := p.parse_attrs() _t1949 = _t1950 } -<<<<<<< HEAD - attrs1069 := _t1875 + attrs1106 := _t1949 p.consumeLiteral(")") - _t1877 := attrs1069 - if attrs1069 == nil { - _t1877 = []*pb.Attribute{} + _t1951 := attrs1106 + if attrs1106 == nil { + _t1951 = []*pb.Attribute{} } - _t1878 := &pb.Assign{Name: relation_id1067, Body: abstraction1068, Attrs: _t1877} - result1071 := _t1878 - p.recordSpan(int(span_start1070), "Assign") - return result1071 + _t1952 := &pb.Assign{Name: relation_id1104, Body: abstraction1105, Attrs: _t1951} + result1108 := _t1952 + p.recordSpan(int(span_start1107), "Assign") + return result1108 } func (p *Parser) parse_upsert() *pb.Upsert { - span_start1075 := int64(p.spanStart()) + span_start1112 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("upsert") - _t1879 := p.parse_relation_id() - relation_id1072 := _t1879 - _t1880 := p.parse_abstraction_with_arity() - abstraction_with_arity1073 := _t1880 - var _t1881 []*pb.Attribute + _t1953 := p.parse_relation_id() + relation_id1109 := _t1953 + _t1954 := p.parse_abstraction_with_arity() + abstraction_with_arity1110 := _t1954 + var _t1955 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1882 := p.parse_attrs() - _t1881 = _t1882 + _t1956 := p.parse_attrs() + _t1955 = _t1956 } - attrs1074 := _t1881 - p.consumeLiteral(")") - _t1883 := attrs1074 - if attrs1074 == nil { - _t1883 = []*pb.Attribute{} - } - _t1884 := &pb.Upsert{Name: relation_id1072, Body: abstraction_with_arity1073[0].(*pb.Abstraction), Attrs: _t1883, ValueArity: abstraction_with_arity1073[1].(int64)} - result1076 := _t1884 - p.recordSpan(int(span_start1075), "Upsert") - return result1076 -======= - attrs1108 := _t1949 + attrs1111 := _t1955 p.consumeLiteral(")") - _t1951 := attrs1108 - if attrs1108 == nil { - _t1951 = []*pb.Attribute{} + _t1957 := attrs1111 + if attrs1111 == nil { + _t1957 = []*pb.Attribute{} } - _t1952 := &pb.Upsert{Name: relation_id1106, Body: abstraction_with_arity1107[0].(*pb.Abstraction), Attrs: _t1951, ValueArity: abstraction_with_arity1107[1].(int64)} - result1110 := _t1952 - p.recordSpan(int(span_start1109), "Upsert") - return result1110 ->>>>>>> origin/main + _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 } func (p *Parser) parse_abstraction_with_arity() []interface{} { p.consumeLiteral("(") -<<<<<<< HEAD - _t1885 := p.parse_bindings() - bindings1077 := _t1885 - _t1886 := p.parse_formula() - formula1078 := _t1886 - p.consumeLiteral(")") - _t1887 := &pb.Abstraction{Vars: listConcat(bindings1077[0].([]*pb.Binding), bindings1077[1].([]*pb.Binding)), Value: formula1078} - return []interface{}{_t1887, int64(len(bindings1077[1].([]*pb.Binding)))} -} - -func (p *Parser) parse_break() *pb.Break { - span_start1082 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("break") - _t1888 := p.parse_relation_id() - relation_id1079 := _t1888 - _t1889 := p.parse_abstraction() - abstraction1080 := _t1889 - var _t1890 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1891 := p.parse_attrs() - _t1890 = _t1891 - } - attrs1081 := _t1890 - p.consumeLiteral(")") - _t1892 := attrs1081 - if attrs1081 == nil { - _t1892 = []*pb.Attribute{} - } - _t1893 := &pb.Break{Name: relation_id1079, Body: abstraction1080, Attrs: _t1892} - result1083 := _t1893 - p.recordSpan(int(span_start1082), "Break") - return result1083 -} - -func (p *Parser) parse_monoid_def() *pb.MonoidDef { - span_start1088 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("monoid") - _t1894 := p.parse_monoid() - monoid1084 := _t1894 - _t1895 := p.parse_relation_id() - relation_id1085 := _t1895 - _t1896 := p.parse_abstraction_with_arity() - abstraction_with_arity1086 := _t1896 - var _t1897 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1898 := p.parse_attrs() - _t1897 = _t1898 - } - attrs1087 := _t1897 - p.consumeLiteral(")") - _t1899 := attrs1087 - if attrs1087 == nil { - _t1899 = []*pb.Attribute{} - } - _t1900 := &pb.MonoidDef{Monoid: monoid1084, Name: relation_id1085, Body: abstraction_with_arity1086[0].(*pb.Abstraction), Attrs: _t1899, ValueArity: abstraction_with_arity1086[1].(int64)} - result1089 := _t1900 - p.recordSpan(int(span_start1088), "MonoidDef") - return result1089 -} - -func (p *Parser) parse_monoid() *pb.Monoid { - span_start1095 := int64(p.spanStart()) - var _t1901 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1902 int64 - if p.matchLookaheadLiteral("sum", 1) { - _t1902 = 3 - } else { - var _t1903 int64 - if p.matchLookaheadLiteral("or", 1) { - _t1903 = 0 - } else { - var _t1904 int64 - if p.matchLookaheadLiteral("min", 1) { - _t1904 = 1 - } else { - var _t1905 int64 - if p.matchLookaheadLiteral("max", 1) { - _t1905 = 2 - } else { - _t1905 = -1 - } - _t1904 = _t1905 - } - _t1903 = _t1904 - } - _t1902 = _t1903 - } - _t1901 = _t1902 - } else { - _t1901 = -1 - } - prediction1090 := _t1901 - var _t1906 *pb.Monoid - if prediction1090 == 3 { - _t1907 := p.parse_sum_monoid() - sum_monoid1094 := _t1907 - _t1908 := &pb.Monoid{} - _t1908.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1094} - _t1906 = _t1908 - } else { - var _t1909 *pb.Monoid - if prediction1090 == 2 { - _t1910 := p.parse_max_monoid() - max_monoid1093 := _t1910 - _t1911 := &pb.Monoid{} - _t1911.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1093} - _t1909 = _t1911 - } else { - var _t1912 *pb.Monoid - if prediction1090 == 1 { - _t1913 := p.parse_min_monoid() - min_monoid1092 := _t1913 - _t1914 := &pb.Monoid{} - _t1914.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1092} - _t1912 = _t1914 - } else { - var _t1915 *pb.Monoid - if prediction1090 == 0 { - _t1916 := p.parse_or_monoid() - or_monoid1091 := _t1916 - _t1917 := &pb.Monoid{} - _t1917.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1091} - _t1915 = _t1917 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1912 = _t1915 - } - _t1909 = _t1912 - } - _t1906 = _t1909 - } - result1096 := _t1906 - p.recordSpan(int(span_start1095), "Monoid") - return result1096 -} - -func (p *Parser) parse_or_monoid() *pb.OrMonoid { - span_start1097 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("or") - p.consumeLiteral(")") - _t1918 := &pb.OrMonoid{} - result1098 := _t1918 - p.recordSpan(int(span_start1097), "OrMonoid") - return result1098 -} - -func (p *Parser) parse_min_monoid() *pb.MinMonoid { - span_start1100 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("min") - _t1919 := p.parse_type() - type1099 := _t1919 - p.consumeLiteral(")") - _t1920 := &pb.MinMonoid{Type: type1099} - result1101 := _t1920 - p.recordSpan(int(span_start1100), "MinMonoid") - return result1101 -} - -func (p *Parser) parse_max_monoid() *pb.MaxMonoid { - span_start1103 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("max") - _t1921 := p.parse_type() - type1102 := _t1921 - p.consumeLiteral(")") - _t1922 := &pb.MaxMonoid{Type: type1102} - result1104 := _t1922 - p.recordSpan(int(span_start1103), "MaxMonoid") - return result1104 -======= - _t1953 := p.parse_bindings() - bindings1111 := _t1953 - _t1954 := p.parse_formula() - formula1112 := _t1954 + _t1959 := p.parse_bindings() + bindings1114 := _t1959 + _t1960 := p.parse_formula() + formula1115 := _t1960 p.consumeLiteral(")") - _t1955 := &pb.Abstraction{Vars: listConcat(bindings1111[0].([]*pb.Binding), bindings1111[1].([]*pb.Binding)), Value: formula1112} - return []interface{}{_t1955, int64(len(bindings1111[1].([]*pb.Binding)))} + _t1961 := &pb.Abstraction{Vars: listConcat(bindings1114[0].([]*pb.Binding), bindings1114[1].([]*pb.Binding)), Value: formula1115} + return []interface{}{_t1961, int64(len(bindings1114[1].([]*pb.Binding)))} } func (p *Parser) parse_break() *pb.Break { - span_start1116 := int64(p.spanStart()) + span_start1119 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("break") - _t1956 := p.parse_relation_id() - relation_id1113 := _t1956 - _t1957 := p.parse_abstraction() - abstraction1114 := _t1957 - var _t1958 []*pb.Attribute + _t1962 := p.parse_relation_id() + relation_id1116 := _t1962 + _t1963 := p.parse_abstraction() + abstraction1117 := _t1963 + var _t1964 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1959 := p.parse_attrs() - _t1958 = _t1959 + _t1965 := p.parse_attrs() + _t1964 = _t1965 } - attrs1115 := _t1958 + attrs1118 := _t1964 p.consumeLiteral(")") - _t1960 := attrs1115 - if attrs1115 == nil { - _t1960 = []*pb.Attribute{} + _t1966 := attrs1118 + if attrs1118 == nil { + _t1966 = []*pb.Attribute{} } - _t1961 := &pb.Break{Name: relation_id1113, Body: abstraction1114, Attrs: _t1960} - result1117 := _t1961 - p.recordSpan(int(span_start1116), "Break") - return result1117 + _t1967 := &pb.Break{Name: relation_id1116, Body: abstraction1117, Attrs: _t1966} + result1120 := _t1967 + p.recordSpan(int(span_start1119), "Break") + return result1120 } func (p *Parser) parse_monoid_def() *pb.MonoidDef { - span_start1122 := int64(p.spanStart()) + span_start1125 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monoid") - _t1962 := p.parse_monoid() - monoid1118 := _t1962 - _t1963 := p.parse_relation_id() - relation_id1119 := _t1963 - _t1964 := p.parse_abstraction_with_arity() - abstraction_with_arity1120 := _t1964 - var _t1965 []*pb.Attribute + _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 if p.matchLookaheadLiteral("(", 0) { - _t1966 := p.parse_attrs() - _t1965 = _t1966 + _t1972 := p.parse_attrs() + _t1971 = _t1972 } - attrs1121 := _t1965 + attrs1124 := _t1971 p.consumeLiteral(")") - _t1967 := attrs1121 - if attrs1121 == nil { - _t1967 = []*pb.Attribute{} + _t1973 := attrs1124 + if attrs1124 == nil { + _t1973 = []*pb.Attribute{} } - _t1968 := &pb.MonoidDef{Monoid: monoid1118, Name: relation_id1119, Body: abstraction_with_arity1120[0].(*pb.Abstraction), Attrs: _t1967, ValueArity: abstraction_with_arity1120[1].(int64)} - result1123 := _t1968 - p.recordSpan(int(span_start1122), "MonoidDef") - return result1123 + _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 } func (p *Parser) parse_monoid() *pb.Monoid { - span_start1129 := int64(p.spanStart()) - var _t1969 int64 + span_start1132 := int64(p.spanStart()) + var _t1975 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1970 int64 + var _t1976 int64 if p.matchLookaheadLiteral("sum", 1) { - _t1970 = 3 + _t1976 = 3 } else { - var _t1971 int64 + var _t1977 int64 if p.matchLookaheadLiteral("or", 1) { - _t1971 = 0 + _t1977 = 0 } else { - var _t1972 int64 + var _t1978 int64 if p.matchLookaheadLiteral("min", 1) { - _t1972 = 1 + _t1978 = 1 } else { - var _t1973 int64 + var _t1979 int64 if p.matchLookaheadLiteral("max", 1) { - _t1973 = 2 + _t1979 = 2 } else { - _t1973 = -1 + _t1979 = -1 } - _t1972 = _t1973 + _t1978 = _t1979 } - _t1971 = _t1972 + _t1977 = _t1978 } - _t1970 = _t1971 + _t1976 = _t1977 } - _t1969 = _t1970 + _t1975 = _t1976 } else { - _t1969 = -1 - } - prediction1124 := _t1969 - var _t1974 *pb.Monoid - if prediction1124 == 3 { - _t1975 := p.parse_sum_monoid() - sum_monoid1128 := _t1975 - _t1976 := &pb.Monoid{} - _t1976.Value = &pb.Monoid_SumMonoid{SumMonoid: sum_monoid1128} - _t1974 = _t1976 + _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 } else { - var _t1977 *pb.Monoid - if prediction1124 == 2 { - _t1978 := p.parse_max_monoid() - max_monoid1127 := _t1978 - _t1979 := &pb.Monoid{} - _t1979.Value = &pb.Monoid_MaxMonoid{MaxMonoid: max_monoid1127} - _t1977 = _t1979 + 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 } else { - var _t1980 *pb.Monoid - if prediction1124 == 1 { - _t1981 := p.parse_min_monoid() - min_monoid1126 := _t1981 - _t1982 := &pb.Monoid{} - _t1982.Value = &pb.Monoid_MinMonoid{MinMonoid: min_monoid1126} - _t1980 = _t1982 + 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 } else { - var _t1983 *pb.Monoid - if prediction1124 == 0 { - _t1984 := p.parse_or_monoid() - or_monoid1125 := _t1984 - _t1985 := &pb.Monoid{} - _t1985.Value = &pb.Monoid_OrMonoid{OrMonoid: or_monoid1125} - _t1983 = _t1985 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in monoid", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1980 = _t1983 + _t1986 = _t1989 } - _t1977 = _t1980 + _t1983 = _t1986 } - _t1974 = _t1977 + _t1980 = _t1983 } - result1130 := _t1974 - p.recordSpan(int(span_start1129), "Monoid") - return result1130 + result1133 := _t1980 + p.recordSpan(int(span_start1132), "Monoid") + return result1133 } func (p *Parser) parse_or_monoid() *pb.OrMonoid { - span_start1131 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("or") - p.consumeLiteral(")") - _t1986 := &pb.OrMonoid{} - result1132 := _t1986 - p.recordSpan(int(span_start1131), "OrMonoid") - return result1132 -} - -func (p *Parser) parse_min_monoid() *pb.MinMonoid { span_start1134 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("min") - _t1987 := p.parse_type() - type1133 := _t1987 + p.consumeLiteral("or") p.consumeLiteral(")") - _t1988 := &pb.MinMonoid{Type: type1133} - result1135 := _t1988 - p.recordSpan(int(span_start1134), "MinMonoid") + _t1992 := &pb.OrMonoid{} + result1135 := _t1992 + p.recordSpan(int(span_start1134), "OrMonoid") return result1135 } -func (p *Parser) parse_max_monoid() *pb.MaxMonoid { +func (p *Parser) parse_min_monoid() *pb.MinMonoid { span_start1137 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("max") - _t1989 := p.parse_type() - type1136 := _t1989 + p.consumeLiteral("min") + _t1993 := p.parse_type() + type1136 := _t1993 p.consumeLiteral(")") - _t1990 := &pb.MaxMonoid{Type: type1136} - result1138 := _t1990 - p.recordSpan(int(span_start1137), "MaxMonoid") + _t1994 := &pb.MinMonoid{Type: type1136} + result1138 := _t1994 + p.recordSpan(int(span_start1137), "MinMonoid") return result1138 } -func (p *Parser) parse_sum_monoid() *pb.SumMonoid { +func (p *Parser) parse_max_monoid() *pb.MaxMonoid { span_start1140 := int64(p.spanStart()) p.consumeLiteral("(") - p.consumeLiteral("sum") - _t1991 := p.parse_type() - type1139 := _t1991 + p.consumeLiteral("max") + _t1995 := p.parse_type() + type1139 := _t1995 p.consumeLiteral(")") - _t1992 := &pb.SumMonoid{Type: type1139} - result1141 := _t1992 - p.recordSpan(int(span_start1140), "SumMonoid") + _t1996 := &pb.MaxMonoid{Type: type1139} + result1141 := _t1996 + p.recordSpan(int(span_start1140), "MaxMonoid") return result1141 ->>>>>>> origin/main } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { - span_start1106 := int64(p.spanStart()) + span_start1143 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sum") - _t1923 := p.parse_type() - type1105 := _t1923 + _t1997 := p.parse_type() + type1142 := _t1997 p.consumeLiteral(")") - _t1924 := &pb.SumMonoid{Type: type1105} - result1107 := _t1924 - p.recordSpan(int(span_start1106), "SumMonoid") - return result1107 + _t1998 := &pb.SumMonoid{Type: type1142} + result1144 := _t1998 + p.recordSpan(int(span_start1143), "SumMonoid") + return result1144 } func (p *Parser) parse_monus_def() *pb.MonusDef { -<<<<<<< HEAD - span_start1112 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("monus") - _t1925 := p.parse_monoid() - monoid1108 := _t1925 - _t1926 := p.parse_relation_id() - relation_id1109 := _t1926 - _t1927 := p.parse_abstraction_with_arity() - abstraction_with_arity1110 := _t1927 - var _t1928 []*pb.Attribute - if p.matchLookaheadLiteral("(", 0) { - _t1929 := p.parse_attrs() - _t1928 = _t1929 - } - attrs1111 := _t1928 - p.consumeLiteral(")") - _t1930 := attrs1111 - if attrs1111 == nil { - _t1930 = []*pb.Attribute{} - } - _t1931 := &pb.MonusDef{Monoid: monoid1108, Name: relation_id1109, Body: abstraction_with_arity1110[0].(*pb.Abstraction), Attrs: _t1930, ValueArity: abstraction_with_arity1110[1].(int64)} - result1113 := _t1931 - p.recordSpan(int(span_start1112), "MonusDef") - return result1113 -} - -func (p *Parser) parse_constraint() *pb.Constraint { - span_start1118 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("functional_dependency") - _t1932 := p.parse_relation_id() - relation_id1114 := _t1932 - _t1933 := p.parse_abstraction() - abstraction1115 := _t1933 - _t1934 := p.parse_functional_dependency_keys() - functional_dependency_keys1116 := _t1934 - _t1935 := p.parse_functional_dependency_values() - functional_dependency_values1117 := _t1935 - p.consumeLiteral(")") - _t1936 := &pb.FunctionalDependency{Guard: abstraction1115, Keys: functional_dependency_keys1116, Values: functional_dependency_values1117} - _t1937 := &pb.Constraint{Name: relation_id1114} - _t1937.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t1936} - result1119 := _t1937 - p.recordSpan(int(span_start1118), "Constraint") - return result1119 -======= - span_start1146 := int64(p.spanStart()) + span_start1149 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("monus") - _t1993 := p.parse_monoid() - monoid1142 := _t1993 - _t1994 := p.parse_relation_id() - relation_id1143 := _t1994 - _t1995 := p.parse_abstraction_with_arity() - abstraction_with_arity1144 := _t1995 - var _t1996 []*pb.Attribute + _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 if p.matchLookaheadLiteral("(", 0) { - _t1997 := p.parse_attrs() - _t1996 = _t1997 + _t2003 := p.parse_attrs() + _t2002 = _t2003 } - attrs1145 := _t1996 + attrs1148 := _t2002 p.consumeLiteral(")") - _t1998 := attrs1145 - if attrs1145 == nil { - _t1998 = []*pb.Attribute{} + _t2004 := attrs1148 + if attrs1148 == nil { + _t2004 = []*pb.Attribute{} } - _t1999 := &pb.MonusDef{Monoid: monoid1142, Name: relation_id1143, Body: abstraction_with_arity1144[0].(*pb.Abstraction), Attrs: _t1998, ValueArity: abstraction_with_arity1144[1].(int64)} - result1147 := _t1999 - p.recordSpan(int(span_start1146), "MonusDef") - return result1147 + _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 } func (p *Parser) parse_constraint() *pb.Constraint { - span_start1152 := int64(p.spanStart()) + span_start1155 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("functional_dependency") - _t2000 := p.parse_relation_id() - relation_id1148 := _t2000 - _t2001 := p.parse_abstraction() - abstraction1149 := _t2001 - _t2002 := p.parse_functional_dependency_keys() - functional_dependency_keys1150 := _t2002 - _t2003 := p.parse_functional_dependency_values() - functional_dependency_values1151 := _t2003 - p.consumeLiteral(")") - _t2004 := &pb.FunctionalDependency{Guard: abstraction1149, Keys: functional_dependency_keys1150, Values: functional_dependency_values1151} - _t2005 := &pb.Constraint{Name: relation_id1148} - _t2005.ConstraintType = &pb.Constraint_FunctionalDependency{FunctionalDependency: _t2004} - result1153 := _t2005 - p.recordSpan(int(span_start1152), "Constraint") - return result1153 ->>>>>>> origin/main + _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 + 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 } func (p *Parser) parse_functional_dependency_keys() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("keys") -<<<<<<< HEAD - xs1120 := []*pb.Var{} - cond1121 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1121 { - _t1938 := p.parse_var() - item1122 := _t1938 - xs1120 = append(xs1120, item1122) - cond1121 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1123 := xs1120 - p.consumeLiteral(")") - return vars1123 -======= - xs1154 := []*pb.Var{} - cond1155 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1155 { - _t2006 := p.parse_var() - item1156 := _t2006 - xs1154 = append(xs1154, item1156) - cond1155 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1157 := xs1154 + 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 p.consumeLiteral(")") - return vars1157 ->>>>>>> origin/main + return vars1160 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") -<<<<<<< HEAD - xs1124 := []*pb.Var{} - cond1125 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1125 { - _t1939 := p.parse_var() - item1126 := _t1939 - xs1124 = append(xs1124, item1126) - cond1125 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1127 := xs1124 - p.consumeLiteral(")") - return vars1127 -} - -func (p *Parser) parse_data() *pb.Data { - span_start1133 := int64(p.spanStart()) - var _t1940 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t1941 int64 - if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1941 = 3 - } else { - var _t1942 int64 - if p.matchLookaheadLiteral("edb", 1) { - _t1942 = 0 - } else { - var _t1943 int64 - if p.matchLookaheadLiteral("csv_data", 1) { - _t1943 = 2 - } else { - var _t1944 int64 - if p.matchLookaheadLiteral("betree_relation", 1) { - _t1944 = 1 - } else { - _t1944 = -1 - } - _t1943 = _t1944 - } - _t1942 = _t1943 - } - _t1941 = _t1942 - } - _t1940 = _t1941 - } else { - _t1940 = -1 - } - prediction1128 := _t1940 - var _t1945 *pb.Data - if prediction1128 == 3 { - _t1946 := p.parse_iceberg_data() - iceberg_data1132 := _t1946 - _t1947 := &pb.Data{} - _t1947.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1132} - _t1945 = _t1947 - } else { - var _t1948 *pb.Data - if prediction1128 == 2 { - _t1949 := p.parse_csv_data() - csv_data1131 := _t1949 - _t1950 := &pb.Data{} - _t1950.DataType = &pb.Data_CsvData{CsvData: csv_data1131} - _t1948 = _t1950 - } else { - var _t1951 *pb.Data - if prediction1128 == 1 { - _t1952 := p.parse_betree_relation() - betree_relation1130 := _t1952 - _t1953 := &pb.Data{} - _t1953.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1130} - _t1951 = _t1953 - } else { - var _t1954 *pb.Data - if prediction1128 == 0 { - _t1955 := p.parse_edb() - edb1129 := _t1955 - _t1956 := &pb.Data{} - _t1956.DataType = &pb.Data_Edb{Edb: edb1129} - _t1954 = _t1956 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1951 = _t1954 - } - _t1948 = _t1951 - } - _t1945 = _t1948 + 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) } - result1134 := _t1945 - p.recordSpan(int(span_start1133), "Data") - return result1134 -} - -func (p *Parser) parse_edb() *pb.EDB { - span_start1138 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("edb") - _t1957 := p.parse_relation_id() - relation_id1135 := _t1957 - _t1958 := p.parse_edb_path() - edb_path1136 := _t1958 - _t1959 := p.parse_edb_types() - edb_types1137 := _t1959 + vars1164 := xs1161 p.consumeLiteral(")") - _t1960 := &pb.EDB{TargetId: relation_id1135, Path: edb_path1136, Types: edb_types1137} - result1139 := _t1960 - p.recordSpan(int(span_start1138), "EDB") - return result1139 -======= - xs1158 := []*pb.Var{} - cond1159 := p.matchLookaheadTerminal("SYMBOL", 0) - for cond1159 { - _t2007 := p.parse_var() - item1160 := _t2007 - xs1158 = append(xs1158, item1160) - cond1159 = p.matchLookaheadTerminal("SYMBOL", 0) - } - vars1161 := xs1158 - p.consumeLiteral(")") - return vars1161 + return vars1164 } func (p *Parser) parse_data() *pb.Data { - span_start1167 := int64(p.spanStart()) - var _t2008 int64 + span_start1170 := int64(p.spanStart()) + var _t2014 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2009 int64 + var _t2015 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t2009 = 3 + _t2015 = 3 } else { - var _t2010 int64 + var _t2016 int64 if p.matchLookaheadLiteral("edb", 1) { - _t2010 = 0 + _t2016 = 0 } else { - var _t2011 int64 + var _t2017 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t2011 = 2 + _t2017 = 2 } else { - var _t2012 int64 + var _t2018 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t2012 = 1 + _t2018 = 1 } else { - _t2012 = -1 + _t2018 = -1 } - _t2011 = _t2012 + _t2017 = _t2018 } - _t2010 = _t2011 + _t2016 = _t2017 } - _t2009 = _t2010 + _t2015 = _t2016 } - _t2008 = _t2009 + _t2014 = _t2015 } else { - _t2008 = -1 - } - prediction1162 := _t2008 - var _t2013 *pb.Data - if prediction1162 == 3 { - _t2014 := p.parse_iceberg_data() - iceberg_data1166 := _t2014 - _t2015 := &pb.Data{} - _t2015.DataType = &pb.Data_IcebergData{IcebergData: iceberg_data1166} - _t2013 = _t2015 + _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 } else { - var _t2016 *pb.Data - if prediction1162 == 2 { - _t2017 := p.parse_csv_data() - csv_data1165 := _t2017 - _t2018 := &pb.Data{} - _t2018.DataType = &pb.Data_CsvData{CsvData: csv_data1165} - _t2016 = _t2018 + 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 } else { - var _t2019 *pb.Data - if prediction1162 == 1 { - _t2020 := p.parse_betree_relation() - betree_relation1164 := _t2020 - _t2021 := &pb.Data{} - _t2021.DataType = &pb.Data_BetreeRelation{BetreeRelation: betree_relation1164} - _t2019 = _t2021 + 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 } else { - var _t2022 *pb.Data - if prediction1162 == 0 { - _t2023 := p.parse_edb() - edb1163 := _t2023 - _t2024 := &pb.Data{} - _t2024.DataType = &pb.Data_Edb{Edb: edb1163} - _t2022 = _t2024 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in data", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2019 = _t2022 + _t2025 = _t2028 } - _t2016 = _t2019 + _t2022 = _t2025 } - _t2013 = _t2016 + _t2019 = _t2022 } - result1168 := _t2013 - p.recordSpan(int(span_start1167), "Data") - return result1168 + result1171 := _t2019 + p.recordSpan(int(span_start1170), "Data") + return result1171 } func (p *Parser) parse_edb() *pb.EDB { - span_start1172 := int64(p.spanStart()) + span_start1175 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("edb") - _t2025 := p.parse_relation_id() - relation_id1169 := _t2025 - _t2026 := p.parse_edb_path() - edb_path1170 := _t2026 - _t2027 := p.parse_edb_types() - edb_types1171 := _t2027 + _t2031 := p.parse_relation_id() + relation_id1172 := _t2031 + _t2032 := p.parse_edb_path() + edb_path1173 := _t2032 + _t2033 := p.parse_edb_types() + edb_types1174 := _t2033 p.consumeLiteral(")") - _t2028 := &pb.EDB{TargetId: relation_id1169, Path: edb_path1170, Types: edb_types1171} - result1173 := _t2028 - p.recordSpan(int(span_start1172), "EDB") - return result1173 ->>>>>>> origin/main + _t2034 := &pb.EDB{TargetId: relation_id1172, Path: edb_path1173, Types: edb_types1174} + result1176 := _t2034 + p.recordSpan(int(span_start1175), "EDB") + return result1176 } func (p *Parser) parse_edb_path() []string { p.consumeLiteral("[") -<<<<<<< HEAD - xs1140 := []string{} - cond1141 := p.matchLookaheadTerminal("STRING", 0) - for cond1141 { - item1142 := p.consumeTerminal("STRING").Value.str - xs1140 = append(xs1140, item1142) - cond1141 = p.matchLookaheadTerminal("STRING", 0) - } - strings1143 := xs1140 - p.consumeLiteral("]") - return strings1143 -======= - xs1174 := []string{} - cond1175 := p.matchLookaheadTerminal("STRING", 0) - for cond1175 { - item1176 := p.consumeTerminal("STRING").Value.str - xs1174 = append(xs1174, item1176) - cond1175 = p.matchLookaheadTerminal("STRING", 0) - } - strings1177 := xs1174 + 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 p.consumeLiteral("]") - return strings1177 ->>>>>>> origin/main + return strings1180 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") -<<<<<<< HEAD - xs1144 := []*pb.Type{} - cond1145 := (((((((((((((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 cond1145 { - _t1961 := p.parse_type() - item1146 := _t1961 - xs1144 = append(xs1144, item1146) - cond1145 = (((((((((((((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)) - } - types1147 := xs1144 - p.consumeLiteral("]") - return types1147 -} - -func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { - span_start1150 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("betree_relation") - _t1962 := p.parse_relation_id() - relation_id1148 := _t1962 - _t1963 := p.parse_betree_info() - betree_info1149 := _t1963 - p.consumeLiteral(")") - _t1964 := &pb.BeTreeRelation{Name: relation_id1148, RelationInfo: betree_info1149} - result1151 := _t1964 - p.recordSpan(int(span_start1150), "BeTreeRelation") - return result1151 -} - -func (p *Parser) parse_betree_info() *pb.BeTreeInfo { - span_start1155 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("betree_info") - _t1965 := p.parse_betree_info_key_types() - betree_info_key_types1152 := _t1965 - _t1966 := p.parse_betree_info_value_types() - betree_info_value_types1153 := _t1966 - _t1967 := p.parse_config_dict() - config_dict1154 := _t1967 - p.consumeLiteral(")") - _t1968 := p.construct_betree_info(betree_info_key_types1152, betree_info_value_types1153, config_dict1154) - result1156 := _t1968 - p.recordSpan(int(span_start1155), "BeTreeInfo") - return result1156 -======= - xs1178 := []*pb.Type{} - cond1179 := (((((((((((((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 cond1179 { - _t2029 := p.parse_type() - item1180 := _t2029 - xs1178 = append(xs1178, item1180) - cond1179 = (((((((((((((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)) - } - types1181 := xs1178 + 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 p.consumeLiteral("]") - return types1181 + return types1184 } func (p *Parser) parse_betree_relation() *pb.BeTreeRelation { - span_start1184 := int64(p.spanStart()) + span_start1187 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_relation") - _t2030 := p.parse_relation_id() - relation_id1182 := _t2030 - _t2031 := p.parse_betree_info() - betree_info1183 := _t2031 + _t2036 := p.parse_relation_id() + relation_id1185 := _t2036 + _t2037 := p.parse_betree_info() + betree_info1186 := _t2037 p.consumeLiteral(")") - _t2032 := &pb.BeTreeRelation{Name: relation_id1182, RelationInfo: betree_info1183} - result1185 := _t2032 - p.recordSpan(int(span_start1184), "BeTreeRelation") - return result1185 + _t2038 := &pb.BeTreeRelation{Name: relation_id1185, RelationInfo: betree_info1186} + result1188 := _t2038 + p.recordSpan(int(span_start1187), "BeTreeRelation") + return result1188 } func (p *Parser) parse_betree_info() *pb.BeTreeInfo { - span_start1189 := int64(p.spanStart()) + span_start1192 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("betree_info") - _t2033 := p.parse_betree_info_key_types() - betree_info_key_types1186 := _t2033 - _t2034 := p.parse_betree_info_value_types() - betree_info_value_types1187 := _t2034 - _t2035 := p.parse_config_dict() - config_dict1188 := _t2035 + _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 p.consumeLiteral(")") - _t2036 := p.construct_betree_info(betree_info_key_types1186, betree_info_value_types1187, config_dict1188) - result1190 := _t2036 - p.recordSpan(int(span_start1189), "BeTreeInfo") - return result1190 ->>>>>>> origin/main + _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 } func (p *Parser) parse_betree_info_key_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("key_types") -<<<<<<< HEAD - xs1157 := []*pb.Type{} - cond1158 := (((((((((((((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 cond1158 { - _t1969 := p.parse_type() - item1159 := _t1969 - xs1157 = append(xs1157, item1159) - cond1158 = (((((((((((((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)) + 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)) } - types1160 := xs1157 + types1197 := xs1194 p.consumeLiteral(")") - return types1160 -======= - xs1191 := []*pb.Type{} - cond1192 := (((((((((((((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 cond1192 { - _t2037 := p.parse_type() - item1193 := _t2037 - xs1191 = append(xs1191, item1193) - cond1192 = (((((((((((((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)) - } - types1194 := xs1191 - p.consumeLiteral(")") - return types1194 ->>>>>>> origin/main + return types1197 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") -<<<<<<< HEAD - xs1161 := []*pb.Type{} - cond1162 := (((((((((((((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 cond1162 { - _t1970 := p.parse_type() - item1163 := _t1970 - xs1161 = append(xs1161, item1163) - cond1162 = (((((((((((((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)) - } - types1164 := xs1161 - p.consumeLiteral(")") - return types1164 -} - -func (p *Parser) parse_csv_data() *pb.CSVData { - span_start1169 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("csv_data") - _t1971 := p.parse_csvlocator() - csvlocator1165 := _t1971 - _t1972 := p.parse_csv_config() - csv_config1166 := _t1972 - _t1973 := p.parse_gnf_columns() - gnf_columns1167 := _t1973 - _t1974 := p.parse_csv_asof() - csv_asof1168 := _t1974 - p.consumeLiteral(")") - _t1975 := &pb.CSVData{Locator: csvlocator1165, Config: csv_config1166, Columns: gnf_columns1167, Asof: csv_asof1168} - result1170 := _t1975 - p.recordSpan(int(span_start1169), "CSVData") - return result1170 -} - -func (p *Parser) parse_csvlocator() *pb.CSVLocator { - span_start1173 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("csv_locator") - var _t1976 []string - if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t1977 := p.parse_csv_locator_paths() - _t1976 = _t1977 - } - csv_locator_paths1171 := _t1976 - var _t1978 *string - if p.matchLookaheadLiteral("(", 0) { - _t1979 := p.parse_csv_locator_inline_data() - _t1978 = ptr(_t1979) + 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)) } - csv_locator_inline_data1172 := _t1978 - p.consumeLiteral(")") - _t1980 := csv_locator_paths1171 - if csv_locator_paths1171 == nil { - _t1980 = []string{} - } - _t1981 := &pb.CSVLocator{Paths: _t1980, InlineData: []byte(deref(csv_locator_inline_data1172, ""))} - result1174 := _t1981 - p.recordSpan(int(span_start1173), "CSVLocator") - return result1174 -======= - 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 { - _t2038 := p.parse_type() - item1197 := _t2038 - 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 + types1201 := xs1198 p.consumeLiteral(")") - return types1198 + return types1201 } func (p *Parser) parse_csv_data() *pb.CSVData { - span_start1204 := int64(p.spanStart()) + span_start1207 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_data") - _t2039 := p.parse_csvlocator() - csvlocator1199 := _t2039 - _t2040 := p.parse_csv_config() - csv_config1200 := _t2040 - var _t2041 []*pb.GNFColumn + _t2045 := p.parse_csvlocator() + csvlocator1202 := _t2045 + _t2046 := p.parse_csv_config() + csv_config1203 := _t2046 + var _t2047 []*pb.GNFColumn if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("columns", 1)) { - _t2042 := p.parse_gnf_columns() - _t2041 = _t2042 + _t2048 := p.parse_gnf_columns() + _t2047 = _t2048 } - gnf_columns1201 := _t2041 - var _t2043 *pb.TargetRelations + gnf_columns1204 := _t2047 + var _t2049 *pb.TargetRelations if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("relations", 1)) { - _t2044 := p.parse_target_relations() - _t2043 = _t2044 + _t2050 := p.parse_target_relations() + _t2049 = _t2050 } - target_relations1202 := _t2043 - _t2045 := p.parse_csv_asof() - csv_asof1203 := _t2045 + target_relations1205 := _t2049 + _t2051 := p.parse_csv_asof() + csv_asof1206 := _t2051 p.consumeLiteral(")") - _t2046 := p.construct_csv_data(csvlocator1199, csv_config1200, gnf_columns1201, target_relations1202, csv_asof1203) - result1205 := _t2046 - p.recordSpan(int(span_start1204), "CSVData") - return result1205 + _t2052 := p.construct_csv_data(csvlocator1202, csv_config1203, gnf_columns1204, target_relations1205, csv_asof1206) + result1208 := _t2052 + p.recordSpan(int(span_start1207), "CSVData") + return result1208 } func (p *Parser) parse_csvlocator() *pb.CSVLocator { - span_start1208 := int64(p.spanStart()) + span_start1211 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_locator") - var _t2047 []string + var _t2053 []string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("paths", 1)) { - _t2048 := p.parse_csv_locator_paths() - _t2047 = _t2048 + _t2054 := p.parse_csv_locator_paths() + _t2053 = _t2054 } - csv_locator_paths1206 := _t2047 - var _t2049 *string + csv_locator_paths1209 := _t2053 + var _t2055 *string if p.matchLookaheadLiteral("(", 0) { - _t2050 := p.parse_csv_locator_inline_data() - _t2049 = ptr(_t2050) + _t2056 := p.parse_csv_locator_inline_data() + _t2055 = ptr(_t2056) } - csv_locator_inline_data1207 := _t2049 + csv_locator_inline_data1210 := _t2055 p.consumeLiteral(")") - _t2051 := csv_locator_paths1206 - if csv_locator_paths1206 == nil { - _t2051 = []string{} + _t2057 := csv_locator_paths1209 + if csv_locator_paths1209 == nil { + _t2057 = []string{} } - _t2052 := &pb.CSVLocator{Paths: _t2051, InlineData: []byte(deref(csv_locator_inline_data1207, ""))} - result1209 := _t2052 - p.recordSpan(int(span_start1208), "CSVLocator") - return result1209 ->>>>>>> origin/main + _t2058 := &pb.CSVLocator{Paths: _t2057, InlineData: []byte(deref(csv_locator_inline_data1210, ""))} + result1212 := _t2058 + p.recordSpan(int(span_start1211), "CSVLocator") + return result1212 } func (p *Parser) parse_csv_locator_paths() []string { p.consumeLiteral("(") p.consumeLiteral("paths") -<<<<<<< HEAD - xs1175 := []string{} - cond1176 := p.matchLookaheadTerminal("STRING", 0) - for cond1176 { - item1177 := p.consumeTerminal("STRING").Value.str - xs1175 = append(xs1175, item1177) - cond1176 = p.matchLookaheadTerminal("STRING", 0) - } - strings1178 := xs1175 - p.consumeLiteral(")") - return strings1178 -======= - xs1210 := []string{} - cond1211 := p.matchLookaheadTerminal("STRING", 0) - for cond1211 { - item1212 := p.consumeTerminal("STRING").Value.str - xs1210 = append(xs1210, item1212) - cond1211 = p.matchLookaheadTerminal("STRING", 0) - } - strings1213 := xs1210 + 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 p.consumeLiteral(")") - return strings1213 ->>>>>>> origin/main + return strings1216 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") -<<<<<<< HEAD - formatted_string1179 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return formatted_string1179 -} - -func (p *Parser) parse_csv_config() *pb.CSVConfig { - span_start1182 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("csv_config") - _t1982 := p.parse_config_dict() - config_dict1180 := _t1982 - var _t1983 [][]interface{} - if p.matchLookaheadLiteral("(", 0) { - _t1984 := p.parse__storage_integration() - _t1983 = _t1984 - } - _storage_integration1181 := _t1983 + formatted_string1217 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - _t1985 := p.construct_csv_config(config_dict1180, _storage_integration1181) - result1183 := _t1985 - p.recordSpan(int(span_start1182), "CSVConfig") - return result1183 -======= - formatted_string1214 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return formatted_string1214 + return formatted_string1217 } func (p *Parser) parse_csv_config() *pb.CSVConfig { - span_start1217 := int64(p.spanStart()) + span_start1220 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("csv_config") - _t2053 := p.parse_config_dict() - config_dict1215 := _t2053 - var _t2054 [][]interface{} + _t2059 := p.parse_config_dict() + config_dict1218 := _t2059 + var _t2060 [][]interface{} if p.matchLookaheadLiteral("(", 0) { - _t2055 := p.parse__storage_integration() - _t2054 = _t2055 + _t2061 := p.parse__storage_integration() + _t2060 = _t2061 } - _storage_integration1216 := _t2054 - p.consumeLiteral(")") - _t2056 := p.construct_csv_config(config_dict1215, _storage_integration1216) - result1218 := _t2056 - p.recordSpan(int(span_start1217), "CSVConfig") - return result1218 ->>>>>>> origin/main -} - -func (p *Parser) parse__storage_integration() [][]interface{} { - p.consumeLiteral("(") - p.consumeLiteral("storage_integration") -<<<<<<< HEAD - _t1986 := p.parse_config_dict() - config_dict1184 := _t1986 + _storage_integration1219 := _t2060 p.consumeLiteral(")") - return config_dict1184 -======= - _t2057 := p.parse_config_dict() - config_dict1219 := _t2057 - p.consumeLiteral(")") - return config_dict1219 ->>>>>>> origin/main -} - -func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { - p.consumeLiteral("(") - p.consumeLiteral("columns") -<<<<<<< HEAD - xs1185 := []*pb.GNFColumn{} - cond1186 := p.matchLookaheadLiteral("(", 0) - for cond1186 { - _t1987 := p.parse_gnf_column() - item1187 := _t1987 - xs1185 = append(xs1185, item1187) - cond1186 = p.matchLookaheadLiteral("(", 0) - } - gnf_columns1188 := xs1185 - p.consumeLiteral(")") - return gnf_columns1188 + _t2062 := p.construct_csv_config(config_dict1218, _storage_integration1219) + result1221 := _t2062 + p.recordSpan(int(span_start1220), "CSVConfig") + return result1221 } -func (p *Parser) parse_gnf_column() *pb.GNFColumn { - span_start1195 := int64(p.spanStart()) +func (p *Parser) parse__storage_integration() [][]interface{} { p.consumeLiteral("(") - p.consumeLiteral("column") - _t1988 := p.parse_gnf_column_path() - gnf_column_path1189 := _t1988 - var _t1989 *pb.RelationId - if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t1990 := p.parse_relation_id() - _t1989 = _t1990 - } - relation_id1190 := _t1989 - p.consumeLiteral("[") - xs1191 := []*pb.Type{} - cond1192 := (((((((((((((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 cond1192 { - _t1991 := p.parse_type() - item1193 := _t1991 - xs1191 = append(xs1191, item1193) - cond1192 = (((((((((((((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)) - } - types1194 := xs1191 - p.consumeLiteral("]") + p.consumeLiteral("storage_integration") + _t2063 := p.parse_config_dict() + config_dict1222 := _t2063 p.consumeLiteral(")") - _t1992 := &pb.GNFColumn{ColumnPath: gnf_column_path1189, TargetId: relation_id1190, Types: types1194} - result1196 := _t1992 - p.recordSpan(int(span_start1195), "GNFColumn") - return result1196 + return config_dict1222 } -func (p *Parser) parse_gnf_column_path() []string { - var _t1993 int64 - if p.matchLookaheadLiteral("[", 0) { - _t1993 = 1 - } else { - var _t1994 int64 - if p.matchLookaheadTerminal("STRING", 0) { - _t1994 = 0 - } else { - _t1994 = -1 - } - _t1993 = _t1994 +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) } - prediction1197 := _t1993 - var _t1995 []string - if prediction1197 == 1 { - p.consumeLiteral("[") - xs1199 := []string{} - cond1200 := p.matchLookaheadTerminal("STRING", 0) - for cond1200 { - item1201 := p.consumeTerminal("STRING").Value.str - xs1199 = append(xs1199, item1201) - cond1200 = p.matchLookaheadTerminal("STRING", 0) - } - strings1202 := xs1199 - p.consumeLiteral("]") - _t1995 = strings1202 - } else { - var _t1996 []string - if prediction1197 == 0 { - string1198 := p.consumeTerminal("STRING").Value.str - _ = string1198 - _t1996 = []string{string1198} - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t1995 = _t1996 - } - return _t1995 -======= - xs1220 := []*pb.GNFColumn{} - cond1221 := p.matchLookaheadLiteral("(", 0) - for cond1221 { - _t2058 := p.parse_gnf_column() - item1222 := _t2058 - xs1220 = append(xs1220, item1222) - cond1221 = p.matchLookaheadLiteral("(", 0) - } - gnf_columns1223 := xs1220 + gnf_columns1226 := xs1223 p.consumeLiteral(")") - return gnf_columns1223 + return gnf_columns1226 } func (p *Parser) parse_gnf_column() *pb.GNFColumn { - span_start1230 := int64(p.spanStart()) + span_start1233 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - _t2059 := p.parse_gnf_column_path() - gnf_column_path1224 := _t2059 - var _t2060 *pb.RelationId + _t2065 := p.parse_gnf_column_path() + gnf_column_path1227 := _t2065 + var _t2066 *pb.RelationId if (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) { - _t2061 := p.parse_relation_id() - _t2060 = _t2061 + _t2067 := p.parse_relation_id() + _t2066 = _t2067 } - relation_id1225 := _t2060 + relation_id1228 := _t2066 p.consumeLiteral("[") - xs1226 := []*pb.Type{} - cond1227 := (((((((((((((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 cond1227 { - _t2062 := p.parse_type() - item1228 := _t2062 - xs1226 = append(xs1226, item1228) - cond1227 = (((((((((((((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)) - } - types1229 := xs1226 + 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 p.consumeLiteral("]") p.consumeLiteral(")") - _t2063 := &pb.GNFColumn{ColumnPath: gnf_column_path1224, TargetId: relation_id1225, Types: types1229} - result1231 := _t2063 - p.recordSpan(int(span_start1230), "GNFColumn") - return result1231 + _t2069 := &pb.GNFColumn{ColumnPath: gnf_column_path1227, TargetId: relation_id1228, Types: types1232} + result1234 := _t2069 + p.recordSpan(int(span_start1233), "GNFColumn") + return result1234 } func (p *Parser) parse_gnf_column_path() []string { - var _t2064 int64 + var _t2070 int64 if p.matchLookaheadLiteral("[", 0) { - _t2064 = 1 + _t2070 = 1 } else { - var _t2065 int64 + var _t2071 int64 if p.matchLookaheadTerminal("STRING", 0) { - _t2065 = 0 + _t2071 = 0 } else { - _t2065 = -1 + _t2071 = -1 } - _t2064 = _t2065 + _t2070 = _t2071 } - prediction1232 := _t2064 - var _t2066 []string - if prediction1232 == 1 { + prediction1235 := _t2070 + var _t2072 []string + if prediction1235 == 1 { p.consumeLiteral("[") - xs1234 := []string{} - cond1235 := p.matchLookaheadTerminal("STRING", 0) - for cond1235 { - item1236 := p.consumeTerminal("STRING").Value.str - xs1234 = append(xs1234, item1236) - cond1235 = p.matchLookaheadTerminal("STRING", 0) + xs1237 := []string{} + cond1238 := p.matchLookaheadTerminal("STRING", 0) + for cond1238 { + item1239 := p.consumeTerminal("STRING").Value.str + xs1237 = append(xs1237, item1239) + cond1238 = p.matchLookaheadTerminal("STRING", 0) } - strings1237 := xs1234 + strings1240 := xs1237 p.consumeLiteral("]") - _t2066 = strings1237 + _t2072 = strings1240 } else { - var _t2067 []string - if prediction1232 == 0 { - string1233 := p.consumeTerminal("STRING").Value.str - _ = string1233 - _t2067 = []string{string1233} + var _t2073 []string + if prediction1235 == 0 { + string1236 := p.consumeTerminal("STRING").Value.str + _ = string1236 + _t2073 = []string{string1236} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in gnf_column_path", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2066 = _t2067 + _t2072 = _t2073 } - return _t2066 + return _t2072 } func (p *Parser) parse_target_relations() *pb.TargetRelations { - span_start1240 := int64(p.spanStart()) + span_start1243 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relations") - _t2068 := p.parse_relation_keys() - relation_keys1238 := _t2068 - _t2069 := p.parse_relation_body() - relation_body1239 := _t2069 + _t2074 := p.parse_relation_keys() + relation_keys1241 := _t2074 + _t2075 := p.parse_relation_body() + relation_body1242 := _t2075 p.consumeLiteral(")") - _t2070 := p.construct_relations(relation_keys1238, relation_body1239) - result1241 := _t2070 - p.recordSpan(int(span_start1240), "TargetRelations") - return result1241 + _t2076 := p.construct_relations(relation_keys1241, relation_body1242) + result1244 := _t2076 + p.recordSpan(int(span_start1243), "TargetRelations") + return result1244 } func (p *Parser) parse_relation_keys() []*pb.NamedColumn { p.consumeLiteral("(") p.consumeLiteral("keys") - xs1242 := []*pb.NamedColumn{} - cond1243 := p.matchLookaheadLiteral("(", 0) - for cond1243 { - _t2071 := p.parse_named_column() - item1244 := _t2071 - xs1242 = append(xs1242, item1244) - cond1243 = p.matchLookaheadLiteral("(", 0) - } - named_columns1245 := xs1242 + 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_columns1245 + return named_columns1248 } func (p *Parser) parse_named_column() *pb.NamedColumn { - span_start1248 := int64(p.spanStart()) + span_start1251 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1246 := p.consumeTerminal("STRING").Value.str - _t2072 := p.parse_type() - type1247 := _t2072 + string1249 := p.consumeTerminal("STRING").Value.str + _t2078 := p.parse_type() + type1250 := _t2078 p.consumeLiteral(")") - _t2073 := &pb.NamedColumn{Name: string1246, Type: type1247} - result1249 := _t2073 - p.recordSpan(int(span_start1248), "NamedColumn") - return result1249 + _t2079 := &pb.NamedColumn{Name: string1249, Type: type1250} + result1252 := _t2079 + p.recordSpan(int(span_start1251), "NamedColumn") + return result1252 } func (p *Parser) parse_relation_body() *pb.TargetRelations { - span_start1254 := int64(p.spanStart()) - var _t2074 int64 + span_start1257 := int64(p.spanStart()) + var _t2080 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2075 int64 + var _t2081 int64 if p.matchLookaheadLiteral("relation", 1) { - _t2075 = 0 + _t2081 = 0 } else { - var _t2076 int64 + var _t2082 int64 if p.matchLookaheadLiteral("inserts", 1) { - _t2076 = 1 + _t2082 = 1 } else { - _t2076 = 0 + _t2082 = 0 } - _t2075 = _t2076 + _t2081 = _t2082 } - _t2074 = _t2075 + _t2080 = _t2081 } else { - _t2074 = 0 - } - prediction1250 := _t2074 - var _t2077 *pb.TargetRelations - if prediction1250 == 1 { - _t2078 := p.parse_cdc_inserts() - cdc_inserts1252 := _t2078 - _t2079 := p.parse_cdc_deletes() - cdc_deletes1253 := _t2079 - _t2080 := p.construct_cdc_relations(cdc_inserts1252, cdc_deletes1253) - _t2077 = _t2080 + _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 } else { - var _t2081 *pb.TargetRelations - if prediction1250 == 0 { - _t2082 := p.parse_non_cdc_relations() - non_cdc_relations1251 := _t2082 - _t2083 := p.construct_non_cdc_relations(non_cdc_relations1251) - _t2081 = _t2083 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in relation_body", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2077 = _t2081 + _t2083 = _t2087 } - result1255 := _t2077 - p.recordSpan(int(span_start1254), "TargetRelations") - return result1255 + result1258 := _t2083 + p.recordSpan(int(span_start1257), "TargetRelations") + return result1258 } func (p *Parser) parse_non_cdc_relations() []*pb.TargetRelation { - xs1256 := []*pb.TargetRelation{} - cond1257 := p.matchLookaheadLiteral("(", 0) - for cond1257 { - _t2084 := p.parse_target_relation() - item1258 := _t2084 - xs1256 = append(xs1256, item1258) - cond1257 = p.matchLookaheadLiteral("(", 0) + 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 xs1256 + return xs1259 } func (p *Parser) parse_target_relation() *pb.TargetRelation { - span_start1264 := int64(p.spanStart()) + span_start1267 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("relation") - _t2085 := p.parse_relation_id() - relation_id1259 := _t2085 - xs1260 := []*pb.NamedColumn{} - cond1261 := p.matchLookaheadLiteral("(", 0) - for cond1261 { - _t2086 := p.parse_named_column() - item1262 := _t2086 - xs1260 = append(xs1260, item1262) - cond1261 = p.matchLookaheadLiteral("(", 0) - } - named_columns1263 := xs1260 + _t2091 := p.parse_relation_id() + relation_id1262 := _t2091 + xs1263 := []*pb.NamedColumn{} + cond1264 := p.matchLookaheadLiteral("(", 0) + for cond1264 { + _t2092 := p.parse_named_column() + item1265 := _t2092 + xs1263 = append(xs1263, item1265) + cond1264 = p.matchLookaheadLiteral("(", 0) + } + named_columns1266 := xs1263 p.consumeLiteral(")") - _t2087 := &pb.TargetRelation{TargetId: relation_id1259, Values: named_columns1263} - result1265 := _t2087 - p.recordSpan(int(span_start1264), "TargetRelation") - return result1265 + _t2093 := &pb.TargetRelation{TargetId: relation_id1262, Values: named_columns1266} + result1268 := _t2093 + p.recordSpan(int(span_start1267), "TargetRelation") + return result1268 } func (p *Parser) parse_cdc_inserts() []*pb.TargetRelation { p.consumeLiteral("(") p.consumeLiteral("inserts") - xs1266 := []*pb.TargetRelation{} - cond1267 := p.matchLookaheadLiteral("(", 0) - for cond1267 { - _t2088 := p.parse_target_relation() - item1268 := _t2088 - xs1266 = append(xs1266, item1268) - cond1267 = p.matchLookaheadLiteral("(", 0) - } - target_relations1269 := xs1266 + 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(")") - return target_relations1269 + return target_relations1272 } func (p *Parser) parse_cdc_deletes() []*pb.TargetRelation { p.consumeLiteral("(") p.consumeLiteral("deletes") - xs1270 := []*pb.TargetRelation{} - cond1271 := p.matchLookaheadLiteral("(", 0) - for cond1271 { - _t2089 := p.parse_target_relation() - item1272 := _t2089 - xs1270 = append(xs1270, item1272) - cond1271 = p.matchLookaheadLiteral("(", 0) - } - target_relations1273 := xs1270 + xs1273 := []*pb.TargetRelation{} + cond1274 := p.matchLookaheadLiteral("(", 0) + for cond1274 { + _t2095 := p.parse_target_relation() + item1275 := _t2095 + xs1273 = append(xs1273, item1275) + cond1274 = p.matchLookaheadLiteral("(", 0) + } + target_relations1276 := xs1273 p.consumeLiteral(")") - return target_relations1273 ->>>>>>> origin/main + return target_relations1276 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") -<<<<<<< HEAD - string1203 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1203 -} - -func (p *Parser) parse_iceberg_data() *pb.IcebergData { - span_start1210 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("iceberg_data") - _t1997 := p.parse_iceberg_locator() - iceberg_locator1204 := _t1997 - _t1998 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1205 := _t1998 - _t1999 := p.parse_gnf_columns() - gnf_columns1206 := _t1999 - var _t2000 *string - if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("from_snapshot", 1)) { - _t2001 := p.parse_iceberg_from_snapshot() - _t2000 = ptr(_t2001) - } - iceberg_from_snapshot1207 := _t2000 - var _t2002 *string - if p.matchLookaheadLiteral("(", 0) { - _t2003 := p.parse_iceberg_to_snapshot() - _t2002 = ptr(_t2003) - } - iceberg_to_snapshot1208 := _t2002 - _t2004 := p.parse_boolean_value() - boolean_value1209 := _t2004 - p.consumeLiteral(")") - _t2005 := p.construct_iceberg_data(iceberg_locator1204, iceberg_catalog_config1205, gnf_columns1206, iceberg_from_snapshot1207, iceberg_to_snapshot1208, boolean_value1209) - result1211 := _t2005 - p.recordSpan(int(span_start1210), "IcebergData") - return result1211 -} - -func (p *Parser) parse_iceberg_locator() *pb.IcebergLocator { - span_start1215 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("iceberg_locator") - _t2006 := p.parse_iceberg_locator_table_name() - iceberg_locator_table_name1212 := _t2006 - _t2007 := p.parse_iceberg_locator_namespace() - iceberg_locator_namespace1213 := _t2007 - _t2008 := p.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1214 := _t2008 - p.consumeLiteral(")") - _t2009 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1212, Namespace: iceberg_locator_namespace1213, Warehouse: iceberg_locator_warehouse1214} - result1216 := _t2009 - p.recordSpan(int(span_start1215), "IcebergLocator") - return result1216 -======= - string1274 := p.consumeTerminal("STRING").Value.str + string1277 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1274 + return string1277 } func (p *Parser) parse_iceberg_data() *pb.IcebergData { - span_start1281 := int64(p.spanStart()) + span_start1284 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_data") - _t2090 := p.parse_iceberg_locator() - iceberg_locator1275 := _t2090 - _t2091 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1276 := _t2091 - _t2092 := p.parse_gnf_columns() - gnf_columns1277 := _t2092 - var _t2093 *string + _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 if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("from_snapshot", 1)) { - _t2094 := p.parse_iceberg_from_snapshot() - _t2093 = ptr(_t2094) + _t2100 := p.parse_iceberg_from_snapshot() + _t2099 = ptr(_t2100) } - iceberg_from_snapshot1278 := _t2093 - var _t2095 *string + iceberg_from_snapshot1281 := _t2099 + var _t2101 *string if p.matchLookaheadLiteral("(", 0) { - _t2096 := p.parse_iceberg_to_snapshot() - _t2095 = ptr(_t2096) + _t2102 := p.parse_iceberg_to_snapshot() + _t2101 = ptr(_t2102) } - iceberg_to_snapshot1279 := _t2095 - _t2097 := p.parse_boolean_value() - boolean_value1280 := _t2097 + iceberg_to_snapshot1282 := _t2101 + _t2103 := p.parse_boolean_value() + boolean_value1283 := _t2103 p.consumeLiteral(")") - _t2098 := p.construct_iceberg_data(iceberg_locator1275, iceberg_catalog_config1276, gnf_columns1277, iceberg_from_snapshot1278, iceberg_to_snapshot1279, boolean_value1280) - result1282 := _t2098 - p.recordSpan(int(span_start1281), "IcebergData") - return result1282 + _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 } func (p *Parser) parse_iceberg_locator() *pb.IcebergLocator { - span_start1286 := int64(p.spanStart()) + span_start1289 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_locator") - _t2099 := p.parse_iceberg_locator_table_name() - iceberg_locator_table_name1283 := _t2099 - _t2100 := p.parse_iceberg_locator_namespace() - iceberg_locator_namespace1284 := _t2100 - _t2101 := p.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1285 := _t2101 + _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 p.consumeLiteral(")") - _t2102 := &pb.IcebergLocator{TableName: iceberg_locator_table_name1283, Namespace: iceberg_locator_namespace1284, Warehouse: iceberg_locator_warehouse1285} - result1287 := _t2102 - p.recordSpan(int(span_start1286), "IcebergLocator") - return result1287 ->>>>>>> origin/main + _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 } func (p *Parser) parse_iceberg_locator_table_name() string { p.consumeLiteral("(") p.consumeLiteral("table_name") -<<<<<<< HEAD - string1217 := p.consumeTerminal("STRING").Value.str + string1291 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1217 -======= - string1288 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1288 ->>>>>>> origin/main + return string1291 } func (p *Parser) parse_iceberg_locator_namespace() []string { p.consumeLiteral("(") p.consumeLiteral("namespace") -<<<<<<< HEAD - xs1218 := []string{} - cond1219 := p.matchLookaheadTerminal("STRING", 0) - for cond1219 { - item1220 := p.consumeTerminal("STRING").Value.str - xs1218 = append(xs1218, item1220) - cond1219 = p.matchLookaheadTerminal("STRING", 0) - } - strings1221 := xs1218 - p.consumeLiteral(")") - return strings1221 -======= - xs1289 := []string{} - cond1290 := p.matchLookaheadTerminal("STRING", 0) - for cond1290 { - item1291 := p.consumeTerminal("STRING").Value.str - xs1289 = append(xs1289, item1291) - cond1290 = p.matchLookaheadTerminal("STRING", 0) - } - strings1292 := xs1289 + 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 p.consumeLiteral(")") - return strings1292 ->>>>>>> origin/main + return strings1295 } func (p *Parser) parse_iceberg_locator_warehouse() string { p.consumeLiteral("(") p.consumeLiteral("warehouse") -<<<<<<< HEAD - string1222 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1222 -} - -func (p *Parser) parse_iceberg_catalog_config() *pb.IcebergCatalogConfig { - span_start1227 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("iceberg_catalog_config") - _t2010 := p.parse_iceberg_catalog_uri() - iceberg_catalog_uri1223 := _t2010 - var _t2011 *string - if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("scope", 1)) { - _t2012 := p.parse_iceberg_catalog_config_scope() - _t2011 = ptr(_t2012) - } - iceberg_catalog_config_scope1224 := _t2011 - _t2013 := p.parse_iceberg_properties() - iceberg_properties1225 := _t2013 - _t2014 := p.parse_iceberg_auth_properties() - iceberg_auth_properties1226 := _t2014 + string1296 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - _t2015 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1223, iceberg_catalog_config_scope1224, iceberg_properties1225, iceberg_auth_properties1226) - result1228 := _t2015 - p.recordSpan(int(span_start1227), "IcebergCatalogConfig") - return result1228 -======= - string1293 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1293 + return string1296 } func (p *Parser) parse_iceberg_catalog_config() *pb.IcebergCatalogConfig { - span_start1298 := int64(p.spanStart()) + span_start1301 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("iceberg_catalog_config") - _t2103 := p.parse_iceberg_catalog_uri() - iceberg_catalog_uri1294 := _t2103 - var _t2104 *string + _t2109 := p.parse_iceberg_catalog_uri() + iceberg_catalog_uri1297 := _t2109 + var _t2110 *string if (p.matchLookaheadLiteral("(", 0) && p.matchLookaheadLiteral("scope", 1)) { - _t2105 := p.parse_iceberg_catalog_config_scope() - _t2104 = ptr(_t2105) - } - iceberg_catalog_config_scope1295 := _t2104 - _t2106 := p.parse_iceberg_properties() - iceberg_properties1296 := _t2106 - _t2107 := p.parse_iceberg_auth_properties() - iceberg_auth_properties1297 := _t2107 + _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 p.consumeLiteral(")") - _t2108 := p.construct_iceberg_catalog_config(iceberg_catalog_uri1294, iceberg_catalog_config_scope1295, iceberg_properties1296, iceberg_auth_properties1297) - result1299 := _t2108 - p.recordSpan(int(span_start1298), "IcebergCatalogConfig") - return result1299 ->>>>>>> origin/main + _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 } func (p *Parser) parse_iceberg_catalog_uri() string { p.consumeLiteral("(") p.consumeLiteral("catalog_uri") -<<<<<<< HEAD - string1229 := p.consumeTerminal("STRING").Value.str + string1303 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1229 -======= - string1300 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1300 ->>>>>>> origin/main + return string1303 } func (p *Parser) parse_iceberg_catalog_config_scope() string { p.consumeLiteral("(") p.consumeLiteral("scope") -<<<<<<< HEAD - string1230 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1230 -======= - string1301 := p.consumeTerminal("STRING").Value.str + string1304 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1301 ->>>>>>> origin/main + return string1304 } func (p *Parser) parse_iceberg_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("properties") -<<<<<<< HEAD - xs1231 := [][]interface{}{} - cond1232 := p.matchLookaheadLiteral("(", 0) - for cond1232 { - _t2016 := p.parse_iceberg_property_entry() - item1233 := _t2016 - xs1231 = append(xs1231, item1233) - cond1232 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1234 := xs1231 - p.consumeLiteral(")") - return iceberg_property_entrys1234 -======= - xs1302 := [][]interface{}{} - cond1303 := p.matchLookaheadLiteral("(", 0) - for cond1303 { - _t2109 := p.parse_iceberg_property_entry() - item1304 := _t2109 - xs1302 = append(xs1302, item1304) - cond1303 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1305 := xs1302 + 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 p.consumeLiteral(")") - return iceberg_property_entrys1305 ->>>>>>> origin/main + return iceberg_property_entrys1308 } func (p *Parser) parse_iceberg_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") -<<<<<<< HEAD - string1235 := p.consumeTerminal("STRING").Value.str - string_31236 := p.consumeTerminal("STRING").Value.str + string1309 := p.consumeTerminal("STRING").Value.str + string_31310 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1235, string_31236} -======= - string1306 := p.consumeTerminal("STRING").Value.str - string_31307 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return []interface{}{string1306, string_31307} ->>>>>>> origin/main + return []interface{}{string1309, string_31310} } func (p *Parser) parse_iceberg_auth_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("auth_properties") -<<<<<<< HEAD - xs1237 := [][]interface{}{} - cond1238 := p.matchLookaheadLiteral("(", 0) - for cond1238 { - _t2017 := p.parse_iceberg_masked_property_entry() - item1239 := _t2017 - xs1237 = append(xs1237, item1239) - cond1238 = p.matchLookaheadLiteral("(", 0) - } - iceberg_masked_property_entrys1240 := xs1237 - p.consumeLiteral(")") - return iceberg_masked_property_entrys1240 -======= - xs1308 := [][]interface{}{} - cond1309 := p.matchLookaheadLiteral("(", 0) - for cond1309 { - _t2110 := p.parse_iceberg_masked_property_entry() - item1310 := _t2110 - xs1308 = append(xs1308, item1310) - cond1309 = p.matchLookaheadLiteral("(", 0) - } - iceberg_masked_property_entrys1311 := xs1308 + 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 p.consumeLiteral(")") - return iceberg_masked_property_entrys1311 ->>>>>>> origin/main + return iceberg_masked_property_entrys1314 } func (p *Parser) parse_iceberg_masked_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") -<<<<<<< HEAD - string1241 := p.consumeTerminal("STRING").Value.str - string_31242 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return []interface{}{string1241, string_31242} -======= - string1312 := p.consumeTerminal("STRING").Value.str - string_31313 := p.consumeTerminal("STRING").Value.str + string1315 := p.consumeTerminal("STRING").Value.str + string_31316 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1312, string_31313} ->>>>>>> origin/main + return []interface{}{string1315, string_31316} } func (p *Parser) parse_iceberg_from_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("from_snapshot") -<<<<<<< HEAD - string1243 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1243 -======= - string1314 := p.consumeTerminal("STRING").Value.str + string1317 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1314 ->>>>>>> origin/main + return string1317 } func (p *Parser) parse_iceberg_to_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("to_snapshot") -<<<<<<< HEAD - string1244 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1244 -} - -func (p *Parser) parse_undefine() *pb.Undefine { - span_start1246 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("undefine") - _t2018 := p.parse_fragment_id() - fragment_id1245 := _t2018 - p.consumeLiteral(")") - _t2019 := &pb.Undefine{FragmentId: fragment_id1245} - result1247 := _t2019 - p.recordSpan(int(span_start1246), "Undefine") - return result1247 -} - -func (p *Parser) parse_context() *pb.Context { - span_start1252 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("context") - xs1248 := []*pb.RelationId{} - cond1249 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1249 { - _t2020 := p.parse_relation_id() - item1250 := _t2020 - xs1248 = append(xs1248, item1250) - cond1249 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1251 := xs1248 - p.consumeLiteral(")") - _t2021 := &pb.Context{Relations: relation_ids1251} - result1253 := _t2021 - p.recordSpan(int(span_start1252), "Context") - return result1253 -} - -func (p *Parser) parse_snapshot() *pb.Snapshot { - span_start1259 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("snapshot") - _t2022 := p.parse_edb_path() - edb_path1254 := _t2022 - xs1255 := []*pb.SnapshotMapping{} - cond1256 := p.matchLookaheadLiteral("[", 0) - for cond1256 { - _t2023 := p.parse_snapshot_mapping() - item1257 := _t2023 - xs1255 = append(xs1255, item1257) - cond1256 = p.matchLookaheadLiteral("[", 0) - } - snapshot_mappings1258 := xs1255 - p.consumeLiteral(")") - _t2024 := &pb.Snapshot{Prefix: edb_path1254, Mappings: snapshot_mappings1258} - result1260 := _t2024 - p.recordSpan(int(span_start1259), "Snapshot") - return result1260 -} - -func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { - span_start1263 := int64(p.spanStart()) - _t2025 := p.parse_edb_path() - edb_path1261 := _t2025 - _t2026 := p.parse_relation_id() - relation_id1262 := _t2026 - _t2027 := &pb.SnapshotMapping{DestinationPath: edb_path1261, SourceRelation: relation_id1262} - result1264 := _t2027 - p.recordSpan(int(span_start1263), "SnapshotMapping") - return result1264 -======= - string1315 := p.consumeTerminal("STRING").Value.str + string1318 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1315 + return string1318 } func (p *Parser) parse_undefine() *pb.Undefine { - span_start1317 := int64(p.spanStart()) + span_start1320 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("undefine") - _t2111 := p.parse_fragment_id() - fragment_id1316 := _t2111 + _t2117 := p.parse_fragment_id() + fragment_id1319 := _t2117 p.consumeLiteral(")") - _t2112 := &pb.Undefine{FragmentId: fragment_id1316} - result1318 := _t2112 - p.recordSpan(int(span_start1317), "Undefine") - return result1318 + _t2118 := &pb.Undefine{FragmentId: fragment_id1319} + result1321 := _t2118 + p.recordSpan(int(span_start1320), "Undefine") + return result1321 } func (p *Parser) parse_context() *pb.Context { - span_start1323 := int64(p.spanStart()) + span_start1326 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("context") - xs1319 := []*pb.RelationId{} - cond1320 := (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - for cond1320 { - _t2113 := p.parse_relation_id() - item1321 := _t2113 - xs1319 = append(xs1319, item1321) - cond1320 = (p.matchLookaheadLiteral(":", 0) || p.matchLookaheadTerminal("UINT128", 0)) - } - relation_ids1322 := xs1319 + 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 p.consumeLiteral(")") - _t2114 := &pb.Context{Relations: relation_ids1322} - result1324 := _t2114 - p.recordSpan(int(span_start1323), "Context") - return result1324 + _t2120 := &pb.Context{Relations: relation_ids1325} + result1327 := _t2120 + p.recordSpan(int(span_start1326), "Context") + return result1327 } func (p *Parser) parse_snapshot() *pb.Snapshot { - span_start1330 := int64(p.spanStart()) + span_start1333 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("snapshot") - _t2115 := p.parse_edb_path() - edb_path1325 := _t2115 - xs1326 := []*pb.SnapshotMapping{} - cond1327 := p.matchLookaheadLiteral("[", 0) - for cond1327 { - _t2116 := p.parse_snapshot_mapping() - item1328 := _t2116 - xs1326 = append(xs1326, item1328) - cond1327 = p.matchLookaheadLiteral("[", 0) - } - snapshot_mappings1329 := xs1326 + _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 p.consumeLiteral(")") - _t2117 := &pb.Snapshot{Prefix: edb_path1325, Mappings: snapshot_mappings1329} - result1331 := _t2117 - p.recordSpan(int(span_start1330), "Snapshot") - return result1331 + _t2123 := &pb.Snapshot{Prefix: edb_path1328, Mappings: snapshot_mappings1332} + result1334 := _t2123 + p.recordSpan(int(span_start1333), "Snapshot") + return result1334 } func (p *Parser) parse_snapshot_mapping() *pb.SnapshotMapping { - span_start1334 := int64(p.spanStart()) - _t2118 := p.parse_edb_path() - edb_path1332 := _t2118 - _t2119 := p.parse_relation_id() - relation_id1333 := _t2119 - _t2120 := &pb.SnapshotMapping{DestinationPath: edb_path1332, SourceRelation: relation_id1333} - result1335 := _t2120 - p.recordSpan(int(span_start1334), "SnapshotMapping") - return result1335 ->>>>>>> origin/main + 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 } func (p *Parser) parse_epoch_reads() []*pb.Read { p.consumeLiteral("(") p.consumeLiteral("reads") -<<<<<<< HEAD - xs1265 := []*pb.Read{} - cond1266 := p.matchLookaheadLiteral("(", 0) - for cond1266 { - _t2028 := p.parse_read() - item1267 := _t2028 - xs1265 = append(xs1265, item1267) - cond1266 = p.matchLookaheadLiteral("(", 0) - } - reads1268 := xs1265 - p.consumeLiteral(")") - return reads1268 -} - -func (p *Parser) parse_read() *pb.Read { - span_start1275 := int64(p.spanStart()) - var _t2029 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t2030 int64 - if p.matchLookaheadLiteral("what_if", 1) { - _t2030 = 2 - } else { - var _t2031 int64 - if p.matchLookaheadLiteral("output", 1) { - _t2031 = 1 - } else { - var _t2032 int64 - if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2032 = 4 - } else { - var _t2033 int64 - if p.matchLookaheadLiteral("export", 1) { - _t2033 = 4 - } else { - var _t2034 int64 - if p.matchLookaheadLiteral("demand", 1) { - _t2034 = 0 - } else { - var _t2035 int64 - if p.matchLookaheadLiteral("abort", 1) { - _t2035 = 3 - } else { - _t2035 = -1 - } - _t2034 = _t2035 - } - _t2033 = _t2034 - } - _t2032 = _t2033 - } - _t2031 = _t2032 - } - _t2030 = _t2031 - } - _t2029 = _t2030 - } else { - _t2029 = -1 - } - prediction1269 := _t2029 - var _t2036 *pb.Read - if prediction1269 == 4 { - _t2037 := p.parse_export() - export1274 := _t2037 - _t2038 := &pb.Read{} - _t2038.ReadType = &pb.Read_Export{Export: export1274} - _t2036 = _t2038 - } else { - var _t2039 *pb.Read - if prediction1269 == 3 { - _t2040 := p.parse_abort() - abort1273 := _t2040 - _t2041 := &pb.Read{} - _t2041.ReadType = &pb.Read_Abort{Abort: abort1273} - _t2039 = _t2041 - } else { - var _t2042 *pb.Read - if prediction1269 == 2 { - _t2043 := p.parse_what_if() - what_if1272 := _t2043 - _t2044 := &pb.Read{} - _t2044.ReadType = &pb.Read_WhatIf{WhatIf: what_if1272} - _t2042 = _t2044 - } else { - var _t2045 *pb.Read - if prediction1269 == 1 { - _t2046 := p.parse_output() - output1271 := _t2046 - _t2047 := &pb.Read{} - _t2047.ReadType = &pb.Read_Output{Output: output1271} - _t2045 = _t2047 - } else { - var _t2048 *pb.Read - if prediction1269 == 0 { - _t2049 := p.parse_demand() - demand1270 := _t2049 - _t2050 := &pb.Read{} - _t2050.ReadType = &pb.Read_Demand{Demand: demand1270} - _t2048 = _t2050 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t2045 = _t2048 - } - _t2042 = _t2045 - } - _t2039 = _t2042 - } - _t2036 = _t2039 - } - result1276 := _t2036 - p.recordSpan(int(span_start1275), "Read") - return result1276 -======= - xs1336 := []*pb.Read{} - cond1337 := p.matchLookaheadLiteral("(", 0) - for cond1337 { - _t2121 := p.parse_read() - item1338 := _t2121 - xs1336 = append(xs1336, item1338) - cond1337 = p.matchLookaheadLiteral("(", 0) - } - reads1339 := xs1336 + 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 p.consumeLiteral(")") - return reads1339 + return reads1342 } func (p *Parser) parse_read() *pb.Read { - span_start1346 := int64(p.spanStart()) - var _t2122 int64 + span_start1349 := int64(p.spanStart()) + var _t2128 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2123 int64 + var _t2129 int64 if p.matchLookaheadLiteral("what_if", 1) { - _t2123 = 2 + _t2129 = 2 } else { - var _t2124 int64 + var _t2130 int64 if p.matchLookaheadLiteral("output", 1) { - _t2124 = 1 + _t2130 = 1 } else { - var _t2125 int64 + var _t2131 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2125 = 4 + _t2131 = 4 } else { - var _t2126 int64 + var _t2132 int64 if p.matchLookaheadLiteral("export", 1) { - _t2126 = 4 + _t2132 = 4 } else { - var _t2127 int64 + var _t2133 int64 if p.matchLookaheadLiteral("demand", 1) { - _t2127 = 0 + _t2133 = 0 } else { - var _t2128 int64 + var _t2134 int64 if p.matchLookaheadLiteral("abort", 1) { - _t2128 = 3 + _t2134 = 3 } else { - _t2128 = -1 + _t2134 = -1 } - _t2127 = _t2128 + _t2133 = _t2134 } - _t2126 = _t2127 + _t2132 = _t2133 } - _t2125 = _t2126 + _t2131 = _t2132 } - _t2124 = _t2125 + _t2130 = _t2131 } - _t2123 = _t2124 + _t2129 = _t2130 } - _t2122 = _t2123 + _t2128 = _t2129 } else { - _t2122 = -1 - } - prediction1340 := _t2122 - var _t2129 *pb.Read - if prediction1340 == 4 { - _t2130 := p.parse_export() - export1345 := _t2130 - _t2131 := &pb.Read{} - _t2131.ReadType = &pb.Read_Export{Export: export1345} - _t2129 = _t2131 + _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 } else { - var _t2132 *pb.Read - if prediction1340 == 3 { - _t2133 := p.parse_abort() - abort1344 := _t2133 - _t2134 := &pb.Read{} - _t2134.ReadType = &pb.Read_Abort{Abort: abort1344} - _t2132 = _t2134 + 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 } else { - var _t2135 *pb.Read - if prediction1340 == 2 { - _t2136 := p.parse_what_if() - what_if1343 := _t2136 - _t2137 := &pb.Read{} - _t2137.ReadType = &pb.Read_WhatIf{WhatIf: what_if1343} - _t2135 = _t2137 + 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 } else { - var _t2138 *pb.Read - if prediction1340 == 1 { - _t2139 := p.parse_output() - output1342 := _t2139 - _t2140 := &pb.Read{} - _t2140.ReadType = &pb.Read_Output{Output: output1342} - _t2138 = _t2140 + 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 } else { - var _t2141 *pb.Read - if prediction1340 == 0 { - _t2142 := p.parse_demand() - demand1341 := _t2142 - _t2143 := &pb.Read{} - _t2143.ReadType = &pb.Read_Demand{Demand: demand1341} - _t2141 = _t2143 + 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 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in read", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2138 = _t2141 + _t2144 = _t2147 } - _t2135 = _t2138 + _t2141 = _t2144 } - _t2132 = _t2135 + _t2138 = _t2141 } - _t2129 = _t2132 + _t2135 = _t2138 } - result1347 := _t2129 - p.recordSpan(int(span_start1346), "Read") - return result1347 -} - -func (p *Parser) parse_demand() *pb.Demand { - span_start1349 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("demand") - _t2144 := p.parse_relation_id() - relation_id1348 := _t2144 - p.consumeLiteral(")") - _t2145 := &pb.Demand{RelationId: relation_id1348} - result1350 := _t2145 - p.recordSpan(int(span_start1349), "Demand") + result1350 := _t2135 + p.recordSpan(int(span_start1349), "Read") return result1350 ->>>>>>> origin/main } func (p *Parser) parse_demand() *pb.Demand { - span_start1278 := int64(p.spanStart()) + span_start1352 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("demand") - _t2051 := p.parse_relation_id() - relation_id1277 := _t2051 + _t2150 := p.parse_relation_id() + relation_id1351 := _t2150 p.consumeLiteral(")") - _t2052 := &pb.Demand{RelationId: relation_id1277} - result1279 := _t2052 - p.recordSpan(int(span_start1278), "Demand") - return result1279 + _t2151 := &pb.Demand{RelationId: relation_id1351} + result1353 := _t2151 + p.recordSpan(int(span_start1352), "Demand") + return result1353 } func (p *Parser) parse_output() *pb.Output { -<<<<<<< HEAD - span_start1282 := int64(p.spanStart()) + span_start1356 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("output") - _t2053 := p.parse_name() - name1280 := _t2053 - _t2054 := p.parse_relation_id() - relation_id1281 := _t2054 + _t2152 := p.parse_name() + name1354 := _t2152 + _t2153 := p.parse_relation_id() + relation_id1355 := _t2153 p.consumeLiteral(")") - _t2055 := &pb.Output{Name: name1280, RelationId: relation_id1281} - result1283 := _t2055 - p.recordSpan(int(span_start1282), "Output") - return result1283 + _t2154 := &pb.Output{Name: name1354, RelationId: relation_id1355} + result1357 := _t2154 + p.recordSpan(int(span_start1356), "Output") + return result1357 } func (p *Parser) parse_what_if() *pb.WhatIf { - span_start1286 := int64(p.spanStart()) + span_start1360 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("what_if") - _t2056 := p.parse_name() - name1284 := _t2056 - _t2057 := p.parse_epoch() - epoch1285 := _t2057 + _t2155 := p.parse_name() + name1358 := _t2155 + _t2156 := p.parse_epoch() + epoch1359 := _t2156 p.consumeLiteral(")") - _t2058 := &pb.WhatIf{Branch: name1284, Epoch: epoch1285} - result1287 := _t2058 - p.recordSpan(int(span_start1286), "WhatIf") - return result1287 + _t2157 := &pb.WhatIf{Branch: name1358, Epoch: epoch1359} + result1361 := _t2157 + p.recordSpan(int(span_start1360), "WhatIf") + return result1361 } func (p *Parser) parse_abort() *pb.Abort { - span_start1290 := int64(p.spanStart()) + span_start1364 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("abort") - var _t2059 *string + var _t2158 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2060 := p.parse_name() - _t2059 = ptr(_t2060) + _t2159 := p.parse_name() + _t2158 = ptr(_t2159) } - name1288 := _t2059 - _t2061 := p.parse_relation_id() - relation_id1289 := _t2061 + name1362 := _t2158 + _t2160 := p.parse_relation_id() + relation_id1363 := _t2160 p.consumeLiteral(")") - _t2062 := &pb.Abort{Name: deref(name1288, "abort"), RelationId: relation_id1289} - result1291 := _t2062 - p.recordSpan(int(span_start1290), "Abort") - return result1291 + _t2161 := &pb.Abort{Name: deref(name1362, "abort"), RelationId: relation_id1363} + result1365 := _t2161 + p.recordSpan(int(span_start1364), "Abort") + return result1365 } func (p *Parser) parse_export() *pb.Export { - span_start1295 := int64(p.spanStart()) - var _t2063 int64 + span_start1369 := int64(p.spanStart()) + var _t2162 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2064 int64 + var _t2163 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2064 = 1 + _t2163 = 1 } else { - var _t2065 int64 + var _t2164 int64 if p.matchLookaheadLiteral("export", 1) { - _t2065 = 0 + _t2164 = 0 } else { - _t2065 = -1 + _t2164 = -1 } - _t2064 = _t2065 + _t2163 = _t2164 } - _t2063 = _t2064 + _t2162 = _t2163 } else { - _t2063 = -1 + _t2162 = -1 } - prediction1292 := _t2063 - var _t2066 *pb.Export - if prediction1292 == 1 { + prediction1366 := _t2162 + var _t2165 *pb.Export + if prediction1366 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_iceberg") - _t2067 := p.parse_export_iceberg_config() - export_iceberg_config1294 := _t2067 + _t2166 := p.parse_export_iceberg_config() + export_iceberg_config1368 := _t2166 p.consumeLiteral(")") - _t2068 := &pb.Export{} - _t2068.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1294} - _t2066 = _t2068 + _t2167 := &pb.Export{} + _t2167.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1368} + _t2165 = _t2167 } else { - var _t2069 *pb.Export - if prediction1292 == 0 { + var _t2168 *pb.Export + if prediction1366 == 0 { p.consumeLiteral("(") p.consumeLiteral("export") - _t2070 := p.parse_export_csv_config() - export_csv_config1293 := _t2070 + _t2169 := p.parse_export_csv_config() + export_csv_config1367 := _t2169 p.consumeLiteral(")") - _t2071 := &pb.Export{} - _t2071.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1293} - _t2069 = _t2071 + _t2170 := &pb.Export{} + _t2170.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1367} + _t2168 = _t2170 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2066 = _t2069 + _t2165 = _t2168 } - result1296 := _t2066 - p.recordSpan(int(span_start1295), "Export") - return result1296 + result1370 := _t2165 + p.recordSpan(int(span_start1369), "Export") + return result1370 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1304 := int64(p.spanStart()) - var _t2072 int64 + span_start1378 := int64(p.spanStart()) + var _t2171 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2073 int64 + var _t2172 int64 if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2073 = 0 + _t2172 = 0 } else { - var _t2074 int64 + var _t2173 int64 if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2074 = 1 + _t2173 = 1 } else { - _t2074 = -1 + _t2173 = -1 } - _t2073 = _t2074 + _t2172 = _t2173 } - _t2072 = _t2073 + _t2171 = _t2172 } else { - _t2072 = -1 + _t2171 = -1 } - prediction1297 := _t2072 - var _t2075 *pb.ExportCSVConfig - if prediction1297 == 1 { + prediction1371 := _t2171 + var _t2174 *pb.ExportCSVConfig + if prediction1371 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config") - _t2076 := p.parse_export_csv_path() - export_csv_path1301 := _t2076 - _t2077 := p.parse_export_csv_columns_list() - export_csv_columns_list1302 := _t2077 - _t2078 := p.parse_config_dict() - config_dict1303 := _t2078 + _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 p.consumeLiteral(")") - _t2079 := p.construct_export_csv_config(export_csv_path1301, export_csv_columns_list1302, config_dict1303) - _t2075 = _t2079 + _t2178 := p.construct_export_csv_config(export_csv_path1375, export_csv_columns_list1376, config_dict1377) + _t2174 = _t2178 } else { - var _t2080 *pb.ExportCSVConfig - if prediction1297 == 0 { + var _t2179 *pb.ExportCSVConfig + if prediction1371 == 0 { p.consumeLiteral("(") p.consumeLiteral("export_csv_config_v2") - _t2081 := p.parse_export_csv_output_location() - export_csv_output_location1298 := _t2081 - _t2082 := p.parse_export_csv_source() - export_csv_source1299 := _t2082 - _t2083 := p.parse_csv_config() - csv_config1300 := _t2083 + _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 p.consumeLiteral(")") - _t2084 := p.construct_export_csv_config_with_location(export_csv_output_location1298, export_csv_source1299, csv_config1300) - _t2080 = _t2084 + _t2183 := p.construct_export_csv_config_with_location(export_csv_output_location1372, export_csv_source1373, csv_config1374) + _t2179 = _t2183 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_config", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2075 = _t2080 + _t2174 = _t2179 } - result1305 := _t2075 - p.recordSpan(int(span_start1304), "ExportCSVConfig") - return result1305 + result1379 := _t2174 + p.recordSpan(int(span_start1378), "ExportCSVConfig") + return result1379 } func (p *Parser) parse_export_csv_output_location() []interface{} { - var _t2085 int64 + var _t2184 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2086 int64 + var _t2185 int64 if p.matchLookaheadLiteral("transaction_output_name", 1) { - _t2086 = 1 + _t2185 = 1 } else { - var _t2087 int64 + var _t2186 int64 if p.matchLookaheadLiteral("path", 1) { - _t2087 = 0 + _t2186 = 0 } else { - _t2087 = -1 + _t2186 = -1 } - _t2086 = _t2087 + _t2185 = _t2186 } - _t2085 = _t2086 + _t2184 = _t2185 } else { - _t2085 = -1 + _t2184 = -1 } - prediction1306 := _t2085 - var _t2088 []interface{} - if prediction1306 == 1 { + prediction1380 := _t2184 + var _t2187 []interface{} + if prediction1380 == 1 { p.consumeLiteral("(") p.consumeLiteral("transaction_output_name") - _t2089 := p.parse_name() - name1308 := _t2089 + _t2188 := p.parse_name() + name1382 := _t2188 p.consumeLiteral(")") - _t2088 = []interface{}{"", name1308} + _t2187 = []interface{}{"", name1382} } else { - var _t2090 []interface{} - if prediction1306 == 0 { + var _t2189 []interface{} + if prediction1380 == 0 { p.consumeLiteral("(") p.consumeLiteral("path") - string1307 := p.consumeTerminal("STRING").Value.str + string1381 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - _t2090 = []interface{}{string1307, ""} + _t2189 = []interface{}{string1381, ""} } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_output_location", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2088 = _t2090 + _t2187 = _t2189 } - return _t2088 + return _t2187 } func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1315 := int64(p.spanStart()) - var _t2091 int64 + span_start1389 := int64(p.spanStart()) + var _t2190 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2092 int64 + var _t2191 int64 if p.matchLookaheadLiteral("table_def", 1) { - _t2092 = 1 + _t2191 = 1 } else { - var _t2093 int64 + var _t2192 int64 if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2093 = 0 + _t2192 = 0 } else { - _t2093 = -1 + _t2192 = -1 } - _t2092 = _t2093 + _t2191 = _t2192 } - _t2091 = _t2092 + _t2190 = _t2191 } else { - _t2091 = -1 + _t2190 = -1 } - prediction1309 := _t2091 - var _t2094 *pb.ExportCSVSource - if prediction1309 == 1 { + prediction1383 := _t2190 + var _t2193 *pb.ExportCSVSource + if prediction1383 == 1 { p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2095 := p.parse_relation_id() - relation_id1314 := _t2095 + _t2194 := p.parse_relation_id() + relation_id1388 := _t2194 p.consumeLiteral(")") - _t2096 := &pb.ExportCSVSource{} - _t2096.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1314} - _t2094 = _t2096 + _t2195 := &pb.ExportCSVSource{} + _t2195.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1388} + _t2193 = _t2195 } else { - var _t2097 *pb.ExportCSVSource - if prediction1309 == 0 { + var _t2196 *pb.ExportCSVSource + if prediction1383 == 0 { p.consumeLiteral("(") p.consumeLiteral("gnf_columns") - xs1310 := []*pb.ExportCSVColumn{} - cond1311 := p.matchLookaheadLiteral("(", 0) - for cond1311 { - _t2098 := p.parse_export_csv_column() - item1312 := _t2098 - xs1310 = append(xs1310, item1312) - cond1311 = p.matchLookaheadLiteral("(", 0) + 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) } - export_csv_columns1313 := xs1310 + export_csv_columns1387 := xs1384 p.consumeLiteral(")") - _t2099 := &pb.ExportCSVColumns{Columns: export_csv_columns1313} - _t2100 := &pb.ExportCSVSource{} - _t2100.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2099} - _t2097 = _t2100 + _t2198 := &pb.ExportCSVColumns{Columns: export_csv_columns1387} + _t2199 := &pb.ExportCSVSource{} + _t2199.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2198} + _t2196 = _t2199 } else { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_source", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t2094 = _t2097 + _t2193 = _t2196 } - result1316 := _t2094 - p.recordSpan(int(span_start1315), "ExportCSVSource") - return result1316 + result1390 := _t2193 + p.recordSpan(int(span_start1389), "ExportCSVSource") + return result1390 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1319 := int64(p.spanStart()) + span_start1393 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1317 := p.consumeTerminal("STRING").Value.str - _t2101 := p.parse_relation_id() - relation_id1318 := _t2101 - p.consumeLiteral(")") - _t2102 := &pb.ExportCSVColumn{ColumnName: string1317, ColumnData: relation_id1318} - result1320 := _t2102 - p.recordSpan(int(span_start1319), "ExportCSVColumn") - return result1320 -======= - span_start1353 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("output") - _t2146 := p.parse_name() - name1351 := _t2146 - _t2147 := p.parse_relation_id() - relation_id1352 := _t2147 - p.consumeLiteral(")") - _t2148 := &pb.Output{Name: name1351, RelationId: relation_id1352} - result1354 := _t2148 - p.recordSpan(int(span_start1353), "Output") - return result1354 -} - -func (p *Parser) parse_what_if() *pb.WhatIf { - span_start1357 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("what_if") - _t2149 := p.parse_name() - name1355 := _t2149 - _t2150 := p.parse_epoch() - epoch1356 := _t2150 - p.consumeLiteral(")") - _t2151 := &pb.WhatIf{Branch: name1355, Epoch: epoch1356} - result1358 := _t2151 - p.recordSpan(int(span_start1357), "WhatIf") - return result1358 -} - -func (p *Parser) parse_abort() *pb.Abort { - span_start1361 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("abort") - var _t2152 *string - if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2153 := p.parse_name() - _t2152 = ptr(_t2153) - } - name1359 := _t2152 - _t2154 := p.parse_relation_id() - relation_id1360 := _t2154 + string1391 := p.consumeTerminal("STRING").Value.str + _t2200 := p.parse_relation_id() + relation_id1392 := _t2200 p.consumeLiteral(")") - _t2155 := &pb.Abort{Name: deref(name1359, "abort"), RelationId: relation_id1360} - result1362 := _t2155 - p.recordSpan(int(span_start1361), "Abort") - return result1362 -} - -func (p *Parser) parse_export() *pb.Export { - span_start1366 := int64(p.spanStart()) - var _t2156 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t2157 int64 - if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2157 = 1 - } else { - var _t2158 int64 - if p.matchLookaheadLiteral("export", 1) { - _t2158 = 0 - } else { - _t2158 = -1 - } - _t2157 = _t2158 - } - _t2156 = _t2157 - } else { - _t2156 = -1 - } - prediction1363 := _t2156 - var _t2159 *pb.Export - if prediction1363 == 1 { - p.consumeLiteral("(") - p.consumeLiteral("export_iceberg") - _t2160 := p.parse_export_iceberg_config() - export_iceberg_config1365 := _t2160 - p.consumeLiteral(")") - _t2161 := &pb.Export{} - _t2161.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1365} - _t2159 = _t2161 - } else { - var _t2162 *pb.Export - if prediction1363 == 0 { - p.consumeLiteral("(") - p.consumeLiteral("export") - _t2163 := p.parse_export_csv_config() - export_csv_config1364 := _t2163 - p.consumeLiteral(")") - _t2164 := &pb.Export{} - _t2164.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1364} - _t2162 = _t2164 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t2159 = _t2162 - } - result1367 := _t2159 - p.recordSpan(int(span_start1366), "Export") - return result1367 -} - -func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1375 := int64(p.spanStart()) - var _t2165 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t2166 int64 - if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2166 = 0 - } else { - var _t2167 int64 - if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2167 = 1 - } else { - _t2167 = -1 - } - _t2166 = _t2167 - } - _t2165 = _t2166 - } else { - _t2165 = -1 - } - prediction1368 := _t2165 - var _t2168 *pb.ExportCSVConfig - if prediction1368 == 1 { - p.consumeLiteral("(") - p.consumeLiteral("export_csv_config") - _t2169 := p.parse_export_csv_path() - export_csv_path1372 := _t2169 - _t2170 := p.parse_export_csv_columns_list() - export_csv_columns_list1373 := _t2170 - _t2171 := p.parse_config_dict() - config_dict1374 := _t2171 - p.consumeLiteral(")") - _t2172 := p.construct_export_csv_config(export_csv_path1372, export_csv_columns_list1373, config_dict1374) - _t2168 = _t2172 - } else { - var _t2173 *pb.ExportCSVConfig - if prediction1368 == 0 { - p.consumeLiteral("(") - p.consumeLiteral("export_csv_config_v2") - _t2174 := p.parse_export_csv_path() - export_csv_path1369 := _t2174 - _t2175 := p.parse_export_csv_source() - export_csv_source1370 := _t2175 - _t2176 := p.parse_csv_config() - csv_config1371 := _t2176 - p.consumeLiteral(")") - _t2177 := p.construct_export_csv_config_with_source(export_csv_path1369, export_csv_source1370, csv_config1371) - _t2173 = _t2177 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_config", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t2168 = _t2173 - } - result1376 := _t2168 - p.recordSpan(int(span_start1375), "ExportCSVConfig") - return result1376 ->>>>>>> origin/main + _t2201 := &pb.ExportCSVColumn{ColumnName: string1391, ColumnData: relation_id1392} + result1394 := _t2201 + p.recordSpan(int(span_start1393), "ExportCSVColumn") + return result1394 } func (p *Parser) parse_export_csv_path() string { p.consumeLiteral("(") p.consumeLiteral("path") -<<<<<<< HEAD - string1321 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1321 -======= - string1377 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1377 -} - -func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1384 := int64(p.spanStart()) - var _t2178 int64 - if p.matchLookaheadLiteral("(", 0) { - var _t2179 int64 - if p.matchLookaheadLiteral("table_def", 1) { - _t2179 = 1 - } else { - var _t2180 int64 - if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2180 = 0 - } else { - _t2180 = -1 - } - _t2179 = _t2180 - } - _t2178 = _t2179 - } else { - _t2178 = -1 - } - prediction1378 := _t2178 - var _t2181 *pb.ExportCSVSource - if prediction1378 == 1 { - p.consumeLiteral("(") - p.consumeLiteral("table_def") - _t2182 := p.parse_relation_id() - relation_id1383 := _t2182 - p.consumeLiteral(")") - _t2183 := &pb.ExportCSVSource{} - _t2183.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1383} - _t2181 = _t2183 - } else { - var _t2184 *pb.ExportCSVSource - if prediction1378 == 0 { - p.consumeLiteral("(") - p.consumeLiteral("gnf_columns") - xs1379 := []*pb.ExportCSVColumn{} - cond1380 := p.matchLookaheadLiteral("(", 0) - for cond1380 { - _t2185 := p.parse_export_csv_column() - item1381 := _t2185 - xs1379 = append(xs1379, item1381) - cond1380 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1382 := xs1379 - p.consumeLiteral(")") - _t2186 := &pb.ExportCSVColumns{Columns: export_csv_columns1382} - _t2187 := &pb.ExportCSVSource{} - _t2187.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2186} - _t2184 = _t2187 - } else { - panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in export_csv_source", p.lookahead(0).Type, p.lookahead(0).Value)}) - } - _t2181 = _t2184 - } - result1385 := _t2181 - p.recordSpan(int(span_start1384), "ExportCSVSource") - return result1385 -} - -func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1388 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("column") - string1386 := p.consumeTerminal("STRING").Value.str - _t2188 := p.parse_relation_id() - relation_id1387 := _t2188 + string1395 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - _t2189 := &pb.ExportCSVColumn{ColumnName: string1386, ColumnData: relation_id1387} - result1389 := _t2189 - p.recordSpan(int(span_start1388), "ExportCSVColumn") - return result1389 ->>>>>>> origin/main + return string1395 } func (p *Parser) parse_export_csv_columns_list() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") -<<<<<<< HEAD - xs1322 := []*pb.ExportCSVColumn{} - cond1323 := p.matchLookaheadLiteral("(", 0) - for cond1323 { - _t2103 := p.parse_export_csv_column() - item1324 := _t2103 - xs1322 = append(xs1322, item1324) - cond1323 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1325 := xs1322 - p.consumeLiteral(")") - return export_csv_columns1325 -} - -func (p *Parser) parse_export_iceberg_config() *pb.ExportIcebergConfig { - span_start1331 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("export_iceberg_config") - _t2104 := p.parse_iceberg_locator() - iceberg_locator1326 := _t2104 - _t2105 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1327 := _t2105 - _t2106 := p.parse_export_iceberg_table_def() - export_iceberg_table_def1328 := _t2106 - _t2107 := p.parse_iceberg_table_properties() - iceberg_table_properties1329 := _t2107 - var _t2108 [][]interface{} - if p.matchLookaheadLiteral("{", 0) { - _t2109 := p.parse_config_dict() - _t2108 = _t2109 + 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) } - config_dict1330 := _t2108 - p.consumeLiteral(")") - _t2110 := p.construct_export_iceberg_config_full(iceberg_locator1326, iceberg_catalog_config1327, export_iceberg_table_def1328, iceberg_table_properties1329, config_dict1330) - result1332 := _t2110 - p.recordSpan(int(span_start1331), "ExportIcebergConfig") - return result1332 -} - -func (p *Parser) parse_export_iceberg_table_def() *pb.RelationId { - span_start1334 := int64(p.spanStart()) - p.consumeLiteral("(") - p.consumeLiteral("table_def") - _t2111 := p.parse_relation_id() - relation_id1333 := _t2111 - p.consumeLiteral(")") - result1335 := relation_id1333 - p.recordSpan(int(span_start1334), "RelationId") - return result1335 -======= - xs1390 := []*pb.ExportCSVColumn{} - cond1391 := p.matchLookaheadLiteral("(", 0) - for cond1391 { - _t2190 := p.parse_export_csv_column() - item1392 := _t2190 - xs1390 = append(xs1390, item1392) - cond1391 = p.matchLookaheadLiteral("(", 0) - } - export_csv_columns1393 := xs1390 + export_csv_columns1399 := xs1396 p.consumeLiteral(")") - return export_csv_columns1393 + return export_csv_columns1399 } func (p *Parser) parse_export_iceberg_config() *pb.ExportIcebergConfig { - span_start1399 := int64(p.spanStart()) + span_start1405 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("export_iceberg_config") - _t2191 := p.parse_iceberg_locator() - iceberg_locator1394 := _t2191 - _t2192 := p.parse_iceberg_catalog_config() - iceberg_catalog_config1395 := _t2192 - _t2193 := p.parse_export_iceberg_table_def() - export_iceberg_table_def1396 := _t2193 - _t2194 := p.parse_iceberg_table_properties() - iceberg_table_properties1397 := _t2194 - var _t2195 [][]interface{} + _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{} if p.matchLookaheadLiteral("{", 0) { - _t2196 := p.parse_config_dict() - _t2195 = _t2196 + _t2208 := p.parse_config_dict() + _t2207 = _t2208 } - config_dict1398 := _t2195 + config_dict1404 := _t2207 p.consumeLiteral(")") - _t2197 := p.construct_export_iceberg_config_full(iceberg_locator1394, iceberg_catalog_config1395, export_iceberg_table_def1396, iceberg_table_properties1397, config_dict1398) - result1400 := _t2197 - p.recordSpan(int(span_start1399), "ExportIcebergConfig") - return result1400 + _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 } func (p *Parser) parse_export_iceberg_table_def() *pb.RelationId { - span_start1402 := int64(p.spanStart()) + span_start1408 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2198 := p.parse_relation_id() - relation_id1401 := _t2198 + _t2210 := p.parse_relation_id() + relation_id1407 := _t2210 p.consumeLiteral(")") - result1403 := relation_id1401 - p.recordSpan(int(span_start1402), "RelationId") - return result1403 ->>>>>>> origin/main + result1409 := relation_id1407 + p.recordSpan(int(span_start1408), "RelationId") + return result1409 } func (p *Parser) parse_iceberg_table_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("table_properties") -<<<<<<< HEAD - xs1336 := [][]interface{}{} - cond1337 := p.matchLookaheadLiteral("(", 0) - for cond1337 { - _t2112 := p.parse_iceberg_property_entry() - item1338 := _t2112 - xs1336 = append(xs1336, item1338) - cond1337 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1339 := xs1336 - p.consumeLiteral(")") - return iceberg_property_entrys1339 -======= - xs1404 := [][]interface{}{} - cond1405 := p.matchLookaheadLiteral("(", 0) - for cond1405 { - _t2199 := p.parse_iceberg_property_entry() - item1406 := _t2199 - xs1404 = append(xs1404, item1406) - cond1405 = p.matchLookaheadLiteral("(", 0) - } - iceberg_property_entrys1407 := xs1404 + 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 p.consumeLiteral(")") - return iceberg_property_entrys1407 ->>>>>>> origin/main + return iceberg_property_entrys1413 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index 1d52ae03..f9018ec0 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -342,384 +342,211 @@ func formatBool(b bool) string { // --- Helper functions --- -<<<<<<< HEAD -func (p *PrettyPrinter) deconstruct_export_csv_output_location(msg *pb.ExportCSVConfig) []interface{} { - return []interface{}{msg.GetPath(), msg.GetTransactionOutputName()} -} - -func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1755 := &pb.Value{} - _t1755.Value = &pb.Value_Int32Value{Int32Value: v} - return _t1755 -} - -func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1756 := &pb.Value{} - _t1756.Value = &pb.Value_IntValue{IntValue: v} - return _t1756 -} - -func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1757 := &pb.Value{} - _t1757.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1757 -} - -func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1758 := &pb.Value{} - _t1758.Value = &pb.Value_StringValue{StringValue: v} - return _t1758 -} - -func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1759 := &pb.Value{} - _t1759.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1759 -} - -func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1760 := &pb.Value{} - _t1760.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1760 -======= func (p *PrettyPrinter) deconstruct_csv_data_columns_optional(msg *pb.CSVData) []*pb.GNFColumn { - var _t1832 interface{} + var _t1845 interface{} if hasProtoField(msg, "relations") { return nil } - _ = _t1832 + _ = _t1845 return msg.GetColumns() } func (p *PrettyPrinter) deconstruct_csv_data_relations_optional(msg *pb.CSVData) *pb.TargetRelations { - var _t1833 interface{} + var _t1846 interface{} if hasProtoField(msg, "relations") { return msg.GetRelations() } - _ = _t1833 + _ = _t1846 return nil } +func (p *PrettyPrinter) deconstruct_export_csv_output_location(msg *pb.ExportCSVConfig) []interface{} { + return []interface{}{msg.GetPath(), msg.GetTransactionOutputName()} +} + func (p *PrettyPrinter) _make_value_int32(v int32) *pb.Value { - _t1834 := &pb.Value{} - _t1834.Value = &pb.Value_Int32Value{Int32Value: v} - return _t1834 + _t1847 := &pb.Value{} + _t1847.Value = &pb.Value_Int32Value{Int32Value: v} + return _t1847 } func (p *PrettyPrinter) _make_value_int64(v int64) *pb.Value { - _t1835 := &pb.Value{} - _t1835.Value = &pb.Value_IntValue{IntValue: v} - return _t1835 + _t1848 := &pb.Value{} + _t1848.Value = &pb.Value_IntValue{IntValue: v} + return _t1848 } func (p *PrettyPrinter) _make_value_float64(v float64) *pb.Value { - _t1836 := &pb.Value{} - _t1836.Value = &pb.Value_FloatValue{FloatValue: v} - return _t1836 + _t1849 := &pb.Value{} + _t1849.Value = &pb.Value_FloatValue{FloatValue: v} + return _t1849 } func (p *PrettyPrinter) _make_value_string(v string) *pb.Value { - _t1837 := &pb.Value{} - _t1837.Value = &pb.Value_StringValue{StringValue: v} - return _t1837 + _t1850 := &pb.Value{} + _t1850.Value = &pb.Value_StringValue{StringValue: v} + return _t1850 } func (p *PrettyPrinter) _make_value_boolean(v bool) *pb.Value { - _t1838 := &pb.Value{} - _t1838.Value = &pb.Value_BooleanValue{BooleanValue: v} - return _t1838 + _t1851 := &pb.Value{} + _t1851.Value = &pb.Value_BooleanValue{BooleanValue: v} + return _t1851 } func (p *PrettyPrinter) _make_value_uint128(v *pb.UInt128Value) *pb.Value { - _t1839 := &pb.Value{} - _t1839.Value = &pb.Value_Uint128Value{Uint128Value: v} - return _t1839 ->>>>>>> origin/main + _t1852 := &pb.Value{} + _t1852.Value = &pb.Value_Uint128Value{Uint128Value: v} + return _t1852 } func (p *PrettyPrinter) deconstruct_configure(msg *pb.Configure) [][]interface{} { result := [][]interface{}{} if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_AUTO { -<<<<<<< HEAD - _t1761 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1761}) + _t1853 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1853}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1762 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1762}) + _t1854 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1854}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1763 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1763}) + _t1855 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1855}) } } } - _t1764 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1764}) -======= - _t1840 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1840}) - } else { - if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1841 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1841}) - } else { - if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1842 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1842}) - } - } - } - _t1843 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1843}) ->>>>>>> origin/main + _t1856 := p._make_value_int64(msg.GetSemanticsVersion()) + result = append(result, []interface{}{"semantics_version", _t1856}) return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_config(msg *pb.CSVConfig) [][]interface{} { result := [][]interface{}{} -<<<<<<< HEAD - _t1765 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1765}) - _t1766 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1766}) - if msg.GetNewLine() != "" { - _t1767 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1767}) - } - _t1768 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1768}) - _t1769 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1769}) - _t1770 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1770}) - if msg.GetComment() != "" { - _t1771 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1771}) - } - for _, missing_string := range msg.GetMissingStrings() { - _t1772 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1772}) - } - _t1773 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1773}) - _t1774 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1774}) - _t1775 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1775}) - if msg.GetPartitionSizeMb() != 0 { - _t1776 := p._make_value_int64(msg.GetPartitionSizeMb()) - result = append(result, []interface{}{"csv_partition_size_mb", _t1776}) -======= - _t1844 := p._make_value_int32(msg.GetHeaderRow()) - result = append(result, []interface{}{"csv_header_row", _t1844}) - _t1845 := p._make_value_int64(msg.GetSkip()) - result = append(result, []interface{}{"csv_skip", _t1845}) + _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}) if msg.GetNewLine() != "" { - _t1846 := p._make_value_string(msg.GetNewLine()) - result = append(result, []interface{}{"csv_new_line", _t1846}) - } - _t1847 := p._make_value_string(msg.GetDelimiter()) - result = append(result, []interface{}{"csv_delimiter", _t1847}) - _t1848 := p._make_value_string(msg.GetQuotechar()) - result = append(result, []interface{}{"csv_quotechar", _t1848}) - _t1849 := p._make_value_string(msg.GetEscapechar()) - result = append(result, []interface{}{"csv_escapechar", _t1849}) + _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}) if msg.GetComment() != "" { - _t1850 := p._make_value_string(msg.GetComment()) - result = append(result, []interface{}{"csv_comment", _t1850}) + _t1863 := p._make_value_string(msg.GetComment()) + result = append(result, []interface{}{"csv_comment", _t1863}) } for _, missing_string := range msg.GetMissingStrings() { - _t1851 := p._make_value_string(missing_string) - result = append(result, []interface{}{"csv_missing_strings", _t1851}) - } - _t1852 := p._make_value_string(msg.GetDecimalSeparator()) - result = append(result, []interface{}{"csv_decimal_separator", _t1852}) - _t1853 := p._make_value_string(msg.GetEncoding()) - result = append(result, []interface{}{"csv_encoding", _t1853}) - _t1854 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"csv_compression", _t1854}) + _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}) if msg.GetPartitionSizeMb() != 0 { - _t1855 := p._make_value_int64(msg.GetPartitionSizeMb()) - result = append(result, []interface{}{"csv_partition_size_mb", _t1855}) ->>>>>>> origin/main + _t1868 := p._make_value_int64(msg.GetPartitionSizeMb()) + result = append(result, []interface{}{"csv_partition_size_mb", _t1868}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_csv_storage_integration_optional(msg *pb.CSVConfig) [][]interface{} { -<<<<<<< HEAD - var _t1777 interface{} - if !(hasProtoField(msg, "storage_integration")) { - return nil - } - _ = _t1777 - si := msg.GetStorageIntegration() - result := [][]interface{}{} - if si.GetProvider() != "" { - _t1778 := p._make_value_string(si.GetProvider()) - result = append(result, []interface{}{"provider", _t1778}) - } - if si.GetAzureSasToken() != "" { - _t1779 := p._make_value_string("***") - result = append(result, []interface{}{"azure_sas_token", _t1779}) - } - if si.GetS3Region() != "" { - _t1780 := p._make_value_string(si.GetS3Region()) - result = append(result, []interface{}{"s3_region", _t1780}) - } - if si.GetS3AccessKeyId() != "" { - _t1781 := p._make_value_string("***") - result = append(result, []interface{}{"s3_access_key_id", _t1781}) - } - if si.GetS3SecretAccessKey() != "" { - _t1782 := p._make_value_string("***") - result = append(result, []interface{}{"s3_secret_access_key", _t1782}) -======= - var _t1856 interface{} + var _t1869 interface{} if !(hasProtoField(msg, "storage_integration")) { return nil } - _ = _t1856 + _ = _t1869 si := msg.GetStorageIntegration() result := [][]interface{}{} if si.GetProvider() != "" { - _t1857 := p._make_value_string(si.GetProvider()) - result = append(result, []interface{}{"provider", _t1857}) + _t1870 := p._make_value_string(si.GetProvider()) + result = append(result, []interface{}{"provider", _t1870}) } if si.GetAzureSasToken() != "" { - _t1858 := p._make_value_string("***") - result = append(result, []interface{}{"azure_sas_token", _t1858}) + _t1871 := p._make_value_string("***") + result = append(result, []interface{}{"azure_sas_token", _t1871}) } if si.GetS3Region() != "" { - _t1859 := p._make_value_string(si.GetS3Region()) - result = append(result, []interface{}{"s3_region", _t1859}) + _t1872 := p._make_value_string(si.GetS3Region()) + result = append(result, []interface{}{"s3_region", _t1872}) } if si.GetS3AccessKeyId() != "" { - _t1860 := p._make_value_string("***") - result = append(result, []interface{}{"s3_access_key_id", _t1860}) + _t1873 := p._make_value_string("***") + result = append(result, []interface{}{"s3_access_key_id", _t1873}) } if si.GetS3SecretAccessKey() != "" { - _t1861 := p._make_value_string("***") - result = append(result, []interface{}{"s3_secret_access_key", _t1861}) ->>>>>>> origin/main + _t1874 := p._make_value_string("***") + result = append(result, []interface{}{"s3_secret_access_key", _t1874}) } return listSort(result) } func (p *PrettyPrinter) deconstruct_betree_info_config(msg *pb.BeTreeInfo) [][]interface{} { result := [][]interface{}{} -<<<<<<< HEAD - _t1783 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1783}) - _t1784 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1784}) - _t1785 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1785}) - _t1786 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1786}) - if hasProtoField(msg.GetRelationLocator(), "root_pageid") { - if msg.GetRelationLocator().GetRootPageid() != nil { - _t1787 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1787}) -======= - _t1862 := p._make_value_float64(msg.GetStorageConfig().GetEpsilon()) - result = append(result, []interface{}{"betree_config_epsilon", _t1862}) - _t1863 := p._make_value_int64(msg.GetStorageConfig().GetMaxPivots()) - result = append(result, []interface{}{"betree_config_max_pivots", _t1863}) - _t1864 := p._make_value_int64(msg.GetStorageConfig().GetMaxDeltas()) - result = append(result, []interface{}{"betree_config_max_deltas", _t1864}) - _t1865 := p._make_value_int64(msg.GetStorageConfig().GetMaxLeaf()) - result = append(result, []interface{}{"betree_config_max_leaf", _t1865}) + _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}) if hasProtoField(msg.GetRelationLocator(), "root_pageid") { if msg.GetRelationLocator().GetRootPageid() != nil { - _t1866 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) - result = append(result, []interface{}{"betree_locator_root_pageid", _t1866}) ->>>>>>> origin/main + _t1879 := p._make_value_uint128(msg.GetRelationLocator().GetRootPageid()) + result = append(result, []interface{}{"betree_locator_root_pageid", _t1879}) } } if hasProtoField(msg.GetRelationLocator(), "inline_data") { if msg.GetRelationLocator().GetInlineData() != nil { -<<<<<<< HEAD - _t1788 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1788}) + _t1880 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1880}) } } - _t1789 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1789}) - _t1790 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1790}) -======= - _t1867 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1867}) - } - } - _t1868 := p._make_value_int64(msg.GetRelationLocator().GetElementCount()) - result = append(result, []interface{}{"betree_locator_element_count", _t1868}) - _t1869 := p._make_value_int64(msg.GetRelationLocator().GetTreeHeight()) - result = append(result, []interface{}{"betree_locator_tree_height", _t1869}) ->>>>>>> origin/main + _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}) return listSort(result) } func (p *PrettyPrinter) deconstruct_export_csv_config(msg *pb.ExportCSVConfig) [][]interface{} { result := [][]interface{}{} if msg.PartitionSize != nil { -<<<<<<< HEAD - _t1791 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1791}) - } - if msg.Compression != nil { - _t1792 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1792}) - } - if msg.SyntaxHeaderRow != nil { - _t1793 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1793}) - } - if msg.SyntaxMissingString != nil { - _t1794 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1794}) - } - if msg.SyntaxDelim != nil { - _t1795 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1795}) - } - if msg.SyntaxQuotechar != nil { - _t1796 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1796}) - } - if msg.SyntaxEscapechar != nil { - _t1797 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1797}) -======= - _t1870 := p._make_value_int64(*msg.PartitionSize) - result = append(result, []interface{}{"partition_size", _t1870}) + _t1883 := p._make_value_int64(*msg.PartitionSize) + result = append(result, []interface{}{"partition_size", _t1883}) } if msg.Compression != nil { - _t1871 := p._make_value_string(*msg.Compression) - result = append(result, []interface{}{"compression", _t1871}) + _t1884 := p._make_value_string(*msg.Compression) + result = append(result, []interface{}{"compression", _t1884}) } if msg.SyntaxHeaderRow != nil { - _t1872 := p._make_value_boolean(*msg.SyntaxHeaderRow) - result = append(result, []interface{}{"syntax_header_row", _t1872}) + _t1885 := p._make_value_boolean(*msg.SyntaxHeaderRow) + result = append(result, []interface{}{"syntax_header_row", _t1885}) } if msg.SyntaxMissingString != nil { - _t1873 := p._make_value_string(*msg.SyntaxMissingString) - result = append(result, []interface{}{"syntax_missing_string", _t1873}) + _t1886 := p._make_value_string(*msg.SyntaxMissingString) + result = append(result, []interface{}{"syntax_missing_string", _t1886}) } if msg.SyntaxDelim != nil { - _t1874 := p._make_value_string(*msg.SyntaxDelim) - result = append(result, []interface{}{"syntax_delim", _t1874}) + _t1887 := p._make_value_string(*msg.SyntaxDelim) + result = append(result, []interface{}{"syntax_delim", _t1887}) } if msg.SyntaxQuotechar != nil { - _t1875 := p._make_value_string(*msg.SyntaxQuotechar) - result = append(result, []interface{}{"syntax_quotechar", _t1875}) + _t1888 := p._make_value_string(*msg.SyntaxQuotechar) + result = append(result, []interface{}{"syntax_quotechar", _t1888}) } if msg.SyntaxEscapechar != nil { - _t1876 := p._make_value_string(*msg.SyntaxEscapechar) - result = append(result, []interface{}{"syntax_escapechar", _t1876}) ->>>>>>> origin/main + _t1889 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1889}) } return listSort(result) } @@ -729,94 +556,51 @@ func (p *PrettyPrinter) mask_secret_value(pair []interface{}) string { } func (p *PrettyPrinter) deconstruct_iceberg_catalog_config_scope_optional(msg *pb.IcebergCatalogConfig) *string { -<<<<<<< HEAD - var _t1798 interface{} - if *msg.Scope != "" { - return ptr(*msg.Scope) - } - _ = _t1798 -======= - var _t1877 interface{} + var _t1890 interface{} if *msg.Scope != "" { return ptr(*msg.Scope) } - _ = _t1877 ->>>>>>> origin/main + _ = _t1890 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_from_snapshot_optional(msg *pb.IcebergData) *string { -<<<<<<< HEAD - var _t1799 interface{} - if *msg.FromSnapshot != "" { - return ptr(*msg.FromSnapshot) - } - _ = _t1799 -======= - var _t1878 interface{} + var _t1891 interface{} if *msg.FromSnapshot != "" { return ptr(*msg.FromSnapshot) } - _ = _t1878 ->>>>>>> origin/main + _ = _t1891 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_to_snapshot_optional(msg *pb.IcebergData) *string { -<<<<<<< HEAD - var _t1800 interface{} + var _t1892 interface{} if *msg.ToSnapshot != "" { return ptr(*msg.ToSnapshot) } - _ = _t1800 -======= - var _t1879 interface{} - if *msg.ToSnapshot != "" { - return ptr(*msg.ToSnapshot) - } - _ = _t1879 ->>>>>>> origin/main + _ = _t1892 return nil } func (p *PrettyPrinter) deconstruct_export_iceberg_config_optional(msg *pb.ExportIcebergConfig) [][]interface{} { result := [][]interface{}{} if *msg.Prefix != "" { -<<<<<<< HEAD - _t1801 := p._make_value_string(*msg.Prefix) - result = append(result, []interface{}{"prefix", _t1801}) - } - if *msg.TargetFileSizeBytes != 0 { - _t1802 := p._make_value_int64(*msg.TargetFileSizeBytes) - result = append(result, []interface{}{"target_file_size_bytes", _t1802}) - } - if msg.GetCompression() != "" { - _t1803 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"compression", _t1803}) - } - var _t1804 interface{} - if int64(len(result)) == 0 { - return nil - } - _ = _t1804 -======= - _t1880 := p._make_value_string(*msg.Prefix) - result = append(result, []interface{}{"prefix", _t1880}) + _t1893 := p._make_value_string(*msg.Prefix) + result = append(result, []interface{}{"prefix", _t1893}) } if *msg.TargetFileSizeBytes != 0 { - _t1881 := p._make_value_int64(*msg.TargetFileSizeBytes) - result = append(result, []interface{}{"target_file_size_bytes", _t1881}) + _t1894 := p._make_value_int64(*msg.TargetFileSizeBytes) + result = append(result, []interface{}{"target_file_size_bytes", _t1894}) } if msg.GetCompression() != "" { - _t1882 := p._make_value_string(msg.GetCompression()) - result = append(result, []interface{}{"compression", _t1882}) + _t1895 := p._make_value_string(msg.GetCompression()) + result = append(result, []interface{}{"compression", _t1895}) } - var _t1883 interface{} + var _t1896 interface{} if int64(len(result)) == 0 { return nil } - _ = _t1883 ->>>>>>> origin/main + _ = _t1896 return listSort(result) } @@ -827,19 +611,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) -<<<<<<< HEAD - var _t1805 interface{} - if name == nil { - return p.relationIdToUint128(msg) - } - _ = _t1805 -======= - var _t1884 interface{} + var _t1897 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1884 ->>>>>>> origin/main + _ = _t1897 return nil } @@ -857,87 +633,45 @@ func (p *PrettyPrinter) deconstruct_bindings_with_arity(abs *pb.Abstraction, val // --- Pretty-print methods --- func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { -<<<<<<< HEAD - flat813 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat813 != nil { - p.write(*flat813) - return nil - } else { - _dollar_dollar := msg - var _t1608 *pb.Configure - if hasProtoField(_dollar_dollar, "configure") { - _t1608 = _dollar_dollar.GetConfigure() - } - var _t1609 *pb.Sync - if hasProtoField(_dollar_dollar, "sync") { - _t1609 = _dollar_dollar.GetSync() - } - fields804 := []interface{}{_t1608, _t1609, _dollar_dollar.GetEpochs()} - unwrapped_fields805 := fields804 - p.write("(") - p.write("transaction") - p.indentSexp() - field806 := unwrapped_fields805[0].(*pb.Configure) - if field806 != nil { - p.newline() - opt_val807 := field806 - p.pretty_configure(opt_val807) - } - field808 := unwrapped_fields805[1].(*pb.Sync) - if field808 != nil { - p.newline() - opt_val809 := field808 - p.pretty_sync(opt_val809) - } - field810 := unwrapped_fields805[2].([]*pb.Epoch) - if !(len(field810) == 0) { - p.newline() - for i812, elem811 := range field810 { - if (i812 > 0) { - p.newline() - } - p.pretty_epoch(elem811) -======= - flat851 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) - if flat851 != nil { - p.write(*flat851) + flat856 := p.tryFlat(msg, func() { p.pretty_transaction(msg) }) + if flat856 != nil { + p.write(*flat856) return nil } else { _dollar_dollar := msg - var _t1684 *pb.Configure + var _t1694 *pb.Configure if hasProtoField(_dollar_dollar, "configure") { - _t1684 = _dollar_dollar.GetConfigure() + _t1694 = _dollar_dollar.GetConfigure() } - var _t1685 *pb.Sync + var _t1695 *pb.Sync if hasProtoField(_dollar_dollar, "sync") { - _t1685 = _dollar_dollar.GetSync() + _t1695 = _dollar_dollar.GetSync() } - fields842 := []interface{}{_t1684, _t1685, _dollar_dollar.GetEpochs()} - unwrapped_fields843 := fields842 + fields847 := []interface{}{_t1694, _t1695, _dollar_dollar.GetEpochs()} + unwrapped_fields848 := fields847 p.write("(") p.write("transaction") p.indentSexp() - field844 := unwrapped_fields843[0].(*pb.Configure) - if field844 != nil { + field849 := unwrapped_fields848[0].(*pb.Configure) + if field849 != nil { p.newline() - opt_val845 := field844 - p.pretty_configure(opt_val845) + opt_val850 := field849 + p.pretty_configure(opt_val850) } - field846 := unwrapped_fields843[1].(*pb.Sync) - if field846 != nil { + field851 := unwrapped_fields848[1].(*pb.Sync) + if field851 != nil { p.newline() - opt_val847 := field846 - p.pretty_sync(opt_val847) + opt_val852 := field851 + p.pretty_sync(opt_val852) } - field848 := unwrapped_fields843[2].([]*pb.Epoch) - if !(len(field848) == 0) { + field853 := unwrapped_fields848[2].([]*pb.Epoch) + if !(len(field853) == 0) { p.newline() - for i850, elem849 := range field848 { - if (i850 > 0) { + for i855, elem854 := range field853 { + if (i855 > 0) { p.newline() } - p.pretty_epoch(elem849) ->>>>>>> origin/main + p.pretty_epoch(elem854) } } p.dedent() @@ -947,36 +681,20 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { -<<<<<<< HEAD - flat816 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat816 != nil { - p.write(*flat816) - return nil - } else { - _dollar_dollar := msg - _t1610 := p.deconstruct_configure(_dollar_dollar) - fields814 := _t1610 - unwrapped_fields815 := fields814 -======= - flat854 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) - if flat854 != nil { - p.write(*flat854) + flat859 := p.tryFlat(msg, func() { p.pretty_configure(msg) }) + if flat859 != nil { + p.write(*flat859) return nil } else { _dollar_dollar := msg - _t1686 := p.deconstruct_configure(_dollar_dollar) - fields852 := _t1686 - unwrapped_fields853 := fields852 ->>>>>>> origin/main + _t1696 := p.deconstruct_configure(_dollar_dollar) + fields857 := _t1696 + unwrapped_fields858 := fields857 p.write("(") p.write("configure") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_config_dict(unwrapped_fields815) -======= - p.pretty_config_dict(unwrapped_fields853) ->>>>>>> origin/main + p.pretty_config_dict(unwrapped_fields858) p.dedent() p.write(")") } @@ -984,39 +702,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { -<<<<<<< HEAD - flat820 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat820 != nil { - p.write(*flat820) - return nil - } else { - fields817 := msg - p.write("{") - p.indent() - if !(len(fields817) == 0) { - p.newline() - for i819, elem818 := range fields817 { - if (i819 > 0) { - p.newline() - } - p.pretty_config_key_value(elem818) -======= - flat858 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) - if flat858 != nil { - p.write(*flat858) + flat863 := p.tryFlat(msg, func() { p.pretty_config_dict(msg) }) + if flat863 != nil { + p.write(*flat863) return nil } else { - fields855 := msg + fields860 := msg p.write("{") p.indent() - if !(len(fields855) == 0) { + if !(len(fields860) == 0) { p.newline() - for i857, elem856 := range fields855 { - if (i857 > 0) { + for i862, elem861 := range fields860 { + if (i862 > 0) { p.newline() } - p.pretty_config_key_value(elem856) ->>>>>>> origin/main + p.pretty_config_key_value(elem861) } } p.dedent() @@ -1026,299 +726,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { -<<<<<<< HEAD - flat825 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat825 != nil { - p.write(*flat825) - return nil - } else { - _dollar_dollar := msg - fields821 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} - unwrapped_fields822 := fields821 - p.write(":") - field823 := unwrapped_fields822[0].(string) - p.write(field823) - p.write(" ") - field824 := unwrapped_fields822[1].(*pb.Value) - p.pretty_raw_value(field824) -======= - flat863 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) - if flat863 != nil { - p.write(*flat863) + flat868 := p.tryFlat(msg, func() { p.pretty_config_key_value(msg) }) + if flat868 != nil { + p.write(*flat868) return nil } else { _dollar_dollar := msg - fields859 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} - unwrapped_fields860 := fields859 + fields864 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(*pb.Value)} + unwrapped_fields865 := fields864 p.write(":") - field861 := unwrapped_fields860[0].(string) - p.write(field861) + field866 := unwrapped_fields865[0].(string) + p.write(field866) p.write(" ") - field862 := unwrapped_fields860[1].(*pb.Value) - p.pretty_raw_value(field862) ->>>>>>> origin/main + field867 := unwrapped_fields865[1].(*pb.Value) + p.pretty_raw_value(field867) } return nil } func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { -<<<<<<< HEAD - flat851 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) - if flat851 != nil { - p.write(*flat851) - return nil - } else { - _dollar_dollar := msg - var _t1611 *pb.DateValue - if hasProtoField(_dollar_dollar, "date_value") { - _t1611 = _dollar_dollar.GetDateValue() - } - deconstruct_result849 := _t1611 - if deconstruct_result849 != nil { - unwrapped850 := deconstruct_result849 - p.pretty_raw_date(unwrapped850) - } else { - _dollar_dollar := msg - var _t1612 *pb.DateTimeValue - if hasProtoField(_dollar_dollar, "datetime_value") { - _t1612 = _dollar_dollar.GetDatetimeValue() - } - deconstruct_result847 := _t1612 - if deconstruct_result847 != nil { - unwrapped848 := deconstruct_result847 - p.pretty_raw_datetime(unwrapped848) - } else { - _dollar_dollar := msg - var _t1613 *string - if hasProtoField(_dollar_dollar, "string_value") { - _t1613 = ptr(_dollar_dollar.GetStringValue()) - } - deconstruct_result845 := _t1613 - if deconstruct_result845 != nil { - unwrapped846 := *deconstruct_result845 - p.write(p.formatStringValue(unwrapped846)) - } else { - _dollar_dollar := msg - var _t1614 *int32 - if hasProtoField(_dollar_dollar, "int32_value") { - _t1614 = ptr(_dollar_dollar.GetInt32Value()) - } - deconstruct_result843 := _t1614 - if deconstruct_result843 != nil { - unwrapped844 := *deconstruct_result843 - p.write(fmt.Sprintf("%di32", unwrapped844)) - } else { - _dollar_dollar := msg - var _t1615 *int64 - if hasProtoField(_dollar_dollar, "int_value") { - _t1615 = ptr(_dollar_dollar.GetIntValue()) - } - deconstruct_result841 := _t1615 - if deconstruct_result841 != nil { - unwrapped842 := *deconstruct_result841 - p.write(fmt.Sprintf("%d", unwrapped842)) - } else { - _dollar_dollar := msg - var _t1616 *float32 - if hasProtoField(_dollar_dollar, "float32_value") { - _t1616 = ptr(_dollar_dollar.GetFloat32Value()) - } - deconstruct_result839 := _t1616 - if deconstruct_result839 != nil { - unwrapped840 := *deconstruct_result839 - p.write(formatFloat32(unwrapped840)) - } else { - _dollar_dollar := msg - var _t1617 *float64 - if hasProtoField(_dollar_dollar, "float_value") { - _t1617 = ptr(_dollar_dollar.GetFloatValue()) - } - deconstruct_result837 := _t1617 - if deconstruct_result837 != nil { - unwrapped838 := *deconstruct_result837 - p.write(formatFloat64(unwrapped838)) - } else { - _dollar_dollar := msg - var _t1618 *uint32 - if hasProtoField(_dollar_dollar, "uint32_value") { - _t1618 = ptr(_dollar_dollar.GetUint32Value()) - } - deconstruct_result835 := _t1618 - if deconstruct_result835 != nil { - unwrapped836 := *deconstruct_result835 - p.write(fmt.Sprintf("%du32", unwrapped836)) - } else { - _dollar_dollar := msg - var _t1619 *pb.UInt128Value - if hasProtoField(_dollar_dollar, "uint128_value") { - _t1619 = _dollar_dollar.GetUint128Value() - } - deconstruct_result833 := _t1619 - if deconstruct_result833 != nil { - unwrapped834 := deconstruct_result833 - p.write(p.formatUint128(unwrapped834)) - } else { - _dollar_dollar := msg - var _t1620 *pb.Int128Value - if hasProtoField(_dollar_dollar, "int128_value") { - _t1620 = _dollar_dollar.GetInt128Value() - } - deconstruct_result831 := _t1620 - if deconstruct_result831 != nil { - unwrapped832 := deconstruct_result831 - p.write(p.formatInt128(unwrapped832)) - } else { - _dollar_dollar := msg - var _t1621 *pb.DecimalValue - if hasProtoField(_dollar_dollar, "decimal_value") { - _t1621 = _dollar_dollar.GetDecimalValue() - } - deconstruct_result829 := _t1621 - if deconstruct_result829 != nil { - unwrapped830 := deconstruct_result829 - p.write(p.formatDecimal(unwrapped830)) - } else { - _dollar_dollar := msg - var _t1622 *bool - if hasProtoField(_dollar_dollar, "boolean_value") { - _t1622 = ptr(_dollar_dollar.GetBooleanValue()) - } - deconstruct_result827 := _t1622 - if deconstruct_result827 != nil { - unwrapped828 := *deconstruct_result827 - p.pretty_boolean_value(unwrapped828) - } else { - fields826 := msg - _ = fields826 -======= - flat889 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) - if flat889 != nil { - p.write(*flat889) + flat894 := p.tryFlat(msg, func() { p.pretty_raw_value(msg) }) + if flat894 != nil { + p.write(*flat894) return nil } else { _dollar_dollar := msg - var _t1687 *pb.DateValue + var _t1697 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1687 = _dollar_dollar.GetDateValue() + _t1697 = _dollar_dollar.GetDateValue() } - deconstruct_result887 := _t1687 - if deconstruct_result887 != nil { - unwrapped888 := deconstruct_result887 - p.pretty_raw_date(unwrapped888) + deconstruct_result892 := _t1697 + if deconstruct_result892 != nil { + unwrapped893 := deconstruct_result892 + p.pretty_raw_date(unwrapped893) } else { _dollar_dollar := msg - var _t1688 *pb.DateTimeValue + var _t1698 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1688 = _dollar_dollar.GetDatetimeValue() + _t1698 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result885 := _t1688 - if deconstruct_result885 != nil { - unwrapped886 := deconstruct_result885 - p.pretty_raw_datetime(unwrapped886) + deconstruct_result890 := _t1698 + if deconstruct_result890 != nil { + unwrapped891 := deconstruct_result890 + p.pretty_raw_datetime(unwrapped891) } else { _dollar_dollar := msg - var _t1689 *string + var _t1699 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1689 = ptr(_dollar_dollar.GetStringValue()) + _t1699 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result883 := _t1689 - if deconstruct_result883 != nil { - unwrapped884 := *deconstruct_result883 - p.write(p.formatStringValue(unwrapped884)) + deconstruct_result888 := _t1699 + if deconstruct_result888 != nil { + unwrapped889 := *deconstruct_result888 + p.write(p.formatStringValue(unwrapped889)) } else { _dollar_dollar := msg - var _t1690 *int32 + var _t1700 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1690 = ptr(_dollar_dollar.GetInt32Value()) + _t1700 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result881 := _t1690 - if deconstruct_result881 != nil { - unwrapped882 := *deconstruct_result881 - p.write(fmt.Sprintf("%di32", unwrapped882)) + deconstruct_result886 := _t1700 + if deconstruct_result886 != nil { + unwrapped887 := *deconstruct_result886 + p.write(fmt.Sprintf("%di32", unwrapped887)) } else { _dollar_dollar := msg - var _t1691 *int64 + var _t1701 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1691 = ptr(_dollar_dollar.GetIntValue()) + _t1701 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result879 := _t1691 - if deconstruct_result879 != nil { - unwrapped880 := *deconstruct_result879 - p.write(fmt.Sprintf("%d", unwrapped880)) + deconstruct_result884 := _t1701 + if deconstruct_result884 != nil { + unwrapped885 := *deconstruct_result884 + p.write(fmt.Sprintf("%d", unwrapped885)) } else { _dollar_dollar := msg - var _t1692 *float32 + var _t1702 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1692 = ptr(_dollar_dollar.GetFloat32Value()) + _t1702 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result877 := _t1692 - if deconstruct_result877 != nil { - unwrapped878 := *deconstruct_result877 - p.write(formatFloat32(unwrapped878)) + deconstruct_result882 := _t1702 + if deconstruct_result882 != nil { + unwrapped883 := *deconstruct_result882 + p.write(formatFloat32(unwrapped883)) } else { _dollar_dollar := msg - var _t1693 *float64 + var _t1703 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1693 = ptr(_dollar_dollar.GetFloatValue()) + _t1703 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result875 := _t1693 - if deconstruct_result875 != nil { - unwrapped876 := *deconstruct_result875 - p.write(formatFloat64(unwrapped876)) + deconstruct_result880 := _t1703 + if deconstruct_result880 != nil { + unwrapped881 := *deconstruct_result880 + p.write(formatFloat64(unwrapped881)) } else { _dollar_dollar := msg - var _t1694 *uint32 + var _t1704 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1694 = ptr(_dollar_dollar.GetUint32Value()) + _t1704 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result873 := _t1694 - if deconstruct_result873 != nil { - unwrapped874 := *deconstruct_result873 - p.write(fmt.Sprintf("%du32", unwrapped874)) + deconstruct_result878 := _t1704 + if deconstruct_result878 != nil { + unwrapped879 := *deconstruct_result878 + p.write(fmt.Sprintf("%du32", unwrapped879)) } else { _dollar_dollar := msg - var _t1695 *pb.UInt128Value + var _t1705 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1695 = _dollar_dollar.GetUint128Value() + _t1705 = _dollar_dollar.GetUint128Value() } - deconstruct_result871 := _t1695 - if deconstruct_result871 != nil { - unwrapped872 := deconstruct_result871 - p.write(p.formatUint128(unwrapped872)) + deconstruct_result876 := _t1705 + if deconstruct_result876 != nil { + unwrapped877 := deconstruct_result876 + p.write(p.formatUint128(unwrapped877)) } else { _dollar_dollar := msg - var _t1696 *pb.Int128Value + var _t1706 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1696 = _dollar_dollar.GetInt128Value() + _t1706 = _dollar_dollar.GetInt128Value() } - deconstruct_result869 := _t1696 - if deconstruct_result869 != nil { - unwrapped870 := deconstruct_result869 - p.write(p.formatInt128(unwrapped870)) + deconstruct_result874 := _t1706 + if deconstruct_result874 != nil { + unwrapped875 := deconstruct_result874 + p.write(p.formatInt128(unwrapped875)) } else { _dollar_dollar := msg - var _t1697 *pb.DecimalValue + var _t1707 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1697 = _dollar_dollar.GetDecimalValue() + _t1707 = _dollar_dollar.GetDecimalValue() } - deconstruct_result867 := _t1697 - if deconstruct_result867 != nil { - unwrapped868 := deconstruct_result867 - p.write(p.formatDecimal(unwrapped868)) + deconstruct_result872 := _t1707 + if deconstruct_result872 != nil { + unwrapped873 := deconstruct_result872 + p.write(p.formatDecimal(unwrapped873)) } else { _dollar_dollar := msg - var _t1698 *bool + var _t1708 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1698 = ptr(_dollar_dollar.GetBooleanValue()) + _t1708 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result865 := _t1698 - if deconstruct_result865 != nil { - unwrapped866 := *deconstruct_result865 - p.pretty_boolean_value(unwrapped866) + deconstruct_result870 := _t1708 + if deconstruct_result870 != nil { + unwrapped871 := *deconstruct_result870 + p.pretty_boolean_value(unwrapped871) } else { - fields864 := msg - _ = fields864 ->>>>>>> origin/main + fields869 := msg + _ = fields869 p.write("missing") } } @@ -1337,48 +890,26 @@ func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { -<<<<<<< HEAD - flat857 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) - if flat857 != nil { - p.write(*flat857) - return nil - } else { - _dollar_dollar := msg - fields852 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields853 := fields852 -======= - flat895 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) - if flat895 != nil { - p.write(*flat895) + flat900 := p.tryFlat(msg, func() { p.pretty_raw_date(msg) }) + if flat900 != nil { + p.write(*flat900) return nil } else { _dollar_dollar := msg - fields890 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields891 := fields890 ->>>>>>> origin/main + fields895 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields896 := fields895 p.write("(") p.write("date") p.indentSexp() p.newline() -<<<<<<< HEAD - field854 := unwrapped_fields853[0].(int64) - p.write(fmt.Sprintf("%d", field854)) - p.newline() - field855 := unwrapped_fields853[1].(int64) - p.write(fmt.Sprintf("%d", field855)) + field897 := unwrapped_fields896[0].(int64) + p.write(fmt.Sprintf("%d", field897)) p.newline() - field856 := unwrapped_fields853[2].(int64) - p.write(fmt.Sprintf("%d", field856)) -======= - field892 := unwrapped_fields891[0].(int64) - p.write(fmt.Sprintf("%d", field892)) - p.newline() - field893 := unwrapped_fields891[1].(int64) - p.write(fmt.Sprintf("%d", field893)) + field898 := unwrapped_fields896[1].(int64) + p.write(fmt.Sprintf("%d", field898)) p.newline() - field894 := unwrapped_fields891[2].(int64) - p.write(fmt.Sprintf("%d", field894)) ->>>>>>> origin/main + field899 := unwrapped_fields896[2].(int64) + p.write(fmt.Sprintf("%d", field899)) p.dedent() p.write(")") } @@ -1386,76 +917,40 @@ func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { -<<<<<<< HEAD - flat868 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) - if flat868 != nil { - p.write(*flat868) - return nil - } else { - _dollar_dollar := msg - fields858 := []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_fields859 := fields858 -======= - flat906 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) - if flat906 != nil { - p.write(*flat906) + flat911 := p.tryFlat(msg, func() { p.pretty_raw_datetime(msg) }) + if flat911 != nil { + p.write(*flat911) return nil } else { _dollar_dollar := msg - fields896 := []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_fields897 := fields896 ->>>>>>> origin/main + 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 p.write("(") p.write("datetime") p.indentSexp() p.newline() -<<<<<<< HEAD - field860 := unwrapped_fields859[0].(int64) - p.write(fmt.Sprintf("%d", field860)) - p.newline() - field861 := unwrapped_fields859[1].(int64) - p.write(fmt.Sprintf("%d", field861)) - p.newline() - field862 := unwrapped_fields859[2].(int64) - p.write(fmt.Sprintf("%d", field862)) - p.newline() - field863 := unwrapped_fields859[3].(int64) - p.write(fmt.Sprintf("%d", field863)) - p.newline() - field864 := unwrapped_fields859[4].(int64) - p.write(fmt.Sprintf("%d", field864)) - p.newline() - field865 := unwrapped_fields859[5].(int64) - p.write(fmt.Sprintf("%d", field865)) - field866 := unwrapped_fields859[6].(*int64) - if field866 != nil { - p.newline() - opt_val867 := *field866 - p.write(fmt.Sprintf("%d", opt_val867)) -======= - field898 := unwrapped_fields897[0].(int64) - p.write(fmt.Sprintf("%d", field898)) + field903 := unwrapped_fields902[0].(int64) + p.write(fmt.Sprintf("%d", field903)) p.newline() - field899 := unwrapped_fields897[1].(int64) - p.write(fmt.Sprintf("%d", field899)) + field904 := unwrapped_fields902[1].(int64) + p.write(fmt.Sprintf("%d", field904)) p.newline() - field900 := unwrapped_fields897[2].(int64) - p.write(fmt.Sprintf("%d", field900)) + field905 := unwrapped_fields902[2].(int64) + p.write(fmt.Sprintf("%d", field905)) p.newline() - field901 := unwrapped_fields897[3].(int64) - p.write(fmt.Sprintf("%d", field901)) + field906 := unwrapped_fields902[3].(int64) + p.write(fmt.Sprintf("%d", field906)) p.newline() - field902 := unwrapped_fields897[4].(int64) - p.write(fmt.Sprintf("%d", field902)) + field907 := unwrapped_fields902[4].(int64) + p.write(fmt.Sprintf("%d", field907)) p.newline() - field903 := unwrapped_fields897[5].(int64) - p.write(fmt.Sprintf("%d", field903)) - field904 := unwrapped_fields897[6].(*int64) - if field904 != nil { + field908 := unwrapped_fields902[5].(int64) + p.write(fmt.Sprintf("%d", field908)) + field909 := unwrapped_fields902[6].(*int64) + if field909 != nil { p.newline() - opt_val905 := *field904 - p.write(fmt.Sprintf("%d", opt_val905)) ->>>>>>> origin/main + opt_val910 := *field909 + p.write(fmt.Sprintf("%d", opt_val910)) } p.dedent() p.write(")") @@ -1465,47 +960,25 @@ func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { _dollar_dollar := msg -<<<<<<< HEAD - var _t1623 []interface{} - if _dollar_dollar { - _t1623 = []interface{}{} - } - deconstruct_result871 := _t1623 - if deconstruct_result871 != nil { - unwrapped872 := deconstruct_result871 - _ = unwrapped872 - p.write("true") - } else { - _dollar_dollar := msg - var _t1624 []interface{} - if !(_dollar_dollar) { - _t1624 = []interface{}{} - } - deconstruct_result869 := _t1624 - if deconstruct_result869 != nil { - unwrapped870 := deconstruct_result869 - _ = unwrapped870 -======= - var _t1699 []interface{} + var _t1709 []interface{} if _dollar_dollar { - _t1699 = []interface{}{} + _t1709 = []interface{}{} } - deconstruct_result909 := _t1699 - if deconstruct_result909 != nil { - unwrapped910 := deconstruct_result909 - _ = unwrapped910 + deconstruct_result914 := _t1709 + if deconstruct_result914 != nil { + unwrapped915 := deconstruct_result914 + _ = unwrapped915 p.write("true") } else { _dollar_dollar := msg - var _t1700 []interface{} + var _t1710 []interface{} if !(_dollar_dollar) { - _t1700 = []interface{}{} + _t1710 = []interface{}{} } - deconstruct_result907 := _t1700 - if deconstruct_result907 != nil { - unwrapped908 := deconstruct_result907 - _ = unwrapped908 ->>>>>>> origin/main + deconstruct_result912 := _t1710 + if deconstruct_result912 != nil { + unwrapped913 := deconstruct_result912 + _ = unwrapped913 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -1515,45 +988,24 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { -<<<<<<< HEAD - flat877 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat877 != nil { - p.write(*flat877) - return nil - } else { - _dollar_dollar := msg - fields873 := _dollar_dollar.GetFragments() - unwrapped_fields874 := fields873 - p.write("(") - p.write("sync") - p.indentSexp() - if !(len(unwrapped_fields874) == 0) { - p.newline() - for i876, elem875 := range unwrapped_fields874 { - if (i876 > 0) { - p.newline() - } - p.pretty_fragment_id(elem875) -======= - flat915 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) - if flat915 != nil { - p.write(*flat915) + flat920 := p.tryFlat(msg, func() { p.pretty_sync(msg) }) + if flat920 != nil { + p.write(*flat920) return nil } else { _dollar_dollar := msg - fields911 := _dollar_dollar.GetFragments() - unwrapped_fields912 := fields911 + fields916 := _dollar_dollar.GetFragments() + unwrapped_fields917 := fields916 p.write("(") p.write("sync") p.indentSexp() - if !(len(unwrapped_fields912) == 0) { + if !(len(unwrapped_fields917) == 0) { p.newline() - for i914, elem913 := range unwrapped_fields912 { - if (i914 > 0) { + for i919, elem918 := range unwrapped_fields917 { + if (i919 > 0) { p.newline() } - p.pretty_fragment_id(elem913) ->>>>>>> origin/main + p.pretty_fragment_id(elem918) } } p.dedent() @@ -1563,97 +1015,51 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { -<<<<<<< HEAD - flat880 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat880 != nil { - p.write(*flat880) - return nil - } else { - _dollar_dollar := msg - fields878 := p.fragmentIdToString(_dollar_dollar) - unwrapped_fields879 := fields878 - p.write(":") - p.write(unwrapped_fields879) -======= - flat918 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) - if flat918 != nil { - p.write(*flat918) + flat923 := p.tryFlat(msg, func() { p.pretty_fragment_id(msg) }) + if flat923 != nil { + p.write(*flat923) return nil } else { _dollar_dollar := msg - fields916 := p.fragmentIdToString(_dollar_dollar) - unwrapped_fields917 := fields916 + fields921 := p.fragmentIdToString(_dollar_dollar) + unwrapped_fields922 := fields921 p.write(":") - p.write(unwrapped_fields917) ->>>>>>> origin/main + p.write(unwrapped_fields922) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { -<<<<<<< HEAD - flat887 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat887 != nil { - p.write(*flat887) - return nil - } else { - _dollar_dollar := msg - var _t1625 []*pb.Write - if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1625 = _dollar_dollar.GetWrites() - } - var _t1626 []*pb.Read - if !(len(_dollar_dollar.GetReads()) == 0) { - _t1626 = _dollar_dollar.GetReads() - } - fields881 := []interface{}{_t1625, _t1626} - unwrapped_fields882 := fields881 - p.write("(") - p.write("epoch") - p.indentSexp() - field883 := unwrapped_fields882[0].([]*pb.Write) - if field883 != nil { - p.newline() - opt_val884 := field883 - p.pretty_epoch_writes(opt_val884) - } - field885 := unwrapped_fields882[1].([]*pb.Read) - if field885 != nil { - p.newline() - opt_val886 := field885 - p.pretty_epoch_reads(opt_val886) -======= - flat925 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) - if flat925 != nil { - p.write(*flat925) + flat930 := p.tryFlat(msg, func() { p.pretty_epoch(msg) }) + if flat930 != nil { + p.write(*flat930) return nil } else { _dollar_dollar := msg - var _t1701 []*pb.Write + var _t1711 []*pb.Write if !(len(_dollar_dollar.GetWrites()) == 0) { - _t1701 = _dollar_dollar.GetWrites() + _t1711 = _dollar_dollar.GetWrites() } - var _t1702 []*pb.Read + var _t1712 []*pb.Read if !(len(_dollar_dollar.GetReads()) == 0) { - _t1702 = _dollar_dollar.GetReads() + _t1712 = _dollar_dollar.GetReads() } - fields919 := []interface{}{_t1701, _t1702} - unwrapped_fields920 := fields919 + fields924 := []interface{}{_t1711, _t1712} + unwrapped_fields925 := fields924 p.write("(") p.write("epoch") p.indentSexp() - field921 := unwrapped_fields920[0].([]*pb.Write) - if field921 != nil { + field926 := unwrapped_fields925[0].([]*pb.Write) + if field926 != nil { p.newline() - opt_val922 := field921 - p.pretty_epoch_writes(opt_val922) + opt_val927 := field926 + p.pretty_epoch_writes(opt_val927) } - field923 := unwrapped_fields920[1].([]*pb.Read) - if field923 != nil { + field928 := unwrapped_fields925[1].([]*pb.Read) + if field928 != nil { p.newline() - opt_val924 := field923 - p.pretty_epoch_reads(opt_val924) ->>>>>>> origin/main + opt_val929 := field928 + p.pretty_epoch_reads(opt_val929) } p.dedent() p.write(")") @@ -1662,41 +1068,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { -<<<<<<< HEAD - flat891 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat891 != nil { - p.write(*flat891) - return nil - } else { - fields888 := msg - p.write("(") - p.write("writes") - p.indentSexp() - if !(len(fields888) == 0) { - p.newline() - for i890, elem889 := range fields888 { - if (i890 > 0) { - p.newline() - } - p.pretty_write(elem889) -======= - flat929 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) - if flat929 != nil { - p.write(*flat929) + flat934 := p.tryFlat(msg, func() { p.pretty_epoch_writes(msg) }) + if flat934 != nil { + p.write(*flat934) return nil } else { - fields926 := msg + fields931 := msg p.write("(") p.write("writes") p.indentSexp() - if !(len(fields926) == 0) { + if !(len(fields931) == 0) { p.newline() - for i928, elem927 := range fields926 { - if (i928 > 0) { + for i933, elem932 := range fields931 { + if (i933 > 0) { p.newline() } - p.pretty_write(elem927) ->>>>>>> origin/main + p.pretty_write(elem932) } } p.dedent() @@ -1706,136 +1093,74 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { -<<<<<<< HEAD - flat900 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat900 != nil { - p.write(*flat900) + flat943 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat943 != nil { + p.write(*flat943) return nil } else { _dollar_dollar := msg - var _t1627 *pb.Define + var _t1713 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1627 = _dollar_dollar.GetDefine() + _t1713 = _dollar_dollar.GetDefine() } - deconstruct_result898 := _t1627 - if deconstruct_result898 != nil { - unwrapped899 := deconstruct_result898 - p.pretty_define(unwrapped899) + deconstruct_result941 := _t1713 + if deconstruct_result941 != nil { + unwrapped942 := deconstruct_result941 + p.pretty_define(unwrapped942) } else { _dollar_dollar := msg - var _t1628 *pb.Undefine + var _t1714 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1628 = _dollar_dollar.GetUndefine() + _t1714 = _dollar_dollar.GetUndefine() } - deconstruct_result896 := _t1628 - if deconstruct_result896 != nil { - unwrapped897 := deconstruct_result896 - p.pretty_undefine(unwrapped897) + deconstruct_result939 := _t1714 + if deconstruct_result939 != nil { + unwrapped940 := deconstruct_result939 + p.pretty_undefine(unwrapped940) } else { _dollar_dollar := msg - var _t1629 *pb.Context + var _t1715 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1629 = _dollar_dollar.GetContext() + _t1715 = _dollar_dollar.GetContext() } - deconstruct_result894 := _t1629 - if deconstruct_result894 != nil { - unwrapped895 := deconstruct_result894 - p.pretty_context(unwrapped895) + deconstruct_result937 := _t1715 + if deconstruct_result937 != nil { + unwrapped938 := deconstruct_result937 + p.pretty_context(unwrapped938) } else { _dollar_dollar := msg - var _t1630 *pb.Snapshot + var _t1716 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1630 = _dollar_dollar.GetSnapshot() + _t1716 = _dollar_dollar.GetSnapshot() } - deconstruct_result892 := _t1630 - if deconstruct_result892 != nil { - unwrapped893 := deconstruct_result892 - p.pretty_snapshot(unwrapped893) -======= - flat938 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat938 != nil { - p.write(*flat938) - return nil - } else { - _dollar_dollar := msg - var _t1703 *pb.Define - if hasProtoField(_dollar_dollar, "define") { - _t1703 = _dollar_dollar.GetDefine() - } - deconstruct_result936 := _t1703 - if deconstruct_result936 != nil { - unwrapped937 := deconstruct_result936 - p.pretty_define(unwrapped937) - } else { - _dollar_dollar := msg - var _t1704 *pb.Undefine - if hasProtoField(_dollar_dollar, "undefine") { - _t1704 = _dollar_dollar.GetUndefine() - } - deconstruct_result934 := _t1704 - if deconstruct_result934 != nil { - unwrapped935 := deconstruct_result934 - p.pretty_undefine(unwrapped935) - } else { - _dollar_dollar := msg - var _t1705 *pb.Context - if hasProtoField(_dollar_dollar, "context") { - _t1705 = _dollar_dollar.GetContext() - } - deconstruct_result932 := _t1705 - if deconstruct_result932 != nil { - unwrapped933 := deconstruct_result932 - p.pretty_context(unwrapped933) - } else { - _dollar_dollar := msg - var _t1706 *pb.Snapshot - if hasProtoField(_dollar_dollar, "snapshot") { - _t1706 = _dollar_dollar.GetSnapshot() - } - deconstruct_result930 := _t1706 - if deconstruct_result930 != nil { - unwrapped931 := deconstruct_result930 - p.pretty_snapshot(unwrapped931) ->>>>>>> origin/main - } else { - panic(ParseError{msg: "No matching rule for write"}) - } - } - } + deconstruct_result935 := _t1716 + if deconstruct_result935 != nil { + unwrapped936 := deconstruct_result935 + p.pretty_snapshot(unwrapped936) + } else { + panic(ParseError{msg: "No matching rule for write"}) + } + } + } } } return nil } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { -<<<<<<< HEAD - flat903 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat903 != nil { - p.write(*flat903) - return nil - } else { - _dollar_dollar := msg - fields901 := _dollar_dollar.GetFragment() - unwrapped_fields902 := fields901 -======= - flat941 := p.tryFlat(msg, func() { p.pretty_define(msg) }) - if flat941 != nil { - p.write(*flat941) + flat946 := p.tryFlat(msg, func() { p.pretty_define(msg) }) + if flat946 != nil { + p.write(*flat946) return nil } else { _dollar_dollar := msg - fields939 := _dollar_dollar.GetFragment() - unwrapped_fields940 := fields939 ->>>>>>> origin/main + fields944 := _dollar_dollar.GetFragment() + unwrapped_fields945 := fields944 p.write("(") p.write("define") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_fragment(unwrapped_fields902) -======= - p.pretty_fragment(unwrapped_fields940) ->>>>>>> origin/main + p.pretty_fragment(unwrapped_fields945) p.dedent() p.write(")") } @@ -1843,53 +1168,29 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { -<<<<<<< HEAD - flat910 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat910 != nil { - p.write(*flat910) -======= - flat948 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat948 != nil { - p.write(*flat948) ->>>>>>> origin/main + flat953 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) + if flat953 != nil { + p.write(*flat953) return nil } else { _dollar_dollar := msg p.startPrettyFragment(_dollar_dollar) -<<<<<<< HEAD - fields904 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} - unwrapped_fields905 := fields904 -======= - fields942 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} - unwrapped_fields943 := fields942 ->>>>>>> origin/main + fields947 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} + unwrapped_fields948 := fields947 p.write("(") p.write("fragment") p.indentSexp() p.newline() -<<<<<<< HEAD - field906 := unwrapped_fields905[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field906) - field907 := unwrapped_fields905[1].([]*pb.Declaration) - if !(len(field907) == 0) { - p.newline() - for i909, elem908 := range field907 { - if (i909 > 0) { - p.newline() - } - p.pretty_declaration(elem908) -======= - field944 := unwrapped_fields943[0].(*pb.FragmentId) - p.pretty_new_fragment_id(field944) - field945 := unwrapped_fields943[1].([]*pb.Declaration) - if !(len(field945) == 0) { + field949 := unwrapped_fields948[0].(*pb.FragmentId) + p.pretty_new_fragment_id(field949) + field950 := unwrapped_fields948[1].([]*pb.Declaration) + if !(len(field950) == 0) { p.newline() - for i947, elem946 := range field945 { - if (i947 > 0) { + for i952, elem951 := range field950 { + if (i952 > 0) { p.newline() } - p.pretty_declaration(elem946) ->>>>>>> origin/main + p.pretty_declaration(elem951) } } p.dedent() @@ -1899,119 +1200,62 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { -<<<<<<< HEAD - flat912 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat912 != nil { - p.write(*flat912) - return nil - } else { - fields911 := msg - p.pretty_fragment_id(fields911) -======= - flat950 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) - if flat950 != nil { - p.write(*flat950) + flat955 := p.tryFlat(msg, func() { p.pretty_new_fragment_id(msg) }) + if flat955 != nil { + p.write(*flat955) return nil } else { - fields949 := msg - p.pretty_fragment_id(fields949) ->>>>>>> origin/main + fields954 := msg + p.pretty_fragment_id(fields954) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { -<<<<<<< HEAD - flat921 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat921 != nil { - p.write(*flat921) - return nil - } else { - _dollar_dollar := msg - var _t1631 *pb.Def - if hasProtoField(_dollar_dollar, "def") { - _t1631 = _dollar_dollar.GetDef() - } - deconstruct_result919 := _t1631 - if deconstruct_result919 != nil { - unwrapped920 := deconstruct_result919 - p.pretty_def(unwrapped920) - } else { - _dollar_dollar := msg - var _t1632 *pb.Algorithm - if hasProtoField(_dollar_dollar, "algorithm") { - _t1632 = _dollar_dollar.GetAlgorithm() - } - deconstruct_result917 := _t1632 - if deconstruct_result917 != nil { - unwrapped918 := deconstruct_result917 - p.pretty_algorithm(unwrapped918) - } else { - _dollar_dollar := msg - var _t1633 *pb.Constraint - if hasProtoField(_dollar_dollar, "constraint") { - _t1633 = _dollar_dollar.GetConstraint() - } - deconstruct_result915 := _t1633 - if deconstruct_result915 != nil { - unwrapped916 := deconstruct_result915 - p.pretty_constraint(unwrapped916) - } else { - _dollar_dollar := msg - var _t1634 *pb.Data - if hasProtoField(_dollar_dollar, "data") { - _t1634 = _dollar_dollar.GetData() - } - deconstruct_result913 := _t1634 - if deconstruct_result913 != nil { - unwrapped914 := deconstruct_result913 - p.pretty_data(unwrapped914) -======= - flat959 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) - if flat959 != nil { - p.write(*flat959) + flat964 := p.tryFlat(msg, func() { p.pretty_declaration(msg) }) + if flat964 != nil { + p.write(*flat964) return nil } else { _dollar_dollar := msg - var _t1707 *pb.Def + var _t1717 *pb.Def if hasProtoField(_dollar_dollar, "def") { - _t1707 = _dollar_dollar.GetDef() + _t1717 = _dollar_dollar.GetDef() } - deconstruct_result957 := _t1707 - if deconstruct_result957 != nil { - unwrapped958 := deconstruct_result957 - p.pretty_def(unwrapped958) + deconstruct_result962 := _t1717 + if deconstruct_result962 != nil { + unwrapped963 := deconstruct_result962 + p.pretty_def(unwrapped963) } else { _dollar_dollar := msg - var _t1708 *pb.Algorithm + var _t1718 *pb.Algorithm if hasProtoField(_dollar_dollar, "algorithm") { - _t1708 = _dollar_dollar.GetAlgorithm() + _t1718 = _dollar_dollar.GetAlgorithm() } - deconstruct_result955 := _t1708 - if deconstruct_result955 != nil { - unwrapped956 := deconstruct_result955 - p.pretty_algorithm(unwrapped956) + deconstruct_result960 := _t1718 + if deconstruct_result960 != nil { + unwrapped961 := deconstruct_result960 + p.pretty_algorithm(unwrapped961) } else { _dollar_dollar := msg - var _t1709 *pb.Constraint + var _t1719 *pb.Constraint if hasProtoField(_dollar_dollar, "constraint") { - _t1709 = _dollar_dollar.GetConstraint() + _t1719 = _dollar_dollar.GetConstraint() } - deconstruct_result953 := _t1709 - if deconstruct_result953 != nil { - unwrapped954 := deconstruct_result953 - p.pretty_constraint(unwrapped954) + deconstruct_result958 := _t1719 + if deconstruct_result958 != nil { + unwrapped959 := deconstruct_result958 + p.pretty_constraint(unwrapped959) } else { _dollar_dollar := msg - var _t1710 *pb.Data + var _t1720 *pb.Data if hasProtoField(_dollar_dollar, "data") { - _t1710 = _dollar_dollar.GetData() + _t1720 = _dollar_dollar.GetData() } - deconstruct_result951 := _t1710 - if deconstruct_result951 != nil { - unwrapped952 := deconstruct_result951 - p.pretty_data(unwrapped952) ->>>>>>> origin/main + deconstruct_result956 := _t1720 + if deconstruct_result956 != nil { + unwrapped957 := deconstruct_result956 + p.pretty_data(unwrapped957) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -2023,60 +1267,32 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { -<<<<<<< HEAD - flat928 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat928 != nil { - p.write(*flat928) - return nil - } else { - _dollar_dollar := msg - var _t1635 []*pb.Attribute - if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1635 = _dollar_dollar.GetAttrs() - } - fields922 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1635} - unwrapped_fields923 := fields922 -======= - flat966 := p.tryFlat(msg, func() { p.pretty_def(msg) }) - if flat966 != nil { - p.write(*flat966) + flat971 := p.tryFlat(msg, func() { p.pretty_def(msg) }) + if flat971 != nil { + p.write(*flat971) return nil } else { _dollar_dollar := msg - var _t1711 []*pb.Attribute + var _t1721 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1711 = _dollar_dollar.GetAttrs() + _t1721 = _dollar_dollar.GetAttrs() } - fields960 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1711} - unwrapped_fields961 := fields960 ->>>>>>> origin/main + fields965 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1721} + unwrapped_fields966 := fields965 p.write("(") p.write("def") p.indentSexp() p.newline() -<<<<<<< HEAD - field924 := unwrapped_fields923[0].(*pb.RelationId) - p.pretty_relation_id(field924) + field967 := unwrapped_fields966[0].(*pb.RelationId) + p.pretty_relation_id(field967) p.newline() - field925 := unwrapped_fields923[1].(*pb.Abstraction) - p.pretty_abstraction(field925) - field926 := unwrapped_fields923[2].([]*pb.Attribute) - if field926 != nil { - p.newline() - opt_val927 := field926 - p.pretty_attrs(opt_val927) -======= - field962 := unwrapped_fields961[0].(*pb.RelationId) - p.pretty_relation_id(field962) - p.newline() - field963 := unwrapped_fields961[1].(*pb.Abstraction) - p.pretty_abstraction(field963) - field964 := unwrapped_fields961[2].([]*pb.Attribute) - if field964 != nil { + field968 := unwrapped_fields966[1].(*pb.Abstraction) + p.pretty_abstraction(field968) + field969 := unwrapped_fields966[2].([]*pb.Attribute) + if field969 != nil { p.newline() - opt_val965 := field964 - p.pretty_attrs(opt_val965) ->>>>>>> origin/main + opt_val970 := field969 + p.pretty_attrs(opt_val970) } p.dedent() p.write(")") @@ -2085,55 +1301,29 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { -<<<<<<< HEAD - flat933 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat933 != nil { - p.write(*flat933) - return nil - } else { - _dollar_dollar := msg - var _t1636 *string - if p.relationIdToString(_dollar_dollar) != nil { - _t1637 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1636 = ptr(_t1637) - } - deconstruct_result931 := _t1636 - if deconstruct_result931 != nil { - unwrapped932 := *deconstruct_result931 - p.write(":") - p.write(unwrapped932) - } else { - _dollar_dollar := msg - _t1638 := p.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result929 := _t1638 - if deconstruct_result929 != nil { - unwrapped930 := deconstruct_result929 - p.write(p.formatUint128(unwrapped930)) -======= - flat971 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) - if flat971 != nil { - p.write(*flat971) + flat976 := p.tryFlat(msg, func() { p.pretty_relation_id(msg) }) + if flat976 != nil { + p.write(*flat976) return nil } else { _dollar_dollar := msg - var _t1712 *string + var _t1722 *string if p.relationIdToString(_dollar_dollar) != nil { - _t1713 := p.deconstruct_relation_id_string(_dollar_dollar) - _t1712 = ptr(_t1713) + _t1723 := p.deconstruct_relation_id_string(_dollar_dollar) + _t1722 = ptr(_t1723) } - deconstruct_result969 := _t1712 - if deconstruct_result969 != nil { - unwrapped970 := *deconstruct_result969 + deconstruct_result974 := _t1722 + if deconstruct_result974 != nil { + unwrapped975 := *deconstruct_result974 p.write(":") - p.write(unwrapped970) + p.write(unwrapped975) } else { _dollar_dollar := msg - _t1714 := p.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result967 := _t1714 - if deconstruct_result967 != nil { - unwrapped968 := deconstruct_result967 - p.write(p.formatUint128(unwrapped968)) ->>>>>>> origin/main + _t1724 := p.deconstruct_relation_id_uint128(_dollar_dollar) + deconstruct_result972 := _t1724 + if deconstruct_result972 != nil { + unwrapped973 := deconstruct_result972 + p.write(p.formatUint128(unwrapped973)) } else { panic(ParseError{msg: "No matching rule for relation_id"}) } @@ -2143,41 +1333,22 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { -<<<<<<< HEAD - flat938 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat938 != nil { - p.write(*flat938) - return nil - } else { - _dollar_dollar := msg - _t1639 := p.deconstruct_bindings(_dollar_dollar) - fields934 := []interface{}{_t1639, _dollar_dollar.GetValue()} - unwrapped_fields935 := fields934 - p.write("(") - p.indent() - field936 := unwrapped_fields935[0].([]interface{}) - p.pretty_bindings(field936) - p.newline() - field937 := unwrapped_fields935[1].(*pb.Formula) - p.pretty_formula(field937) -======= - flat976 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) - if flat976 != nil { - p.write(*flat976) + flat981 := p.tryFlat(msg, func() { p.pretty_abstraction(msg) }) + if flat981 != nil { + p.write(*flat981) return nil } else { _dollar_dollar := msg - _t1715 := p.deconstruct_bindings(_dollar_dollar) - fields972 := []interface{}{_t1715, _dollar_dollar.GetValue()} - unwrapped_fields973 := fields972 + _t1725 := p.deconstruct_bindings(_dollar_dollar) + fields977 := []interface{}{_t1725, _dollar_dollar.GetValue()} + unwrapped_fields978 := fields977 p.write("(") p.indent() - field974 := unwrapped_fields973[0].([]interface{}) - p.pretty_bindings(field974) + field979 := unwrapped_fields978[0].([]interface{}) + p.pretty_bindings(field979) p.newline() - field975 := unwrapped_fields973[1].(*pb.Formula) - p.pretty_formula(field975) ->>>>>>> origin/main + field980 := unwrapped_fields978[1].(*pb.Formula) + p.pretty_formula(field980) p.dedent() p.write(")") } @@ -2185,61 +1356,32 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { -<<<<<<< HEAD - flat946 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat946 != nil { - p.write(*flat946) - return nil - } else { - _dollar_dollar := msg - var _t1640 []*pb.Binding - if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1640 = _dollar_dollar[1].([]*pb.Binding) - } - fields939 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1640} - unwrapped_fields940 := fields939 - p.write("[") - p.indent() - field941 := unwrapped_fields940[0].([]*pb.Binding) - for i943, elem942 := range field941 { - if (i943 > 0) { - p.newline() - } - p.pretty_binding(elem942) - } - field944 := unwrapped_fields940[1].([]*pb.Binding) - if field944 != nil { - p.newline() - opt_val945 := field944 - p.pretty_value_bindings(opt_val945) -======= - flat984 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) - if flat984 != nil { - p.write(*flat984) + flat989 := p.tryFlat(msg, func() { p.pretty_bindings(msg) }) + if flat989 != nil { + p.write(*flat989) return nil } else { _dollar_dollar := msg - var _t1716 []*pb.Binding + var _t1726 []*pb.Binding if !(len(_dollar_dollar[1].([]*pb.Binding)) == 0) { - _t1716 = _dollar_dollar[1].([]*pb.Binding) + _t1726 = _dollar_dollar[1].([]*pb.Binding) } - fields977 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1716} - unwrapped_fields978 := fields977 + fields982 := []interface{}{_dollar_dollar[0].([]*pb.Binding), _t1726} + unwrapped_fields983 := fields982 p.write("[") p.indent() - field979 := unwrapped_fields978[0].([]*pb.Binding) - for i981, elem980 := range field979 { - if (i981 > 0) { + field984 := unwrapped_fields983[0].([]*pb.Binding) + for i986, elem985 := range field984 { + if (i986 > 0) { p.newline() } - p.pretty_binding(elem980) + p.pretty_binding(elem985) } - field982 := unwrapped_fields978[1].([]*pb.Binding) - if field982 != nil { + field987 := unwrapped_fields983[1].([]*pb.Binding) + if field987 != nil { p.newline() - opt_val983 := field982 - p.pretty_value_bindings(opt_val983) ->>>>>>> origin/main + opt_val988 := field987 + p.pretty_value_bindings(opt_val988) } p.dedent() p.write("]") @@ -2248,331 +1390,168 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { -<<<<<<< HEAD - flat951 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat951 != nil { - p.write(*flat951) - return nil - } else { - _dollar_dollar := msg - fields947 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} - unwrapped_fields948 := fields947 - field949 := unwrapped_fields948[0].(string) - p.write(field949) - p.write("::") - field950 := unwrapped_fields948[1].(*pb.Type) - p.pretty_type(field950) -======= - flat989 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) - if flat989 != nil { - p.write(*flat989) + flat994 := p.tryFlat(msg, func() { p.pretty_binding(msg) }) + if flat994 != nil { + p.write(*flat994) return nil } else { _dollar_dollar := msg - fields985 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} - unwrapped_fields986 := fields985 - field987 := unwrapped_fields986[0].(string) - p.write(field987) + fields990 := []interface{}{_dollar_dollar.GetVar().GetName(), _dollar_dollar.GetType()} + unwrapped_fields991 := fields990 + field992 := unwrapped_fields991[0].(string) + p.write(field992) p.write("::") - field988 := unwrapped_fields986[1].(*pb.Type) - p.pretty_type(field988) ->>>>>>> origin/main + field993 := unwrapped_fields991[1].(*pb.Type) + p.pretty_type(field993) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { -<<<<<<< HEAD - flat980 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat980 != nil { - p.write(*flat980) - return nil - } else { - _dollar_dollar := msg - var _t1641 *pb.UnspecifiedType - if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1641 = _dollar_dollar.GetUnspecifiedType() - } - deconstruct_result978 := _t1641 - if deconstruct_result978 != nil { - unwrapped979 := deconstruct_result978 - p.pretty_unspecified_type(unwrapped979) - } else { - _dollar_dollar := msg - var _t1642 *pb.StringType - if hasProtoField(_dollar_dollar, "string_type") { - _t1642 = _dollar_dollar.GetStringType() - } - deconstruct_result976 := _t1642 - if deconstruct_result976 != nil { - unwrapped977 := deconstruct_result976 - p.pretty_string_type(unwrapped977) - } else { - _dollar_dollar := msg - var _t1643 *pb.IntType - if hasProtoField(_dollar_dollar, "int_type") { - _t1643 = _dollar_dollar.GetIntType() - } - deconstruct_result974 := _t1643 - if deconstruct_result974 != nil { - unwrapped975 := deconstruct_result974 - p.pretty_int_type(unwrapped975) - } else { - _dollar_dollar := msg - var _t1644 *pb.FloatType - if hasProtoField(_dollar_dollar, "float_type") { - _t1644 = _dollar_dollar.GetFloatType() - } - deconstruct_result972 := _t1644 - if deconstruct_result972 != nil { - unwrapped973 := deconstruct_result972 - p.pretty_float_type(unwrapped973) - } else { - _dollar_dollar := msg - var _t1645 *pb.UInt128Type - if hasProtoField(_dollar_dollar, "uint128_type") { - _t1645 = _dollar_dollar.GetUint128Type() - } - deconstruct_result970 := _t1645 - if deconstruct_result970 != nil { - unwrapped971 := deconstruct_result970 - p.pretty_uint128_type(unwrapped971) - } else { - _dollar_dollar := msg - var _t1646 *pb.Int128Type - if hasProtoField(_dollar_dollar, "int128_type") { - _t1646 = _dollar_dollar.GetInt128Type() - } - deconstruct_result968 := _t1646 - if deconstruct_result968 != nil { - unwrapped969 := deconstruct_result968 - p.pretty_int128_type(unwrapped969) - } else { - _dollar_dollar := msg - var _t1647 *pb.DateType - if hasProtoField(_dollar_dollar, "date_type") { - _t1647 = _dollar_dollar.GetDateType() - } - deconstruct_result966 := _t1647 - if deconstruct_result966 != nil { - unwrapped967 := deconstruct_result966 - p.pretty_date_type(unwrapped967) - } else { - _dollar_dollar := msg - var _t1648 *pb.DateTimeType - if hasProtoField(_dollar_dollar, "datetime_type") { - _t1648 = _dollar_dollar.GetDatetimeType() - } - deconstruct_result964 := _t1648 - if deconstruct_result964 != nil { - unwrapped965 := deconstruct_result964 - p.pretty_datetime_type(unwrapped965) - } else { - _dollar_dollar := msg - var _t1649 *pb.MissingType - if hasProtoField(_dollar_dollar, "missing_type") { - _t1649 = _dollar_dollar.GetMissingType() - } - deconstruct_result962 := _t1649 - if deconstruct_result962 != nil { - unwrapped963 := deconstruct_result962 - p.pretty_missing_type(unwrapped963) - } else { - _dollar_dollar := msg - var _t1650 *pb.DecimalType - if hasProtoField(_dollar_dollar, "decimal_type") { - _t1650 = _dollar_dollar.GetDecimalType() - } - deconstruct_result960 := _t1650 - if deconstruct_result960 != nil { - unwrapped961 := deconstruct_result960 - p.pretty_decimal_type(unwrapped961) - } else { - _dollar_dollar := msg - var _t1651 *pb.BooleanType - if hasProtoField(_dollar_dollar, "boolean_type") { - _t1651 = _dollar_dollar.GetBooleanType() - } - deconstruct_result958 := _t1651 - if deconstruct_result958 != nil { - unwrapped959 := deconstruct_result958 - p.pretty_boolean_type(unwrapped959) - } else { - _dollar_dollar := msg - var _t1652 *pb.Int32Type - if hasProtoField(_dollar_dollar, "int32_type") { - _t1652 = _dollar_dollar.GetInt32Type() - } - deconstruct_result956 := _t1652 - if deconstruct_result956 != nil { - unwrapped957 := deconstruct_result956 - p.pretty_int32_type(unwrapped957) - } else { - _dollar_dollar := msg - var _t1653 *pb.Float32Type - if hasProtoField(_dollar_dollar, "float32_type") { - _t1653 = _dollar_dollar.GetFloat32Type() - } - deconstruct_result954 := _t1653 - if deconstruct_result954 != nil { - unwrapped955 := deconstruct_result954 - p.pretty_float32_type(unwrapped955) - } else { - _dollar_dollar := msg - var _t1654 *pb.UInt32Type - if hasProtoField(_dollar_dollar, "uint32_type") { - _t1654 = _dollar_dollar.GetUint32Type() - } - deconstruct_result952 := _t1654 - if deconstruct_result952 != nil { - unwrapped953 := deconstruct_result952 - p.pretty_uint32_type(unwrapped953) -======= - flat1018 := p.tryFlat(msg, func() { p.pretty_type(msg) }) - if flat1018 != nil { - p.write(*flat1018) + flat1023 := p.tryFlat(msg, func() { p.pretty_type(msg) }) + if flat1023 != nil { + p.write(*flat1023) return nil } else { _dollar_dollar := msg - var _t1717 *pb.UnspecifiedType + var _t1727 *pb.UnspecifiedType if hasProtoField(_dollar_dollar, "unspecified_type") { - _t1717 = _dollar_dollar.GetUnspecifiedType() + _t1727 = _dollar_dollar.GetUnspecifiedType() } - deconstruct_result1016 := _t1717 - if deconstruct_result1016 != nil { - unwrapped1017 := deconstruct_result1016 - p.pretty_unspecified_type(unwrapped1017) + deconstruct_result1021 := _t1727 + if deconstruct_result1021 != nil { + unwrapped1022 := deconstruct_result1021 + p.pretty_unspecified_type(unwrapped1022) } else { _dollar_dollar := msg - var _t1718 *pb.StringType + var _t1728 *pb.StringType if hasProtoField(_dollar_dollar, "string_type") { - _t1718 = _dollar_dollar.GetStringType() + _t1728 = _dollar_dollar.GetStringType() } - deconstruct_result1014 := _t1718 - if deconstruct_result1014 != nil { - unwrapped1015 := deconstruct_result1014 - p.pretty_string_type(unwrapped1015) + deconstruct_result1019 := _t1728 + if deconstruct_result1019 != nil { + unwrapped1020 := deconstruct_result1019 + p.pretty_string_type(unwrapped1020) } else { _dollar_dollar := msg - var _t1719 *pb.IntType + var _t1729 *pb.IntType if hasProtoField(_dollar_dollar, "int_type") { - _t1719 = _dollar_dollar.GetIntType() + _t1729 = _dollar_dollar.GetIntType() } - deconstruct_result1012 := _t1719 - if deconstruct_result1012 != nil { - unwrapped1013 := deconstruct_result1012 - p.pretty_int_type(unwrapped1013) + deconstruct_result1017 := _t1729 + if deconstruct_result1017 != nil { + unwrapped1018 := deconstruct_result1017 + p.pretty_int_type(unwrapped1018) } else { _dollar_dollar := msg - var _t1720 *pb.FloatType + var _t1730 *pb.FloatType if hasProtoField(_dollar_dollar, "float_type") { - _t1720 = _dollar_dollar.GetFloatType() + _t1730 = _dollar_dollar.GetFloatType() } - deconstruct_result1010 := _t1720 - if deconstruct_result1010 != nil { - unwrapped1011 := deconstruct_result1010 - p.pretty_float_type(unwrapped1011) + deconstruct_result1015 := _t1730 + if deconstruct_result1015 != nil { + unwrapped1016 := deconstruct_result1015 + p.pretty_float_type(unwrapped1016) } else { _dollar_dollar := msg - var _t1721 *pb.UInt128Type + var _t1731 *pb.UInt128Type if hasProtoField(_dollar_dollar, "uint128_type") { - _t1721 = _dollar_dollar.GetUint128Type() + _t1731 = _dollar_dollar.GetUint128Type() } - deconstruct_result1008 := _t1721 - if deconstruct_result1008 != nil { - unwrapped1009 := deconstruct_result1008 - p.pretty_uint128_type(unwrapped1009) + deconstruct_result1013 := _t1731 + if deconstruct_result1013 != nil { + unwrapped1014 := deconstruct_result1013 + p.pretty_uint128_type(unwrapped1014) } else { _dollar_dollar := msg - var _t1722 *pb.Int128Type + var _t1732 *pb.Int128Type if hasProtoField(_dollar_dollar, "int128_type") { - _t1722 = _dollar_dollar.GetInt128Type() + _t1732 = _dollar_dollar.GetInt128Type() } - deconstruct_result1006 := _t1722 - if deconstruct_result1006 != nil { - unwrapped1007 := deconstruct_result1006 - p.pretty_int128_type(unwrapped1007) + deconstruct_result1011 := _t1732 + if deconstruct_result1011 != nil { + unwrapped1012 := deconstruct_result1011 + p.pretty_int128_type(unwrapped1012) } else { _dollar_dollar := msg - var _t1723 *pb.DateType + var _t1733 *pb.DateType if hasProtoField(_dollar_dollar, "date_type") { - _t1723 = _dollar_dollar.GetDateType() + _t1733 = _dollar_dollar.GetDateType() } - deconstruct_result1004 := _t1723 - if deconstruct_result1004 != nil { - unwrapped1005 := deconstruct_result1004 - p.pretty_date_type(unwrapped1005) + deconstruct_result1009 := _t1733 + if deconstruct_result1009 != nil { + unwrapped1010 := deconstruct_result1009 + p.pretty_date_type(unwrapped1010) } else { _dollar_dollar := msg - var _t1724 *pb.DateTimeType + var _t1734 *pb.DateTimeType if hasProtoField(_dollar_dollar, "datetime_type") { - _t1724 = _dollar_dollar.GetDatetimeType() + _t1734 = _dollar_dollar.GetDatetimeType() } - deconstruct_result1002 := _t1724 - if deconstruct_result1002 != nil { - unwrapped1003 := deconstruct_result1002 - p.pretty_datetime_type(unwrapped1003) + deconstruct_result1007 := _t1734 + if deconstruct_result1007 != nil { + unwrapped1008 := deconstruct_result1007 + p.pretty_datetime_type(unwrapped1008) } else { _dollar_dollar := msg - var _t1725 *pb.MissingType + var _t1735 *pb.MissingType if hasProtoField(_dollar_dollar, "missing_type") { - _t1725 = _dollar_dollar.GetMissingType() + _t1735 = _dollar_dollar.GetMissingType() } - deconstruct_result1000 := _t1725 - if deconstruct_result1000 != nil { - unwrapped1001 := deconstruct_result1000 - p.pretty_missing_type(unwrapped1001) + deconstruct_result1005 := _t1735 + if deconstruct_result1005 != nil { + unwrapped1006 := deconstruct_result1005 + p.pretty_missing_type(unwrapped1006) } else { _dollar_dollar := msg - var _t1726 *pb.DecimalType + var _t1736 *pb.DecimalType if hasProtoField(_dollar_dollar, "decimal_type") { - _t1726 = _dollar_dollar.GetDecimalType() + _t1736 = _dollar_dollar.GetDecimalType() } - deconstruct_result998 := _t1726 - if deconstruct_result998 != nil { - unwrapped999 := deconstruct_result998 - p.pretty_decimal_type(unwrapped999) + deconstruct_result1003 := _t1736 + if deconstruct_result1003 != nil { + unwrapped1004 := deconstruct_result1003 + p.pretty_decimal_type(unwrapped1004) } else { _dollar_dollar := msg - var _t1727 *pb.BooleanType + var _t1737 *pb.BooleanType if hasProtoField(_dollar_dollar, "boolean_type") { - _t1727 = _dollar_dollar.GetBooleanType() + _t1737 = _dollar_dollar.GetBooleanType() } - deconstruct_result996 := _t1727 - if deconstruct_result996 != nil { - unwrapped997 := deconstruct_result996 - p.pretty_boolean_type(unwrapped997) + deconstruct_result1001 := _t1737 + if deconstruct_result1001 != nil { + unwrapped1002 := deconstruct_result1001 + p.pretty_boolean_type(unwrapped1002) } else { _dollar_dollar := msg - var _t1728 *pb.Int32Type + var _t1738 *pb.Int32Type if hasProtoField(_dollar_dollar, "int32_type") { - _t1728 = _dollar_dollar.GetInt32Type() + _t1738 = _dollar_dollar.GetInt32Type() } - deconstruct_result994 := _t1728 - if deconstruct_result994 != nil { - unwrapped995 := deconstruct_result994 - p.pretty_int32_type(unwrapped995) + deconstruct_result999 := _t1738 + if deconstruct_result999 != nil { + unwrapped1000 := deconstruct_result999 + p.pretty_int32_type(unwrapped1000) } else { _dollar_dollar := msg - var _t1729 *pb.Float32Type + var _t1739 *pb.Float32Type if hasProtoField(_dollar_dollar, "float32_type") { - _t1729 = _dollar_dollar.GetFloat32Type() + _t1739 = _dollar_dollar.GetFloat32Type() } - deconstruct_result992 := _t1729 - if deconstruct_result992 != nil { - unwrapped993 := deconstruct_result992 - p.pretty_float32_type(unwrapped993) + deconstruct_result997 := _t1739 + if deconstruct_result997 != nil { + unwrapped998 := deconstruct_result997 + p.pretty_float32_type(unwrapped998) } else { _dollar_dollar := msg - var _t1730 *pb.UInt32Type + var _t1740 *pb.UInt32Type if hasProtoField(_dollar_dollar, "uint32_type") { - _t1730 = _dollar_dollar.GetUint32Type() + _t1740 = _dollar_dollar.GetUint32Type() } - deconstruct_result990 := _t1730 - if deconstruct_result990 != nil { - unwrapped991 := deconstruct_result990 - p.pretty_uint32_type(unwrapped991) ->>>>>>> origin/main + deconstruct_result995 := _t1740 + if deconstruct_result995 != nil { + unwrapped996 := deconstruct_result995 + p.pretty_uint32_type(unwrapped996) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -2594,150 +1573,86 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { -<<<<<<< HEAD - fields981 := msg - _ = fields981 -======= - fields1019 := msg - _ = fields1019 ->>>>>>> origin/main + fields1024 := msg + _ = fields1024 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { -<<<<<<< HEAD - fields982 := msg - _ = fields982 -======= - fields1020 := msg - _ = fields1020 ->>>>>>> origin/main + fields1025 := msg + _ = fields1025 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { -<<<<<<< HEAD - fields983 := msg - _ = fields983 -======= - fields1021 := msg - _ = fields1021 ->>>>>>> origin/main + fields1026 := msg + _ = fields1026 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { -<<<<<<< HEAD - fields984 := msg - _ = fields984 -======= - fields1022 := msg - _ = fields1022 ->>>>>>> origin/main + fields1027 := msg + _ = fields1027 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { -<<<<<<< HEAD - fields985 := msg - _ = fields985 -======= - fields1023 := msg - _ = fields1023 ->>>>>>> origin/main + fields1028 := msg + _ = fields1028 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { -<<<<<<< HEAD - fields986 := msg - _ = fields986 -======= - fields1024 := msg - _ = fields1024 ->>>>>>> origin/main + fields1029 := msg + _ = fields1029 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { -<<<<<<< HEAD - fields987 := msg - _ = fields987 -======= - fields1025 := msg - _ = fields1025 ->>>>>>> origin/main + fields1030 := msg + _ = fields1030 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { -<<<<<<< HEAD - fields988 := msg - _ = fields988 -======= - fields1026 := msg - _ = fields1026 ->>>>>>> origin/main + fields1031 := msg + _ = fields1031 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { -<<<<<<< HEAD - fields989 := msg - _ = fields989 -======= - fields1027 := msg - _ = fields1027 ->>>>>>> origin/main + fields1032 := msg + _ = fields1032 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { -<<<<<<< HEAD - flat994 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat994 != nil { - p.write(*flat994) - return nil - } else { - _dollar_dollar := msg - fields990 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} - unwrapped_fields991 := fields990 -======= - flat1032 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) - if flat1032 != nil { - p.write(*flat1032) + flat1037 := p.tryFlat(msg, func() { p.pretty_decimal_type(msg) }) + if flat1037 != nil { + p.write(*flat1037) return nil } else { _dollar_dollar := msg - fields1028 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} - unwrapped_fields1029 := fields1028 ->>>>>>> origin/main + fields1033 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} + unwrapped_fields1034 := fields1033 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() -<<<<<<< HEAD - field992 := unwrapped_fields991[0].(int64) - p.write(fmt.Sprintf("%d", field992)) - p.newline() - field993 := unwrapped_fields991[1].(int64) - p.write(fmt.Sprintf("%d", field993)) -======= - field1030 := unwrapped_fields1029[0].(int64) - p.write(fmt.Sprintf("%d", field1030)) + field1035 := unwrapped_fields1034[0].(int64) + p.write(fmt.Sprintf("%d", field1035)) p.newline() - field1031 := unwrapped_fields1029[1].(int64) - p.write(fmt.Sprintf("%d", field1031)) ->>>>>>> origin/main + field1036 := unwrapped_fields1034[1].(int64) + p.write(fmt.Sprintf("%d", field1036)) p.dedent() p.write(")") } @@ -2745,85 +1660,48 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { -<<<<<<< HEAD - fields995 := msg - _ = fields995 -======= - fields1033 := msg - _ = fields1033 ->>>>>>> origin/main + fields1038 := msg + _ = fields1038 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_int32_type(msg *pb.Int32Type) interface{} { -<<<<<<< HEAD - fields996 := msg - _ = fields996 -======= - fields1034 := msg - _ = fields1034 ->>>>>>> origin/main + fields1039 := msg + _ = fields1039 p.write("INT32") return nil } func (p *PrettyPrinter) pretty_float32_type(msg *pb.Float32Type) interface{} { -<<<<<<< HEAD - fields997 := msg - _ = fields997 -======= - fields1035 := msg - _ = fields1035 ->>>>>>> origin/main + fields1040 := msg + _ = fields1040 p.write("FLOAT32") return nil } func (p *PrettyPrinter) pretty_uint32_type(msg *pb.UInt32Type) interface{} { -<<<<<<< HEAD - fields998 := msg - _ = fields998 -======= - fields1036 := msg - _ = fields1036 ->>>>>>> origin/main + fields1041 := msg + _ = fields1041 p.write("UINT32") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { -<<<<<<< HEAD - flat1002 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat1002 != nil { - p.write(*flat1002) - return nil - } else { - fields999 := msg - p.write("|") - if !(len(fields999) == 0) { - p.write(" ") - for i1001, elem1000 := range fields999 { - if (i1001 > 0) { - p.newline() - } - p.pretty_binding(elem1000) -======= - flat1040 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) - if flat1040 != nil { - p.write(*flat1040) + flat1045 := p.tryFlat(msg, func() { p.pretty_value_bindings(msg) }) + if flat1045 != nil { + p.write(*flat1045) return nil } else { - fields1037 := msg + fields1042 := msg p.write("|") - if !(len(fields1037) == 0) { + if !(len(fields1042) == 0) { p.write(" ") - for i1039, elem1038 := range fields1037 { - if (i1039 > 0) { + for i1044, elem1043 := range fields1042 { + if (i1044 > 0) { p.newline() } - p.pretty_binding(elem1038) ->>>>>>> origin/main + p.pretty_binding(elem1043) } } } @@ -2831,277 +1709,140 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { -<<<<<<< HEAD - flat1029 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat1029 != nil { - p.write(*flat1029) - return nil - } else { - _dollar_dollar := msg - var _t1655 *pb.Conjunction - if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1655 = _dollar_dollar.GetConjunction() - } - deconstruct_result1027 := _t1655 - if deconstruct_result1027 != nil { - unwrapped1028 := deconstruct_result1027 - p.pretty_true(unwrapped1028) - } else { - _dollar_dollar := msg - var _t1656 *pb.Disjunction - if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1656 = _dollar_dollar.GetDisjunction() - } - deconstruct_result1025 := _t1656 - if deconstruct_result1025 != nil { - unwrapped1026 := deconstruct_result1025 - p.pretty_false(unwrapped1026) - } else { - _dollar_dollar := msg - var _t1657 *pb.Exists - if hasProtoField(_dollar_dollar, "exists") { - _t1657 = _dollar_dollar.GetExists() - } - deconstruct_result1023 := _t1657 - if deconstruct_result1023 != nil { - unwrapped1024 := deconstruct_result1023 - p.pretty_exists(unwrapped1024) - } else { - _dollar_dollar := msg - var _t1658 *pb.Reduce - if hasProtoField(_dollar_dollar, "reduce") { - _t1658 = _dollar_dollar.GetReduce() - } - deconstruct_result1021 := _t1658 - if deconstruct_result1021 != nil { - unwrapped1022 := deconstruct_result1021 - p.pretty_reduce(unwrapped1022) - } else { - _dollar_dollar := msg - var _t1659 *pb.Conjunction - if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1659 = _dollar_dollar.GetConjunction() - } - deconstruct_result1019 := _t1659 - if deconstruct_result1019 != nil { - unwrapped1020 := deconstruct_result1019 - p.pretty_conjunction(unwrapped1020) - } else { - _dollar_dollar := msg - var _t1660 *pb.Disjunction - if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1660 = _dollar_dollar.GetDisjunction() - } - deconstruct_result1017 := _t1660 - if deconstruct_result1017 != nil { - unwrapped1018 := deconstruct_result1017 - p.pretty_disjunction(unwrapped1018) - } else { - _dollar_dollar := msg - var _t1661 *pb.Not - if hasProtoField(_dollar_dollar, "not") { - _t1661 = _dollar_dollar.GetNot() - } - deconstruct_result1015 := _t1661 - if deconstruct_result1015 != nil { - unwrapped1016 := deconstruct_result1015 - p.pretty_not(unwrapped1016) - } else { - _dollar_dollar := msg - var _t1662 *pb.FFI - if hasProtoField(_dollar_dollar, "ffi") { - _t1662 = _dollar_dollar.GetFfi() - } - deconstruct_result1013 := _t1662 - if deconstruct_result1013 != nil { - unwrapped1014 := deconstruct_result1013 - p.pretty_ffi(unwrapped1014) - } else { - _dollar_dollar := msg - var _t1663 *pb.Atom - if hasProtoField(_dollar_dollar, "atom") { - _t1663 = _dollar_dollar.GetAtom() - } - deconstruct_result1011 := _t1663 - if deconstruct_result1011 != nil { - unwrapped1012 := deconstruct_result1011 - p.pretty_atom(unwrapped1012) - } else { - _dollar_dollar := msg - var _t1664 *pb.Pragma - if hasProtoField(_dollar_dollar, "pragma") { - _t1664 = _dollar_dollar.GetPragma() - } - deconstruct_result1009 := _t1664 - if deconstruct_result1009 != nil { - unwrapped1010 := deconstruct_result1009 - p.pretty_pragma(unwrapped1010) - } else { - _dollar_dollar := msg - var _t1665 *pb.Primitive - if hasProtoField(_dollar_dollar, "primitive") { - _t1665 = _dollar_dollar.GetPrimitive() - } - deconstruct_result1007 := _t1665 - if deconstruct_result1007 != nil { - unwrapped1008 := deconstruct_result1007 - p.pretty_primitive(unwrapped1008) - } else { - _dollar_dollar := msg - var _t1666 *pb.RelAtom - if hasProtoField(_dollar_dollar, "rel_atom") { - _t1666 = _dollar_dollar.GetRelAtom() - } - deconstruct_result1005 := _t1666 - if deconstruct_result1005 != nil { - unwrapped1006 := deconstruct_result1005 - p.pretty_rel_atom(unwrapped1006) - } else { - _dollar_dollar := msg - var _t1667 *pb.Cast - if hasProtoField(_dollar_dollar, "cast") { - _t1667 = _dollar_dollar.GetCast() - } - deconstruct_result1003 := _t1667 - if deconstruct_result1003 != nil { - unwrapped1004 := deconstruct_result1003 - p.pretty_cast(unwrapped1004) -======= - flat1067 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) - if flat1067 != nil { - p.write(*flat1067) + flat1072 := p.tryFlat(msg, func() { p.pretty_formula(msg) }) + if flat1072 != nil { + p.write(*flat1072) return nil } else { _dollar_dollar := msg - var _t1731 *pb.Conjunction + var _t1741 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && len(_dollar_dollar.GetConjunction().GetArgs()) == 0) { - _t1731 = _dollar_dollar.GetConjunction() + _t1741 = _dollar_dollar.GetConjunction() } - deconstruct_result1065 := _t1731 - if deconstruct_result1065 != nil { - unwrapped1066 := deconstruct_result1065 - p.pretty_true(unwrapped1066) + deconstruct_result1070 := _t1741 + if deconstruct_result1070 != nil { + unwrapped1071 := deconstruct_result1070 + p.pretty_true(unwrapped1071) } else { _dollar_dollar := msg - var _t1732 *pb.Disjunction + var _t1742 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && len(_dollar_dollar.GetDisjunction().GetArgs()) == 0) { - _t1732 = _dollar_dollar.GetDisjunction() + _t1742 = _dollar_dollar.GetDisjunction() } - deconstruct_result1063 := _t1732 - if deconstruct_result1063 != nil { - unwrapped1064 := deconstruct_result1063 - p.pretty_false(unwrapped1064) + deconstruct_result1068 := _t1742 + if deconstruct_result1068 != nil { + unwrapped1069 := deconstruct_result1068 + p.pretty_false(unwrapped1069) } else { _dollar_dollar := msg - var _t1733 *pb.Exists + var _t1743 *pb.Exists if hasProtoField(_dollar_dollar, "exists") { - _t1733 = _dollar_dollar.GetExists() + _t1743 = _dollar_dollar.GetExists() } - deconstruct_result1061 := _t1733 - if deconstruct_result1061 != nil { - unwrapped1062 := deconstruct_result1061 - p.pretty_exists(unwrapped1062) + deconstruct_result1066 := _t1743 + if deconstruct_result1066 != nil { + unwrapped1067 := deconstruct_result1066 + p.pretty_exists(unwrapped1067) } else { _dollar_dollar := msg - var _t1734 *pb.Reduce + var _t1744 *pb.Reduce if hasProtoField(_dollar_dollar, "reduce") { - _t1734 = _dollar_dollar.GetReduce() + _t1744 = _dollar_dollar.GetReduce() } - deconstruct_result1059 := _t1734 - if deconstruct_result1059 != nil { - unwrapped1060 := deconstruct_result1059 - p.pretty_reduce(unwrapped1060) + deconstruct_result1064 := _t1744 + if deconstruct_result1064 != nil { + unwrapped1065 := deconstruct_result1064 + p.pretty_reduce(unwrapped1065) } else { _dollar_dollar := msg - var _t1735 *pb.Conjunction + var _t1745 *pb.Conjunction if (hasProtoField(_dollar_dollar, "conjunction") && !(len(_dollar_dollar.GetConjunction().GetArgs()) == 0)) { - _t1735 = _dollar_dollar.GetConjunction() + _t1745 = _dollar_dollar.GetConjunction() } - deconstruct_result1057 := _t1735 - if deconstruct_result1057 != nil { - unwrapped1058 := deconstruct_result1057 - p.pretty_conjunction(unwrapped1058) + deconstruct_result1062 := _t1745 + if deconstruct_result1062 != nil { + unwrapped1063 := deconstruct_result1062 + p.pretty_conjunction(unwrapped1063) } else { _dollar_dollar := msg - var _t1736 *pb.Disjunction + var _t1746 *pb.Disjunction if (hasProtoField(_dollar_dollar, "disjunction") && !(len(_dollar_dollar.GetDisjunction().GetArgs()) == 0)) { - _t1736 = _dollar_dollar.GetDisjunction() + _t1746 = _dollar_dollar.GetDisjunction() } - deconstruct_result1055 := _t1736 - if deconstruct_result1055 != nil { - unwrapped1056 := deconstruct_result1055 - p.pretty_disjunction(unwrapped1056) + deconstruct_result1060 := _t1746 + if deconstruct_result1060 != nil { + unwrapped1061 := deconstruct_result1060 + p.pretty_disjunction(unwrapped1061) } else { _dollar_dollar := msg - var _t1737 *pb.Not + var _t1747 *pb.Not if hasProtoField(_dollar_dollar, "not") { - _t1737 = _dollar_dollar.GetNot() + _t1747 = _dollar_dollar.GetNot() } - deconstruct_result1053 := _t1737 - if deconstruct_result1053 != nil { - unwrapped1054 := deconstruct_result1053 - p.pretty_not(unwrapped1054) + deconstruct_result1058 := _t1747 + if deconstruct_result1058 != nil { + unwrapped1059 := deconstruct_result1058 + p.pretty_not(unwrapped1059) } else { _dollar_dollar := msg - var _t1738 *pb.FFI + var _t1748 *pb.FFI if hasProtoField(_dollar_dollar, "ffi") { - _t1738 = _dollar_dollar.GetFfi() + _t1748 = _dollar_dollar.GetFfi() } - deconstruct_result1051 := _t1738 - if deconstruct_result1051 != nil { - unwrapped1052 := deconstruct_result1051 - p.pretty_ffi(unwrapped1052) + deconstruct_result1056 := _t1748 + if deconstruct_result1056 != nil { + unwrapped1057 := deconstruct_result1056 + p.pretty_ffi(unwrapped1057) } else { _dollar_dollar := msg - var _t1739 *pb.Atom + var _t1749 *pb.Atom if hasProtoField(_dollar_dollar, "atom") { - _t1739 = _dollar_dollar.GetAtom() + _t1749 = _dollar_dollar.GetAtom() } - deconstruct_result1049 := _t1739 - if deconstruct_result1049 != nil { - unwrapped1050 := deconstruct_result1049 - p.pretty_atom(unwrapped1050) + deconstruct_result1054 := _t1749 + if deconstruct_result1054 != nil { + unwrapped1055 := deconstruct_result1054 + p.pretty_atom(unwrapped1055) } else { _dollar_dollar := msg - var _t1740 *pb.Pragma + var _t1750 *pb.Pragma if hasProtoField(_dollar_dollar, "pragma") { - _t1740 = _dollar_dollar.GetPragma() + _t1750 = _dollar_dollar.GetPragma() } - deconstruct_result1047 := _t1740 - if deconstruct_result1047 != nil { - unwrapped1048 := deconstruct_result1047 - p.pretty_pragma(unwrapped1048) + deconstruct_result1052 := _t1750 + if deconstruct_result1052 != nil { + unwrapped1053 := deconstruct_result1052 + p.pretty_pragma(unwrapped1053) } else { _dollar_dollar := msg - var _t1741 *pb.Primitive + var _t1751 *pb.Primitive if hasProtoField(_dollar_dollar, "primitive") { - _t1741 = _dollar_dollar.GetPrimitive() + _t1751 = _dollar_dollar.GetPrimitive() } - deconstruct_result1045 := _t1741 - if deconstruct_result1045 != nil { - unwrapped1046 := deconstruct_result1045 - p.pretty_primitive(unwrapped1046) + deconstruct_result1050 := _t1751 + if deconstruct_result1050 != nil { + unwrapped1051 := deconstruct_result1050 + p.pretty_primitive(unwrapped1051) } else { _dollar_dollar := msg - var _t1742 *pb.RelAtom + var _t1752 *pb.RelAtom if hasProtoField(_dollar_dollar, "rel_atom") { - _t1742 = _dollar_dollar.GetRelAtom() + _t1752 = _dollar_dollar.GetRelAtom() } - deconstruct_result1043 := _t1742 - if deconstruct_result1043 != nil { - unwrapped1044 := deconstruct_result1043 - p.pretty_rel_atom(unwrapped1044) + deconstruct_result1048 := _t1752 + if deconstruct_result1048 != nil { + unwrapped1049 := deconstruct_result1048 + p.pretty_rel_atom(unwrapped1049) } else { _dollar_dollar := msg - var _t1743 *pb.Cast + var _t1753 *pb.Cast if hasProtoField(_dollar_dollar, "cast") { - _t1743 = _dollar_dollar.GetCast() + _t1753 = _dollar_dollar.GetCast() } - deconstruct_result1041 := _t1743 - if deconstruct_result1041 != nil { - unwrapped1042 := deconstruct_result1041 - p.pretty_cast(unwrapped1042) ->>>>>>> origin/main + deconstruct_result1046 := _t1753 + if deconstruct_result1046 != nil { + unwrapped1047 := deconstruct_result1046 + p.pretty_cast(unwrapped1047) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -3122,13 +1863,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { -<<<<<<< HEAD - fields1030 := msg - _ = fields1030 -======= - fields1068 := msg - _ = fields1068 ->>>>>>> origin/main + fields1073 := msg + _ = fields1073 p.write("(") p.write("true") p.write(")") @@ -3136,13 +1872,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { -<<<<<<< HEAD - fields1031 := msg - _ = fields1031 -======= - fields1069 := msg - _ = fields1069 ->>>>>>> origin/main + fields1074 := msg + _ = fields1074 p.write("(") p.write("false") p.write(")") @@ -3150,44 +1881,24 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { -<<<<<<< HEAD - flat1036 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat1036 != nil { - p.write(*flat1036) - return nil - } else { - _dollar_dollar := msg - _t1668 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - fields1032 := []interface{}{_t1668, _dollar_dollar.GetBody().GetValue()} - unwrapped_fields1033 := fields1032 -======= - flat1074 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) - if flat1074 != nil { - p.write(*flat1074) + flat1079 := p.tryFlat(msg, func() { p.pretty_exists(msg) }) + if flat1079 != nil { + p.write(*flat1079) return nil } else { _dollar_dollar := msg - _t1744 := p.deconstruct_bindings(_dollar_dollar.GetBody()) - fields1070 := []interface{}{_t1744, _dollar_dollar.GetBody().GetValue()} - unwrapped_fields1071 := fields1070 ->>>>>>> origin/main + _t1754 := p.deconstruct_bindings(_dollar_dollar.GetBody()) + fields1075 := []interface{}{_t1754, _dollar_dollar.GetBody().GetValue()} + unwrapped_fields1076 := fields1075 p.write("(") p.write("exists") p.indentSexp() p.newline() -<<<<<<< HEAD - field1034 := unwrapped_fields1033[0].([]interface{}) - p.pretty_bindings(field1034) - p.newline() - field1035 := unwrapped_fields1033[1].(*pb.Formula) - p.pretty_formula(field1035) -======= - field1072 := unwrapped_fields1071[0].([]interface{}) - p.pretty_bindings(field1072) + field1077 := unwrapped_fields1076[0].([]interface{}) + p.pretty_bindings(field1077) p.newline() - field1073 := unwrapped_fields1071[1].(*pb.Formula) - p.pretty_formula(field1073) ->>>>>>> origin/main + field1078 := unwrapped_fields1076[1].(*pb.Formula) + p.pretty_formula(field1078) p.dedent() p.write(")") } @@ -3195,48 +1906,26 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { -<<<<<<< HEAD - flat1042 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat1042 != nil { - p.write(*flat1042) + flat1085 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat1085 != nil { + p.write(*flat1085) return nil } else { _dollar_dollar := msg - fields1037 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} - unwrapped_fields1038 := fields1037 -======= - flat1080 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat1080 != nil { - p.write(*flat1080) - return nil - } else { - _dollar_dollar := msg - fields1075 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} - unwrapped_fields1076 := fields1075 ->>>>>>> origin/main + fields1080 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} + unwrapped_fields1081 := fields1080 p.write("(") p.write("reduce") p.indentSexp() p.newline() -<<<<<<< HEAD - field1039 := unwrapped_fields1038[0].(*pb.Abstraction) - p.pretty_abstraction(field1039) - p.newline() - field1040 := unwrapped_fields1038[1].(*pb.Abstraction) - p.pretty_abstraction(field1040) - p.newline() - field1041 := unwrapped_fields1038[2].([]*pb.Term) - p.pretty_terms(field1041) -======= - field1077 := unwrapped_fields1076[0].(*pb.Abstraction) - p.pretty_abstraction(field1077) + field1082 := unwrapped_fields1081[0].(*pb.Abstraction) + p.pretty_abstraction(field1082) p.newline() - field1078 := unwrapped_fields1076[1].(*pb.Abstraction) - p.pretty_abstraction(field1078) + field1083 := unwrapped_fields1081[1].(*pb.Abstraction) + p.pretty_abstraction(field1083) p.newline() - field1079 := unwrapped_fields1076[2].([]*pb.Term) - p.pretty_terms(field1079) ->>>>>>> origin/main + field1084 := unwrapped_fields1081[2].([]*pb.Term) + p.pretty_terms(field1084) p.dedent() p.write(")") } @@ -3244,41 +1933,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { -<<<<<<< HEAD - flat1046 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat1046 != nil { - p.write(*flat1046) - return nil - } else { - fields1043 := msg - p.write("(") - p.write("terms") - p.indentSexp() - if !(len(fields1043) == 0) { - p.newline() - for i1045, elem1044 := range fields1043 { - if (i1045 > 0) { - p.newline() - } - p.pretty_term(elem1044) -======= - flat1084 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) - if flat1084 != nil { - p.write(*flat1084) + flat1089 := p.tryFlat(msg, func() { p.pretty_terms(msg) }) + if flat1089 != nil { + p.write(*flat1089) return nil } else { - fields1081 := msg + fields1086 := msg p.write("(") p.write("terms") p.indentSexp() - if !(len(fields1081) == 0) { + if !(len(fields1086) == 0) { p.newline() - for i1083, elem1082 := range fields1081 { - if (i1083 > 0) { + for i1088, elem1087 := range fields1086 { + if (i1088 > 0) { p.newline() } - p.pretty_term(elem1082) ->>>>>>> origin/main + p.pretty_term(elem1087) } } p.dedent() @@ -3288,57 +1958,30 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { -<<<<<<< HEAD - flat1051 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat1051 != nil { - p.write(*flat1051) + flat1094 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat1094 != nil { + p.write(*flat1094) return nil } else { _dollar_dollar := msg - var _t1669 *pb.Var + var _t1755 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1669 = _dollar_dollar.GetVar() + _t1755 = _dollar_dollar.GetVar() } - deconstruct_result1049 := _t1669 - if deconstruct_result1049 != nil { - unwrapped1050 := deconstruct_result1049 - p.pretty_var(unwrapped1050) + deconstruct_result1092 := _t1755 + if deconstruct_result1092 != nil { + unwrapped1093 := deconstruct_result1092 + p.pretty_var(unwrapped1093) } else { _dollar_dollar := msg - var _t1670 *pb.Value + var _t1756 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1670 = _dollar_dollar.GetConstant() + _t1756 = _dollar_dollar.GetConstant() } - deconstruct_result1047 := _t1670 - if deconstruct_result1047 != nil { - unwrapped1048 := deconstruct_result1047 - p.pretty_value(unwrapped1048) -======= - flat1089 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat1089 != nil { - p.write(*flat1089) - return nil - } else { - _dollar_dollar := msg - var _t1745 *pb.Var - if hasProtoField(_dollar_dollar, "var") { - _t1745 = _dollar_dollar.GetVar() - } - deconstruct_result1087 := _t1745 - if deconstruct_result1087 != nil { - unwrapped1088 := deconstruct_result1087 - p.pretty_var(unwrapped1088) - } else { - _dollar_dollar := msg - var _t1746 *pb.Value - if hasProtoField(_dollar_dollar, "constant") { - _t1746 = _dollar_dollar.GetConstant() - } - deconstruct_result1085 := _t1746 - if deconstruct_result1085 != nil { - unwrapped1086 := deconstruct_result1085 - p.pretty_value(unwrapped1086) ->>>>>>> origin/main + deconstruct_result1090 := _t1756 + if deconstruct_result1090 != nil { + unwrapped1091 := deconstruct_result1090 + p.pretty_value(unwrapped1091) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -3348,289 +1991,147 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { -<<<<<<< HEAD - flat1054 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat1054 != nil { - p.write(*flat1054) - return nil - } else { - _dollar_dollar := msg - fields1052 := _dollar_dollar.GetName() - unwrapped_fields1053 := fields1052 - p.write(unwrapped_fields1053) -======= - flat1092 := p.tryFlat(msg, func() { p.pretty_var(msg) }) - if flat1092 != nil { - p.write(*flat1092) + flat1097 := p.tryFlat(msg, func() { p.pretty_var(msg) }) + if flat1097 != nil { + p.write(*flat1097) return nil } else { _dollar_dollar := msg - fields1090 := _dollar_dollar.GetName() - unwrapped_fields1091 := fields1090 - p.write(unwrapped_fields1091) ->>>>>>> origin/main + fields1095 := _dollar_dollar.GetName() + unwrapped_fields1096 := fields1095 + p.write(unwrapped_fields1096) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { -<<<<<<< HEAD - flat1080 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat1080 != nil { - p.write(*flat1080) + flat1123 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat1123 != nil { + p.write(*flat1123) return nil } else { _dollar_dollar := msg - var _t1671 *pb.DateValue + var _t1757 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1671 = _dollar_dollar.GetDateValue() + _t1757 = _dollar_dollar.GetDateValue() } - deconstruct_result1078 := _t1671 - if deconstruct_result1078 != nil { - unwrapped1079 := deconstruct_result1078 - p.pretty_date(unwrapped1079) + deconstruct_result1121 := _t1757 + if deconstruct_result1121 != nil { + unwrapped1122 := deconstruct_result1121 + p.pretty_date(unwrapped1122) } else { _dollar_dollar := msg - var _t1672 *pb.DateTimeValue + var _t1758 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1672 = _dollar_dollar.GetDatetimeValue() + _t1758 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result1076 := _t1672 - if deconstruct_result1076 != nil { - unwrapped1077 := deconstruct_result1076 - p.pretty_datetime(unwrapped1077) + deconstruct_result1119 := _t1758 + if deconstruct_result1119 != nil { + unwrapped1120 := deconstruct_result1119 + p.pretty_datetime(unwrapped1120) } else { _dollar_dollar := msg - var _t1673 *string + var _t1759 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1673 = ptr(_dollar_dollar.GetStringValue()) + _t1759 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result1074 := _t1673 - if deconstruct_result1074 != nil { - unwrapped1075 := *deconstruct_result1074 - p.write(p.formatStringValue(unwrapped1075)) + deconstruct_result1117 := _t1759 + if deconstruct_result1117 != nil { + unwrapped1118 := *deconstruct_result1117 + p.write(p.formatStringValue(unwrapped1118)) } else { _dollar_dollar := msg - var _t1674 *int32 + var _t1760 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1674 = ptr(_dollar_dollar.GetInt32Value()) + _t1760 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result1072 := _t1674 - if deconstruct_result1072 != nil { - unwrapped1073 := *deconstruct_result1072 - p.write(fmt.Sprintf("%di32", unwrapped1073)) + deconstruct_result1115 := _t1760 + if deconstruct_result1115 != nil { + unwrapped1116 := *deconstruct_result1115 + p.write(fmt.Sprintf("%di32", unwrapped1116)) } else { _dollar_dollar := msg - var _t1675 *int64 + var _t1761 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1675 = ptr(_dollar_dollar.GetIntValue()) + _t1761 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result1070 := _t1675 - if deconstruct_result1070 != nil { - unwrapped1071 := *deconstruct_result1070 - p.write(fmt.Sprintf("%d", unwrapped1071)) + deconstruct_result1113 := _t1761 + if deconstruct_result1113 != nil { + unwrapped1114 := *deconstruct_result1113 + p.write(fmt.Sprintf("%d", unwrapped1114)) } else { _dollar_dollar := msg - var _t1676 *float32 + var _t1762 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1676 = ptr(_dollar_dollar.GetFloat32Value()) + _t1762 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result1068 := _t1676 - if deconstruct_result1068 != nil { - unwrapped1069 := *deconstruct_result1068 - p.write(formatFloat32(unwrapped1069)) + deconstruct_result1111 := _t1762 + if deconstruct_result1111 != nil { + unwrapped1112 := *deconstruct_result1111 + p.write(formatFloat32(unwrapped1112)) } else { _dollar_dollar := msg - var _t1677 *float64 + var _t1763 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1677 = ptr(_dollar_dollar.GetFloatValue()) + _t1763 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result1066 := _t1677 - if deconstruct_result1066 != nil { - unwrapped1067 := *deconstruct_result1066 - p.write(formatFloat64(unwrapped1067)) + deconstruct_result1109 := _t1763 + if deconstruct_result1109 != nil { + unwrapped1110 := *deconstruct_result1109 + p.write(formatFloat64(unwrapped1110)) } else { _dollar_dollar := msg - var _t1678 *uint32 + var _t1764 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1678 = ptr(_dollar_dollar.GetUint32Value()) + _t1764 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result1064 := _t1678 - if deconstruct_result1064 != nil { - unwrapped1065 := *deconstruct_result1064 - p.write(fmt.Sprintf("%du32", unwrapped1065)) + deconstruct_result1107 := _t1764 + if deconstruct_result1107 != nil { + unwrapped1108 := *deconstruct_result1107 + p.write(fmt.Sprintf("%du32", unwrapped1108)) } else { _dollar_dollar := msg - var _t1679 *pb.UInt128Value + var _t1765 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1679 = _dollar_dollar.GetUint128Value() + _t1765 = _dollar_dollar.GetUint128Value() } - deconstruct_result1062 := _t1679 - if deconstruct_result1062 != nil { - unwrapped1063 := deconstruct_result1062 - p.write(p.formatUint128(unwrapped1063)) + deconstruct_result1105 := _t1765 + if deconstruct_result1105 != nil { + unwrapped1106 := deconstruct_result1105 + p.write(p.formatUint128(unwrapped1106)) } else { _dollar_dollar := msg - var _t1680 *pb.Int128Value + var _t1766 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1680 = _dollar_dollar.GetInt128Value() + _t1766 = _dollar_dollar.GetInt128Value() } - deconstruct_result1060 := _t1680 - if deconstruct_result1060 != nil { - unwrapped1061 := deconstruct_result1060 - p.write(p.formatInt128(unwrapped1061)) + deconstruct_result1103 := _t1766 + if deconstruct_result1103 != nil { + unwrapped1104 := deconstruct_result1103 + p.write(p.formatInt128(unwrapped1104)) } else { _dollar_dollar := msg - var _t1681 *pb.DecimalValue + var _t1767 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1681 = _dollar_dollar.GetDecimalValue() + _t1767 = _dollar_dollar.GetDecimalValue() } - deconstruct_result1058 := _t1681 - if deconstruct_result1058 != nil { - unwrapped1059 := deconstruct_result1058 - p.write(p.formatDecimal(unwrapped1059)) + deconstruct_result1101 := _t1767 + if deconstruct_result1101 != nil { + unwrapped1102 := deconstruct_result1101 + p.write(p.formatDecimal(unwrapped1102)) } else { _dollar_dollar := msg - var _t1682 *bool + var _t1768 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1682 = ptr(_dollar_dollar.GetBooleanValue()) + _t1768 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result1056 := _t1682 - if deconstruct_result1056 != nil { - unwrapped1057 := *deconstruct_result1056 - p.pretty_boolean_value(unwrapped1057) + deconstruct_result1099 := _t1768 + if deconstruct_result1099 != nil { + unwrapped1100 := *deconstruct_result1099 + p.pretty_boolean_value(unwrapped1100) } else { - fields1055 := msg - _ = fields1055 -======= - flat1118 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat1118 != nil { - p.write(*flat1118) - return nil - } else { - _dollar_dollar := msg - var _t1747 *pb.DateValue - if hasProtoField(_dollar_dollar, "date_value") { - _t1747 = _dollar_dollar.GetDateValue() - } - deconstruct_result1116 := _t1747 - if deconstruct_result1116 != nil { - unwrapped1117 := deconstruct_result1116 - p.pretty_date(unwrapped1117) - } else { - _dollar_dollar := msg - var _t1748 *pb.DateTimeValue - if hasProtoField(_dollar_dollar, "datetime_value") { - _t1748 = _dollar_dollar.GetDatetimeValue() - } - deconstruct_result1114 := _t1748 - if deconstruct_result1114 != nil { - unwrapped1115 := deconstruct_result1114 - p.pretty_datetime(unwrapped1115) - } else { - _dollar_dollar := msg - var _t1749 *string - if hasProtoField(_dollar_dollar, "string_value") { - _t1749 = ptr(_dollar_dollar.GetStringValue()) - } - deconstruct_result1112 := _t1749 - if deconstruct_result1112 != nil { - unwrapped1113 := *deconstruct_result1112 - p.write(p.formatStringValue(unwrapped1113)) - } else { - _dollar_dollar := msg - var _t1750 *int32 - if hasProtoField(_dollar_dollar, "int32_value") { - _t1750 = ptr(_dollar_dollar.GetInt32Value()) - } - deconstruct_result1110 := _t1750 - if deconstruct_result1110 != nil { - unwrapped1111 := *deconstruct_result1110 - p.write(fmt.Sprintf("%di32", unwrapped1111)) - } else { - _dollar_dollar := msg - var _t1751 *int64 - if hasProtoField(_dollar_dollar, "int_value") { - _t1751 = ptr(_dollar_dollar.GetIntValue()) - } - deconstruct_result1108 := _t1751 - if deconstruct_result1108 != nil { - unwrapped1109 := *deconstruct_result1108 - p.write(fmt.Sprintf("%d", unwrapped1109)) - } else { - _dollar_dollar := msg - var _t1752 *float32 - if hasProtoField(_dollar_dollar, "float32_value") { - _t1752 = ptr(_dollar_dollar.GetFloat32Value()) - } - deconstruct_result1106 := _t1752 - if deconstruct_result1106 != nil { - unwrapped1107 := *deconstruct_result1106 - p.write(formatFloat32(unwrapped1107)) - } else { - _dollar_dollar := msg - var _t1753 *float64 - if hasProtoField(_dollar_dollar, "float_value") { - _t1753 = ptr(_dollar_dollar.GetFloatValue()) - } - deconstruct_result1104 := _t1753 - if deconstruct_result1104 != nil { - unwrapped1105 := *deconstruct_result1104 - p.write(formatFloat64(unwrapped1105)) - } else { - _dollar_dollar := msg - var _t1754 *uint32 - if hasProtoField(_dollar_dollar, "uint32_value") { - _t1754 = ptr(_dollar_dollar.GetUint32Value()) - } - deconstruct_result1102 := _t1754 - if deconstruct_result1102 != nil { - unwrapped1103 := *deconstruct_result1102 - p.write(fmt.Sprintf("%du32", unwrapped1103)) - } else { - _dollar_dollar := msg - var _t1755 *pb.UInt128Value - if hasProtoField(_dollar_dollar, "uint128_value") { - _t1755 = _dollar_dollar.GetUint128Value() - } - deconstruct_result1100 := _t1755 - if deconstruct_result1100 != nil { - unwrapped1101 := deconstruct_result1100 - p.write(p.formatUint128(unwrapped1101)) - } else { - _dollar_dollar := msg - var _t1756 *pb.Int128Value - if hasProtoField(_dollar_dollar, "int128_value") { - _t1756 = _dollar_dollar.GetInt128Value() - } - deconstruct_result1098 := _t1756 - if deconstruct_result1098 != nil { - unwrapped1099 := deconstruct_result1098 - p.write(p.formatInt128(unwrapped1099)) - } else { - _dollar_dollar := msg - var _t1757 *pb.DecimalValue - if hasProtoField(_dollar_dollar, "decimal_value") { - _t1757 = _dollar_dollar.GetDecimalValue() - } - deconstruct_result1096 := _t1757 - if deconstruct_result1096 != nil { - unwrapped1097 := deconstruct_result1096 - p.write(p.formatDecimal(unwrapped1097)) - } else { - _dollar_dollar := msg - var _t1758 *bool - if hasProtoField(_dollar_dollar, "boolean_value") { - _t1758 = ptr(_dollar_dollar.GetBooleanValue()) - } - deconstruct_result1094 := _t1758 - if deconstruct_result1094 != nil { - unwrapped1095 := *deconstruct_result1094 - p.pretty_boolean_value(unwrapped1095) - } else { - fields1093 := msg - _ = fields1093 ->>>>>>> origin/main + fields1098 := msg + _ = fields1098 p.write("missing") } } @@ -3649,48 +2150,26 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { -<<<<<<< HEAD - flat1086 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat1086 != nil { - p.write(*flat1086) - return nil - } else { - _dollar_dollar := msg - fields1081 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields1082 := fields1081 -======= - flat1124 := p.tryFlat(msg, func() { p.pretty_date(msg) }) - if flat1124 != nil { - p.write(*flat1124) + flat1129 := p.tryFlat(msg, func() { p.pretty_date(msg) }) + if flat1129 != nil { + p.write(*flat1129) return nil } else { _dollar_dollar := msg - fields1119 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} - unwrapped_fields1120 := fields1119 ->>>>>>> origin/main + fields1124 := []interface{}{int64(_dollar_dollar.GetYear()), int64(_dollar_dollar.GetMonth()), int64(_dollar_dollar.GetDay())} + unwrapped_fields1125 := fields1124 p.write("(") p.write("date") p.indentSexp() p.newline() -<<<<<<< HEAD - field1083 := unwrapped_fields1082[0].(int64) - p.write(fmt.Sprintf("%d", field1083)) - p.newline() - field1084 := unwrapped_fields1082[1].(int64) - p.write(fmt.Sprintf("%d", field1084)) + field1126 := unwrapped_fields1125[0].(int64) + p.write(fmt.Sprintf("%d", field1126)) p.newline() - field1085 := unwrapped_fields1082[2].(int64) - p.write(fmt.Sprintf("%d", field1085)) -======= - field1121 := unwrapped_fields1120[0].(int64) - p.write(fmt.Sprintf("%d", field1121)) - p.newline() - field1122 := unwrapped_fields1120[1].(int64) - p.write(fmt.Sprintf("%d", field1122)) + field1127 := unwrapped_fields1125[1].(int64) + p.write(fmt.Sprintf("%d", field1127)) p.newline() - field1123 := unwrapped_fields1120[2].(int64) - p.write(fmt.Sprintf("%d", field1123)) ->>>>>>> origin/main + field1128 := unwrapped_fields1125[2].(int64) + p.write(fmt.Sprintf("%d", field1128)) p.dedent() p.write(")") } @@ -3698,76 +2177,40 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { -<<<<<<< HEAD - flat1097 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat1097 != nil { - p.write(*flat1097) - return nil - } else { - _dollar_dollar := msg - fields1087 := []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_fields1088 := fields1087 -======= - flat1135 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) - if flat1135 != nil { - p.write(*flat1135) + flat1140 := p.tryFlat(msg, func() { p.pretty_datetime(msg) }) + if flat1140 != nil { + p.write(*flat1140) return nil } else { _dollar_dollar := msg - fields1125 := []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_fields1126 := fields1125 ->>>>>>> origin/main + 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 p.write("(") p.write("datetime") p.indentSexp() p.newline() -<<<<<<< HEAD - field1089 := unwrapped_fields1088[0].(int64) - p.write(fmt.Sprintf("%d", field1089)) - p.newline() - field1090 := unwrapped_fields1088[1].(int64) - p.write(fmt.Sprintf("%d", field1090)) - p.newline() - field1091 := unwrapped_fields1088[2].(int64) - p.write(fmt.Sprintf("%d", field1091)) - p.newline() - field1092 := unwrapped_fields1088[3].(int64) - p.write(fmt.Sprintf("%d", field1092)) - p.newline() - field1093 := unwrapped_fields1088[4].(int64) - p.write(fmt.Sprintf("%d", field1093)) - p.newline() - field1094 := unwrapped_fields1088[5].(int64) - p.write(fmt.Sprintf("%d", field1094)) - field1095 := unwrapped_fields1088[6].(*int64) - if field1095 != nil { - p.newline() - opt_val1096 := *field1095 - p.write(fmt.Sprintf("%d", opt_val1096)) -======= - field1127 := unwrapped_fields1126[0].(int64) - p.write(fmt.Sprintf("%d", field1127)) + field1132 := unwrapped_fields1131[0].(int64) + p.write(fmt.Sprintf("%d", field1132)) p.newline() - field1128 := unwrapped_fields1126[1].(int64) - p.write(fmt.Sprintf("%d", field1128)) + field1133 := unwrapped_fields1131[1].(int64) + p.write(fmt.Sprintf("%d", field1133)) p.newline() - field1129 := unwrapped_fields1126[2].(int64) - p.write(fmt.Sprintf("%d", field1129)) + field1134 := unwrapped_fields1131[2].(int64) + p.write(fmt.Sprintf("%d", field1134)) p.newline() - field1130 := unwrapped_fields1126[3].(int64) - p.write(fmt.Sprintf("%d", field1130)) + field1135 := unwrapped_fields1131[3].(int64) + p.write(fmt.Sprintf("%d", field1135)) p.newline() - field1131 := unwrapped_fields1126[4].(int64) - p.write(fmt.Sprintf("%d", field1131)) + field1136 := unwrapped_fields1131[4].(int64) + p.write(fmt.Sprintf("%d", field1136)) p.newline() - field1132 := unwrapped_fields1126[5].(int64) - p.write(fmt.Sprintf("%d", field1132)) - field1133 := unwrapped_fields1126[6].(*int64) - if field1133 != nil { + field1137 := unwrapped_fields1131[5].(int64) + p.write(fmt.Sprintf("%d", field1137)) + field1138 := unwrapped_fields1131[6].(*int64) + if field1138 != nil { p.newline() - opt_val1134 := *field1133 - p.write(fmt.Sprintf("%d", opt_val1134)) ->>>>>>> origin/main + opt_val1139 := *field1138 + p.write(fmt.Sprintf("%d", opt_val1139)) } p.dedent() p.write(")") @@ -3776,42 +2219,9 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { -<<<<<<< HEAD - flat1102 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat1102 != nil { - p.write(*flat1102) -======= - flat1140 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat1140 != nil { - p.write(*flat1140) - return nil - } else { - _dollar_dollar := msg - fields1136 := _dollar_dollar.GetArgs() - unwrapped_fields1137 := fields1136 - p.write("(") - p.write("and") - p.indentSexp() - if !(len(unwrapped_fields1137) == 0) { - p.newline() - for i1139, elem1138 := range unwrapped_fields1137 { - if (i1139 > 0) { - p.newline() - } - p.pretty_formula(elem1138) - } - } - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat1145 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + flat1145 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) if flat1145 != nil { p.write(*flat1145) ->>>>>>> origin/main return nil } else { _dollar_dollar := msg @@ -3835,37 +2245,25 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { return nil } -<<<<<<< HEAD func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat1107 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat1107 != nil { - p.write(*flat1107) - return nil - } else { - _dollar_dollar := msg - fields1103 := _dollar_dollar.GetArgs() - unwrapped_fields1104 := fields1103 -======= -func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat1148 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat1148 != nil { - p.write(*flat1148) + flat1150 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat1150 != nil { + p.write(*flat1150) return nil } else { _dollar_dollar := msg - fields1146 := _dollar_dollar.GetArg() + fields1146 := _dollar_dollar.GetArgs() unwrapped_fields1147 := fields1146 ->>>>>>> origin/main p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields1104) == 0) { + if !(len(unwrapped_fields1147) == 0) { p.newline() - for i1106, elem1105 := range unwrapped_fields1104 { - if (i1106 > 0) { + for i1149, elem1148 := range unwrapped_fields1147 { + if (i1149 > 0) { p.newline() } - p.pretty_formula(elem1105) + p.pretty_formula(elem1148) } } p.dedent() @@ -3875,23 +2273,19 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat1110 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat1110 != nil { - p.write(*flat1110) + flat1153 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat1153 != nil { + p.write(*flat1153) return nil } else { _dollar_dollar := msg - fields1108 := _dollar_dollar.GetArg() - unwrapped_fields1109 := fields1108 + fields1151 := _dollar_dollar.GetArg() + unwrapped_fields1152 := fields1151 p.write("(") p.write("not") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_formula(unwrapped_fields1109) -======= - p.pretty_formula(unwrapped_fields1147) ->>>>>>> origin/main + p.pretty_formula(unwrapped_fields1152) p.dedent() p.write(")") } @@ -3899,48 +2293,26 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { -<<<<<<< HEAD - flat1116 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat1116 != nil { - p.write(*flat1116) + flat1159 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat1159 != nil { + p.write(*flat1159) return nil } else { _dollar_dollar := msg - fields1111 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} - unwrapped_fields1112 := fields1111 -======= - flat1154 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat1154 != nil { - p.write(*flat1154) - return nil - } else { - _dollar_dollar := msg - fields1149 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} - unwrapped_fields1150 := fields1149 ->>>>>>> origin/main + fields1154 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} + unwrapped_fields1155 := fields1154 p.write("(") p.write("ffi") p.indentSexp() p.newline() -<<<<<<< HEAD - field1113 := unwrapped_fields1112[0].(string) - p.pretty_name(field1113) - p.newline() - field1114 := unwrapped_fields1112[1].([]*pb.Abstraction) - p.pretty_ffi_args(field1114) + field1156 := unwrapped_fields1155[0].(string) + p.pretty_name(field1156) p.newline() - field1115 := unwrapped_fields1112[2].([]*pb.Term) - p.pretty_terms(field1115) -======= - field1151 := unwrapped_fields1150[0].(string) - p.pretty_name(field1151) + field1157 := unwrapped_fields1155[1].([]*pb.Abstraction) + p.pretty_ffi_args(field1157) p.newline() - field1152 := unwrapped_fields1150[1].([]*pb.Abstraction) - p.pretty_ffi_args(field1152) - p.newline() - field1153 := unwrapped_fields1150[2].([]*pb.Term) - p.pretty_terms(field1153) ->>>>>>> origin/main + field1158 := unwrapped_fields1155[2].([]*pb.Term) + p.pretty_terms(field1158) p.dedent() p.write(")") } @@ -3948,65 +2320,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { -<<<<<<< HEAD - flat1118 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat1118 != nil { - p.write(*flat1118) - return nil - } else { - fields1117 := msg - p.write(":") - p.write(fields1117) -======= - flat1156 := p.tryFlat(msg, func() { p.pretty_name(msg) }) - if flat1156 != nil { - p.write(*flat1156) + flat1161 := p.tryFlat(msg, func() { p.pretty_name(msg) }) + if flat1161 != nil { + p.write(*flat1161) return nil } else { - fields1155 := msg + fields1160 := msg p.write(":") - p.write(fields1155) ->>>>>>> origin/main + p.write(fields1160) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { -<<<<<<< HEAD - flat1122 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat1122 != nil { - p.write(*flat1122) - return nil - } else { - fields1119 := msg - p.write("(") - p.write("args") - p.indentSexp() - if !(len(fields1119) == 0) { - p.newline() - for i1121, elem1120 := range fields1119 { - if (i1121 > 0) { - p.newline() - } - p.pretty_abstraction(elem1120) -======= - flat1160 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) - if flat1160 != nil { - p.write(*flat1160) + flat1165 := p.tryFlat(msg, func() { p.pretty_ffi_args(msg) }) + if flat1165 != nil { + p.write(*flat1165) return nil } else { - fields1157 := msg + fields1162 := msg p.write("(") p.write("args") p.indentSexp() - if !(len(fields1157) == 0) { + if !(len(fields1162) == 0) { p.newline() - for i1159, elem1158 := range fields1157 { - if (i1159 > 0) { + for i1164, elem1163 := range fields1162 { + if (i1164 > 0) { p.newline() } - p.pretty_abstraction(elem1158) ->>>>>>> origin/main + p.pretty_abstraction(elem1163) } } p.dedent() @@ -4016,52 +2358,28 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { -<<<<<<< HEAD - flat1129 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat1129 != nil { - p.write(*flat1129) - return nil - } else { - _dollar_dollar := msg - fields1123 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1124 := fields1123 -======= - flat1167 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) - if flat1167 != nil { - p.write(*flat1167) + flat1172 := p.tryFlat(msg, func() { p.pretty_atom(msg) }) + if flat1172 != nil { + p.write(*flat1172) return nil } else { _dollar_dollar := msg - fields1161 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1162 := fields1161 ->>>>>>> origin/main + fields1166 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1167 := fields1166 p.write("(") p.write("atom") p.indentSexp() p.newline() -<<<<<<< HEAD - field1125 := unwrapped_fields1124[0].(*pb.RelationId) - p.pretty_relation_id(field1125) - field1126 := unwrapped_fields1124[1].([]*pb.Term) - if !(len(field1126) == 0) { + field1168 := unwrapped_fields1167[0].(*pb.RelationId) + p.pretty_relation_id(field1168) + field1169 := unwrapped_fields1167[1].([]*pb.Term) + if !(len(field1169) == 0) { p.newline() - for i1128, elem1127 := range field1126 { - if (i1128 > 0) { + for i1171, elem1170 := range field1169 { + if (i1171 > 0) { p.newline() } - p.pretty_term(elem1127) -======= - field1163 := unwrapped_fields1162[0].(*pb.RelationId) - p.pretty_relation_id(field1163) - field1164 := unwrapped_fields1162[1].([]*pb.Term) - if !(len(field1164) == 0) { - p.newline() - for i1166, elem1165 := range field1164 { - if (i1166 > 0) { - p.newline() - } - p.pretty_term(elem1165) ->>>>>>> origin/main + p.pretty_term(elem1170) } } p.dedent() @@ -4071,52 +2389,28 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { -<<<<<<< HEAD - flat1136 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat1136 != nil { - p.write(*flat1136) - return nil - } else { - _dollar_dollar := msg - fields1130 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1131 := fields1130 -======= - flat1174 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) - if flat1174 != nil { - p.write(*flat1174) + flat1179 := p.tryFlat(msg, func() { p.pretty_pragma(msg) }) + if flat1179 != nil { + p.write(*flat1179) return nil } else { _dollar_dollar := msg - fields1168 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1169 := fields1168 ->>>>>>> origin/main + fields1173 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1174 := fields1173 p.write("(") p.write("pragma") p.indentSexp() p.newline() -<<<<<<< HEAD - field1132 := unwrapped_fields1131[0].(string) - p.pretty_name(field1132) - field1133 := unwrapped_fields1131[1].([]*pb.Term) - if !(len(field1133) == 0) { - p.newline() - for i1135, elem1134 := range field1133 { - if (i1135 > 0) { - p.newline() - } - p.pretty_term(elem1134) -======= - field1170 := unwrapped_fields1169[0].(string) - p.pretty_name(field1170) - field1171 := unwrapped_fields1169[1].([]*pb.Term) - if !(len(field1171) == 0) { + field1175 := unwrapped_fields1174[0].(string) + p.pretty_name(field1175) + field1176 := unwrapped_fields1174[1].([]*pb.Term) + if !(len(field1176) == 0) { p.newline() - for i1173, elem1172 := range field1171 { - if (i1173 > 0) { + for i1178, elem1177 := range field1176 { + if (i1178 > 0) { p.newline() } - p.pretty_term(elem1172) ->>>>>>> origin/main + p.pretty_term(elem1177) } } p.dedent() @@ -4126,214 +2420,109 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { -<<<<<<< HEAD - flat1152 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat1152 != nil { - p.write(*flat1152) - return nil - } else { - _dollar_dollar := msg - var _t1683 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1683 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - guard_result1151 := _t1683 - if guard_result1151 != nil { - p.pretty_eq(msg) - } else { - _dollar_dollar := msg - var _t1684 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1684 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - guard_result1150 := _t1684 - if guard_result1150 != nil { - p.pretty_lt(msg) - } else { - _dollar_dollar := msg - var _t1685 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1685 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - guard_result1149 := _t1685 - if guard_result1149 != nil { - p.pretty_lt_eq(msg) - } else { - _dollar_dollar := msg - var _t1686 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1686 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - guard_result1148 := _t1686 - if guard_result1148 != nil { - p.pretty_gt(msg) - } else { - _dollar_dollar := msg - var _t1687 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1687 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - guard_result1147 := _t1687 - if guard_result1147 != nil { - p.pretty_gt_eq(msg) - } else { - _dollar_dollar := msg - var _t1688 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1688 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} - } - guard_result1146 := _t1688 - if guard_result1146 != nil { - p.pretty_add(msg) - } else { - _dollar_dollar := msg - var _t1689 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1689 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} - } - guard_result1145 := _t1689 - if guard_result1145 != nil { - p.pretty_minus(msg) - } else { - _dollar_dollar := msg - var _t1690 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1690 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} - } - guard_result1144 := _t1690 - if guard_result1144 != nil { - p.pretty_multiply(msg) - } else { - _dollar_dollar := msg - var _t1691 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1691 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} - } - guard_result1143 := _t1691 - if guard_result1143 != nil { - p.pretty_divide(msg) - } else { - _dollar_dollar := msg - fields1137 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1138 := fields1137 -======= - flat1190 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) - if flat1190 != nil { - p.write(*flat1190) + flat1195 := p.tryFlat(msg, func() { p.pretty_primitive(msg) }) + if flat1195 != nil { + p.write(*flat1195) return nil } else { _dollar_dollar := msg - var _t1759 []interface{} + var _t1769 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1759 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1769 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1189 := _t1759 - if guard_result1189 != nil { + guard_result1194 := _t1769 + if guard_result1194 != nil { p.pretty_eq(msg) } else { _dollar_dollar := msg - var _t1760 []interface{} + var _t1770 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1760 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1770 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1188 := _t1760 - if guard_result1188 != nil { + guard_result1193 := _t1770 + if guard_result1193 != nil { p.pretty_lt(msg) } else { _dollar_dollar := msg - var _t1761 []interface{} + var _t1771 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1761 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1771 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1187 := _t1761 - if guard_result1187 != nil { + guard_result1192 := _t1771 + if guard_result1192 != nil { p.pretty_lt_eq(msg) } else { _dollar_dollar := msg - var _t1762 []interface{} + var _t1772 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1762 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1772 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1186 := _t1762 - if guard_result1186 != nil { + guard_result1191 := _t1772 + if guard_result1191 != nil { p.pretty_gt(msg) } else { _dollar_dollar := msg - var _t1763 []interface{} + var _t1773 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1763 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1773 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - guard_result1185 := _t1763 - if guard_result1185 != nil { + guard_result1190 := _t1773 + if guard_result1190 != nil { p.pretty_gt_eq(msg) } else { _dollar_dollar := msg - var _t1764 []interface{} + var _t1774 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1764 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1774 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1184 := _t1764 - if guard_result1184 != nil { + guard_result1189 := _t1774 + if guard_result1189 != nil { p.pretty_add(msg) } else { _dollar_dollar := msg - var _t1765 []interface{} + var _t1775 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1765 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1775 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1183 := _t1765 - if guard_result1183 != nil { + guard_result1188 := _t1775 + if guard_result1188 != nil { p.pretty_minus(msg) } else { _dollar_dollar := msg - var _t1766 []interface{} + var _t1776 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1766 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1776 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1182 := _t1766 - if guard_result1182 != nil { + guard_result1187 := _t1776 + if guard_result1187 != nil { p.pretty_multiply(msg) } else { _dollar_dollar := msg - var _t1767 []interface{} + var _t1777 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1767 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1777 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - guard_result1181 := _t1767 - if guard_result1181 != nil { + guard_result1186 := _t1777 + if guard_result1186 != nil { p.pretty_divide(msg) } else { _dollar_dollar := msg - fields1175 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1176 := fields1175 ->>>>>>> origin/main + fields1180 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1181 := fields1180 p.write("(") p.write("primitive") p.indentSexp() p.newline() -<<<<<<< HEAD - field1139 := unwrapped_fields1138[0].(string) - p.pretty_name(field1139) - field1140 := unwrapped_fields1138[1].([]*pb.RelTerm) - if !(len(field1140) == 0) { + field1182 := unwrapped_fields1181[0].(string) + p.pretty_name(field1182) + field1183 := unwrapped_fields1181[1].([]*pb.RelTerm) + if !(len(field1183) == 0) { p.newline() - for i1142, elem1141 := range field1140 { - if (i1142 > 0) { + for i1185, elem1184 := range field1183 { + if (i1185 > 0) { p.newline() } - p.pretty_rel_term(elem1141) -======= - field1177 := unwrapped_fields1176[0].(string) - p.pretty_name(field1177) - field1178 := unwrapped_fields1176[1].([]*pb.RelTerm) - if !(len(field1178) == 0) { - p.newline() - for i1180, elem1179 := range field1178 { - if (i1180 > 0) { - p.newline() - } - p.pretty_rel_term(elem1179) ->>>>>>> origin/main + p.pretty_rel_term(elem1184) } } p.dedent() @@ -4343,273 +2532,27 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } } } - } - } - } - } - } - return nil -} - -func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { -<<<<<<< HEAD - flat1157 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat1157 != nil { - p.write(*flat1157) - return nil - } else { - _dollar_dollar := msg - var _t1692 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1692 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - fields1153 := _t1692 - unwrapped_fields1154 := fields1153 - p.write("(") - p.write("=") - p.indentSexp() - p.newline() - field1155 := unwrapped_fields1154[0].(*pb.Term) - p.pretty_term(field1155) - p.newline() - field1156 := unwrapped_fields1154[1].(*pb.Term) - p.pretty_term(field1156) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat1162 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) - if flat1162 != nil { - p.write(*flat1162) - return nil - } else { - _dollar_dollar := msg - var _t1693 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1693 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - fields1158 := _t1693 - unwrapped_fields1159 := fields1158 - p.write("(") - p.write("<") - p.indentSexp() - p.newline() - field1160 := unwrapped_fields1159[0].(*pb.Term) - p.pretty_term(field1160) - p.newline() - field1161 := unwrapped_fields1159[1].(*pb.Term) - p.pretty_term(field1161) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat1167 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) - if flat1167 != nil { - p.write(*flat1167) - return nil - } else { - _dollar_dollar := msg - var _t1694 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1694 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - fields1163 := _t1694 - unwrapped_fields1164 := fields1163 - p.write("(") - p.write("<=") - p.indentSexp() - p.newline() - field1165 := unwrapped_fields1164[0].(*pb.Term) - p.pretty_term(field1165) - p.newline() - field1166 := unwrapped_fields1164[1].(*pb.Term) - p.pretty_term(field1166) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat1172 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) - if flat1172 != nil { - p.write(*flat1172) - return nil - } else { - _dollar_dollar := msg - var _t1695 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1695 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - fields1168 := _t1695 - unwrapped_fields1169 := fields1168 - p.write("(") - p.write(">") - p.indentSexp() - p.newline() - field1170 := unwrapped_fields1169[0].(*pb.Term) - p.pretty_term(field1170) - p.newline() - field1171 := unwrapped_fields1169[1].(*pb.Term) - p.pretty_term(field1171) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat1177 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) - if flat1177 != nil { - p.write(*flat1177) - return nil - } else { - _dollar_dollar := msg - var _t1696 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1696 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - fields1173 := _t1696 - unwrapped_fields1174 := fields1173 - p.write("(") - p.write(">=") - p.indentSexp() - p.newline() - field1175 := unwrapped_fields1174[0].(*pb.Term) - p.pretty_term(field1175) - p.newline() - field1176 := unwrapped_fields1174[1].(*pb.Term) - p.pretty_term(field1176) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat1183 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat1183 != nil { - p.write(*flat1183) - return nil - } else { - _dollar_dollar := msg - var _t1697 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1697 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} - } - fields1178 := _t1697 - unwrapped_fields1179 := fields1178 - p.write("(") - p.write("+") - p.indentSexp() - p.newline() - field1180 := unwrapped_fields1179[0].(*pb.Term) - p.pretty_term(field1180) - p.newline() - field1181 := unwrapped_fields1179[1].(*pb.Term) - p.pretty_term(field1181) - p.newline() - field1182 := unwrapped_fields1179[2].(*pb.Term) - p.pretty_term(field1182) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat1189 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat1189 != nil { - p.write(*flat1189) - return nil - } else { - _dollar_dollar := msg - var _t1698 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1698 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} - } - fields1184 := _t1698 - unwrapped_fields1185 := fields1184 - p.write("(") - p.write("-") - p.indentSexp() - p.newline() - field1186 := unwrapped_fields1185[0].(*pb.Term) - p.pretty_term(field1186) - p.newline() - field1187 := unwrapped_fields1185[1].(*pb.Term) - p.pretty_term(field1187) - p.newline() - field1188 := unwrapped_fields1185[2].(*pb.Term) - p.pretty_term(field1188) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat1195 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) -======= - flat1195 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) ->>>>>>> origin/main - if flat1195 != nil { - p.write(*flat1195) - return nil - } else { - _dollar_dollar := msg -<<<<<<< HEAD - var _t1699 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1699 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} - } - fields1190 := _t1699 - unwrapped_fields1191 := fields1190 - p.write("(") - p.write("*") - p.indentSexp() - p.newline() - field1192 := unwrapped_fields1191[0].(*pb.Term) - p.pretty_term(field1192) - p.newline() - field1193 := unwrapped_fields1191[1].(*pb.Term) - p.pretty_term(field1193) - p.newline() - field1194 := unwrapped_fields1191[2].(*pb.Term) - p.pretty_term(field1194) - p.dedent() - p.write(")") + } + } + } + } } return nil } -func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat1201 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat1201 != nil { - p.write(*flat1201) +func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { + flat1200 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) + if flat1200 != nil { + p.write(*flat1200) return nil } else { _dollar_dollar := msg - var _t1700 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1700 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} - } - fields1196 := _t1700 - unwrapped_fields1197 := fields1196 -======= - var _t1768 []interface{} + var _t1778 []interface{} if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1768 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1778 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1191 := _t1768 - unwrapped_fields1192 := fields1191 ->>>>>>> origin/main + fields1196 := _t1778 + unwrapped_fields1197 := fields1196 p.write("(") p.write("=") p.indentSexp() @@ -4617,201 +2560,111 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { field1198 := unwrapped_fields1197[0].(*pb.Term) p.pretty_term(field1198) p.newline() -<<<<<<< HEAD field1199 := unwrapped_fields1197[1].(*pb.Term) p.pretty_term(field1199) - p.newline() - field1200 := unwrapped_fields1197[2].(*pb.Term) - p.pretty_term(field1200) -======= - field1194 := unwrapped_fields1192[1].(*pb.Term) - p.pretty_term(field1194) ->>>>>>> origin/main p.dedent() p.write(")") } return nil } -<<<<<<< HEAD -func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat1206 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat1206 != nil { - p.write(*flat1206) - return nil - } else { - _dollar_dollar := msg - var _t1701 *pb.Value - if hasProtoField(_dollar_dollar, "specialized_value") { - _t1701 = _dollar_dollar.GetSpecializedValue() - } - deconstruct_result1204 := _t1701 - if deconstruct_result1204 != nil { - unwrapped1205 := deconstruct_result1204 - p.pretty_specialized_value(unwrapped1205) - } else { - _dollar_dollar := msg - var _t1702 *pb.Term - if hasProtoField(_dollar_dollar, "term") { - _t1702 = _dollar_dollar.GetTerm() - } - deconstruct_result1202 := _t1702 - if deconstruct_result1202 != nil { - unwrapped1203 := deconstruct_result1202 - p.pretty_term(unwrapped1203) - } else { - panic(ParseError{msg: "No matching rule for rel_term"}) - } -======= func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat1200 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) - if flat1200 != nil { - p.write(*flat1200) + flat1205 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + if flat1205 != nil { + p.write(*flat1205) return nil } else { _dollar_dollar := msg - var _t1769 []interface{} + var _t1779 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1769 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} ->>>>>>> origin/main + _t1779 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1196 := _t1769 - unwrapped_fields1197 := fields1196 + fields1201 := _t1779 + unwrapped_fields1202 := fields1201 p.write("(") p.write("<") p.indentSexp() p.newline() - field1198 := unwrapped_fields1197[0].(*pb.Term) - p.pretty_term(field1198) + field1203 := unwrapped_fields1202[0].(*pb.Term) + p.pretty_term(field1203) p.newline() - field1199 := unwrapped_fields1197[1].(*pb.Term) - p.pretty_term(field1199) + field1204 := unwrapped_fields1202[1].(*pb.Term) + p.pretty_term(field1204) p.dedent() p.write(")") } return nil } -<<<<<<< HEAD -func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat1208 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat1208 != nil { - p.write(*flat1208) - return nil - } else { - fields1207 := msg - p.write("#") - p.pretty_raw_value(fields1207) -======= func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat1205 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) - if flat1205 != nil { - p.write(*flat1205) + flat1210 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) + if flat1210 != nil { + p.write(*flat1210) return nil } else { _dollar_dollar := msg - var _t1770 []interface{} + var _t1780 []interface{} if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1770 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1780 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1201 := _t1770 - unwrapped_fields1202 := fields1201 + fields1206 := _t1780 + unwrapped_fields1207 := fields1206 p.write("(") p.write("<=") p.indentSexp() p.newline() - field1203 := unwrapped_fields1202[0].(*pb.Term) - p.pretty_term(field1203) + field1208 := unwrapped_fields1207[0].(*pb.Term) + p.pretty_term(field1208) p.newline() - field1204 := unwrapped_fields1202[1].(*pb.Term) - p.pretty_term(field1204) + field1209 := unwrapped_fields1207[1].(*pb.Term) + p.pretty_term(field1209) p.dedent() p.write(")") ->>>>>>> origin/main } return nil } -<<<<<<< HEAD -func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat1215 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) +func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { + flat1215 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) if flat1215 != nil { p.write(*flat1215) return nil } else { _dollar_dollar := msg - fields1209 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1210 := fields1209 -======= -func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat1210 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) - if flat1210 != nil { - p.write(*flat1210) - return nil - } else { - _dollar_dollar := msg - var _t1771 []interface{} + var _t1781 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1771 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1781 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1206 := _t1771 - unwrapped_fields1207 := fields1206 ->>>>>>> origin/main + fields1211 := _t1781 + unwrapped_fields1212 := fields1211 p.write("(") p.write(">") p.indentSexp() p.newline() -<<<<<<< HEAD - field1211 := unwrapped_fields1210[0].(string) - p.pretty_name(field1211) - field1212 := unwrapped_fields1210[1].([]*pb.RelTerm) - if !(len(field1212) == 0) { - p.newline() - for i1214, elem1213 := range field1212 { - if (i1214 > 0) { - p.newline() - } - p.pretty_rel_term(elem1213) - } - } -======= - field1208 := unwrapped_fields1207[0].(*pb.Term) - p.pretty_term(field1208) + field1213 := unwrapped_fields1212[0].(*pb.Term) + p.pretty_term(field1213) p.newline() - field1209 := unwrapped_fields1207[1].(*pb.Term) - p.pretty_term(field1209) ->>>>>>> origin/main + field1214 := unwrapped_fields1212[1].(*pb.Term) + p.pretty_term(field1214) p.dedent() p.write(")") } return nil } -<<<<<<< HEAD -func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat1220 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) +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) return nil } else { _dollar_dollar := msg - fields1216 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} - unwrapped_fields1217 := fields1216 -======= -func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat1215 := p.tryFlat(msg, func() { p.pretty_gt_eq(msg) }) - if flat1215 != nil { - p.write(*flat1215) - return nil - } else { - _dollar_dollar := msg - var _t1772 []interface{} + var _t1782 []interface{} if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1772 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + _t1782 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1211 := _t1772 - unwrapped_fields1212 := fields1211 ->>>>>>> origin/main + fields1216 := _t1782 + unwrapped_fields1217 := fields1216 p.write("(") p.write(">=") p.indentSexp() @@ -4827,50 +2680,31 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { return nil } -<<<<<<< HEAD -func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1224 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1224 != nil { - p.write(*flat1224) - return nil - } else { - fields1221 := msg - p.write("(") - p.write("attrs") - p.indentSexp() - if !(len(fields1221) == 0) { - p.newline() - for i1223, elem1222 := range fields1221 { - if (i1223 > 0) { - p.newline() - } - p.pretty_attribute(elem1222) -======= func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat1221 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat1221 != nil { - p.write(*flat1221) + flat1226 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat1226 != nil { + p.write(*flat1226) return nil } else { _dollar_dollar := msg - var _t1773 []interface{} + var _t1783 []interface{} if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { - _t1773 = []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()} } - fields1216 := _t1773 - unwrapped_fields1217 := fields1216 + fields1221 := _t1783 + unwrapped_fields1222 := fields1221 p.write("(") p.write("+") p.indentSexp() p.newline() - field1218 := unwrapped_fields1217[0].(*pb.Term) - p.pretty_term(field1218) + field1223 := unwrapped_fields1222[0].(*pb.Term) + p.pretty_term(field1223) p.newline() - field1219 := unwrapped_fields1217[1].(*pb.Term) - p.pretty_term(field1219) + field1224 := unwrapped_fields1222[1].(*pb.Term) + p.pretty_term(field1224) p.newline() - field1220 := unwrapped_fields1217[2].(*pb.Term) - p.pretty_term(field1220) + field1225 := unwrapped_fields1222[2].(*pb.Term) + p.pretty_term(field1225) p.dedent() p.write(")") } @@ -4878,30 +2712,30 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { - flat1227 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) - if flat1227 != nil { - p.write(*flat1227) + flat1232 := p.tryFlat(msg, func() { p.pretty_minus(msg) }) + if flat1232 != nil { + p.write(*flat1232) return nil } else { _dollar_dollar := msg - var _t1774 []interface{} + var _t1784 []interface{} if _dollar_dollar.GetName() == "rel_primitive_subtract_monotype" { - _t1774 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1784 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1222 := _t1774 - unwrapped_fields1223 := fields1222 + fields1227 := _t1784 + unwrapped_fields1228 := fields1227 p.write("(") p.write("-") p.indentSexp() p.newline() - field1224 := unwrapped_fields1223[0].(*pb.Term) - p.pretty_term(field1224) + field1229 := unwrapped_fields1228[0].(*pb.Term) + p.pretty_term(field1229) p.newline() - field1225 := unwrapped_fields1223[1].(*pb.Term) - p.pretty_term(field1225) + field1230 := unwrapped_fields1228[1].(*pb.Term) + p.pretty_term(field1230) p.newline() - field1226 := unwrapped_fields1223[2].(*pb.Term) - p.pretty_term(field1226) + field1231 := unwrapped_fields1228[2].(*pb.Term) + p.pretty_term(field1231) p.dedent() p.write(")") } @@ -4909,30 +2743,30 @@ func (p *PrettyPrinter) pretty_minus(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { - flat1233 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) - if flat1233 != nil { - p.write(*flat1233) + flat1238 := p.tryFlat(msg, func() { p.pretty_multiply(msg) }) + if flat1238 != nil { + p.write(*flat1238) return nil } else { _dollar_dollar := msg - var _t1775 []interface{} + var _t1785 []interface{} if _dollar_dollar.GetName() == "rel_primitive_multiply_monotype" { - _t1775 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1785 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1228 := _t1775 - unwrapped_fields1229 := fields1228 + fields1233 := _t1785 + unwrapped_fields1234 := fields1233 p.write("(") p.write("*") p.indentSexp() p.newline() - field1230 := unwrapped_fields1229[0].(*pb.Term) - p.pretty_term(field1230) + field1235 := unwrapped_fields1234[0].(*pb.Term) + p.pretty_term(field1235) p.newline() - field1231 := unwrapped_fields1229[1].(*pb.Term) - p.pretty_term(field1231) + field1236 := unwrapped_fields1234[1].(*pb.Term) + p.pretty_term(field1236) p.newline() - field1232 := unwrapped_fields1229[2].(*pb.Term) - p.pretty_term(field1232) + field1237 := unwrapped_fields1234[2].(*pb.Term) + p.pretty_term(field1237) p.dedent() p.write(")") } @@ -4940,30 +2774,30 @@ func (p *PrettyPrinter) pretty_multiply(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { - flat1239 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) - if flat1239 != nil { - p.write(*flat1239) + flat1244 := p.tryFlat(msg, func() { p.pretty_divide(msg) }) + if flat1244 != nil { + p.write(*flat1244) return nil } else { _dollar_dollar := msg - var _t1776 []interface{} + var _t1786 []interface{} if _dollar_dollar.GetName() == "rel_primitive_divide_monotype" { - _t1776 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + _t1786 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} } - fields1234 := _t1776 - unwrapped_fields1235 := fields1234 + fields1239 := _t1786 + unwrapped_fields1240 := fields1239 p.write("(") p.write("/") p.indentSexp() p.newline() - field1236 := unwrapped_fields1235[0].(*pb.Term) - p.pretty_term(field1236) + field1241 := unwrapped_fields1240[0].(*pb.Term) + p.pretty_term(field1241) p.newline() - field1237 := unwrapped_fields1235[1].(*pb.Term) - p.pretty_term(field1237) + field1242 := unwrapped_fields1240[1].(*pb.Term) + p.pretty_term(field1242) p.newline() - field1238 := unwrapped_fields1235[2].(*pb.Term) - p.pretty_term(field1238) + field1243 := unwrapped_fields1240[2].(*pb.Term) + p.pretty_term(field1243) p.dedent() p.write(")") } @@ -4971,30 +2805,30 @@ func (p *PrettyPrinter) pretty_divide(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { - flat1244 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) - if flat1244 != nil { - p.write(*flat1244) + flat1249 := p.tryFlat(msg, func() { p.pretty_rel_term(msg) }) + if flat1249 != nil { + p.write(*flat1249) return nil } else { _dollar_dollar := msg - var _t1777 *pb.Value + var _t1787 *pb.Value if hasProtoField(_dollar_dollar, "specialized_value") { - _t1777 = _dollar_dollar.GetSpecializedValue() + _t1787 = _dollar_dollar.GetSpecializedValue() } - deconstruct_result1242 := _t1777 - if deconstruct_result1242 != nil { - unwrapped1243 := deconstruct_result1242 - p.pretty_specialized_value(unwrapped1243) + deconstruct_result1247 := _t1787 + if deconstruct_result1247 != nil { + unwrapped1248 := deconstruct_result1247 + p.pretty_specialized_value(unwrapped1248) } else { _dollar_dollar := msg - var _t1778 *pb.Term + var _t1788 *pb.Term if hasProtoField(_dollar_dollar, "term") { - _t1778 = _dollar_dollar.GetTerm() + _t1788 = _dollar_dollar.GetTerm() } - deconstruct_result1240 := _t1778 - if deconstruct_result1240 != nil { - unwrapped1241 := deconstruct_result1240 - p.pretty_term(unwrapped1241) + deconstruct_result1245 := _t1788 + if deconstruct_result1245 != nil { + unwrapped1246 := deconstruct_result1245 + p.pretty_term(unwrapped1246) } else { panic(ParseError{msg: "No matching rule for rel_term"}) } @@ -5004,41 +2838,41 @@ func (p *PrettyPrinter) pretty_rel_term(msg *pb.RelTerm) interface{} { } func (p *PrettyPrinter) pretty_specialized_value(msg *pb.Value) interface{} { - flat1246 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) - if flat1246 != nil { - p.write(*flat1246) + flat1251 := p.tryFlat(msg, func() { p.pretty_specialized_value(msg) }) + if flat1251 != nil { + p.write(*flat1251) return nil } else { - fields1245 := msg + fields1250 := msg p.write("#") - p.pretty_raw_value(fields1245) + p.pretty_raw_value(fields1250) } return nil } func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { - flat1253 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) - if flat1253 != nil { - p.write(*flat1253) + flat1258 := p.tryFlat(msg, func() { p.pretty_rel_atom(msg) }) + if flat1258 != nil { + p.write(*flat1258) return nil } else { _dollar_dollar := msg - fields1247 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} - unwrapped_fields1248 := fields1247 + fields1252 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1253 := fields1252 p.write("(") p.write("relatom") p.indentSexp() p.newline() - field1249 := unwrapped_fields1248[0].(string) - p.pretty_name(field1249) - field1250 := unwrapped_fields1248[1].([]*pb.RelTerm) - if !(len(field1250) == 0) { + field1254 := unwrapped_fields1253[0].(string) + p.pretty_name(field1254) + field1255 := unwrapped_fields1253[1].([]*pb.RelTerm) + if !(len(field1255) == 0) { p.newline() - for i1252, elem1251 := range field1250 { - if (i1252 > 0) { + for i1257, elem1256 := range field1255 { + if (i1257 > 0) { p.newline() } - p.pretty_rel_term(elem1251) + p.pretty_rel_term(elem1256) } } p.dedent() @@ -5048,23 +2882,23 @@ func (p *PrettyPrinter) pretty_rel_atom(msg *pb.RelAtom) interface{} { } func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { - flat1258 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) - if flat1258 != nil { - p.write(*flat1258) + flat1263 := p.tryFlat(msg, func() { p.pretty_cast(msg) }) + if flat1263 != nil { + p.write(*flat1263) return nil } else { _dollar_dollar := msg - fields1254 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} - unwrapped_fields1255 := fields1254 + fields1259 := []interface{}{_dollar_dollar.GetInput(), _dollar_dollar.GetResult()} + unwrapped_fields1260 := fields1259 p.write("(") p.write("cast") p.indentSexp() p.newline() - field1256 := unwrapped_fields1255[0].(*pb.Term) - p.pretty_term(field1256) + field1261 := unwrapped_fields1260[0].(*pb.Term) + p.pretty_term(field1261) p.newline() - field1257 := unwrapped_fields1255[1].(*pb.Term) - p.pretty_term(field1257) + field1262 := unwrapped_fields1260[1].(*pb.Term) + p.pretty_term(field1262) p.dedent() p.write(")") } @@ -5072,23 +2906,22 @@ func (p *PrettyPrinter) pretty_cast(msg *pb.Cast) interface{} { } func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { - flat1262 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) - if flat1262 != nil { - p.write(*flat1262) + flat1267 := p.tryFlat(msg, func() { p.pretty_attrs(msg) }) + if flat1267 != nil { + p.write(*flat1267) return nil } else { - fields1259 := msg + fields1264 := msg p.write("(") p.write("attrs") p.indentSexp() - if !(len(fields1259) == 0) { + if !(len(fields1264) == 0) { p.newline() - for i1261, elem1260 := range fields1259 { - if (i1261 > 0) { + for i1266, elem1265 := range fields1264 { + if (i1266 > 0) { p.newline() } - p.pretty_attribute(elem1260) ->>>>>>> origin/main + p.pretty_attribute(elem1265) } } p.dedent() @@ -5098,52 +2931,28 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { -<<<<<<< HEAD - flat1231 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1231 != nil { - p.write(*flat1231) + flat1274 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1274 != nil { + p.write(*flat1274) return nil } else { _dollar_dollar := msg - fields1225 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} - unwrapped_fields1226 := fields1225 -======= - flat1269 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1269 != nil { - p.write(*flat1269) - return nil - } else { - _dollar_dollar := msg - fields1263 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} - unwrapped_fields1264 := fields1263 ->>>>>>> origin/main + fields1268 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} + unwrapped_fields1269 := fields1268 p.write("(") p.write("attribute") p.indentSexp() p.newline() -<<<<<<< HEAD - field1227 := unwrapped_fields1226[0].(string) - p.pretty_name(field1227) - field1228 := unwrapped_fields1226[1].([]*pb.Value) - if !(len(field1228) == 0) { - p.newline() - for i1230, elem1229 := range field1228 { - if (i1230 > 0) { - p.newline() - } - p.pretty_raw_value(elem1229) -======= - field1265 := unwrapped_fields1264[0].(string) - p.pretty_name(field1265) - field1266 := unwrapped_fields1264[1].([]*pb.Value) - if !(len(field1266) == 0) { + field1270 := unwrapped_fields1269[0].(string) + p.pretty_name(field1270) + field1271 := unwrapped_fields1269[1].([]*pb.Value) + if !(len(field1271) == 0) { p.newline() - for i1268, elem1267 := range field1266 { - if (i1268 > 0) { + for i1273, elem1272 := range field1271 { + if (i1273 > 0) { p.newline() } - p.pretty_raw_value(elem1267) ->>>>>>> origin/main + p.pretty_raw_value(elem1272) } } p.dedent() @@ -5153,75 +2962,39 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { -<<<<<<< HEAD - flat1240 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1240 != nil { - p.write(*flat1240) - return nil - } else { - _dollar_dollar := msg - var _t1703 []*pb.Attribute - if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1703 = _dollar_dollar.GetAttrs() - } - fields1232 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1703} - unwrapped_fields1233 := fields1232 - p.write("(") - p.write("algorithm") - p.indentSexp() - field1234 := unwrapped_fields1233[0].([]*pb.RelationId) - if !(len(field1234) == 0) { - p.newline() - for i1236, elem1235 := range field1234 { - if (i1236 > 0) { - p.newline() - } - p.pretty_relation_id(elem1235) - } - } - p.newline() - field1237 := unwrapped_fields1233[1].(*pb.Script) - p.pretty_script(field1237) - field1238 := unwrapped_fields1233[2].([]*pb.Attribute) - if field1238 != nil { - p.newline() - opt_val1239 := field1238 - p.pretty_attrs(opt_val1239) -======= - flat1278 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) - if flat1278 != nil { - p.write(*flat1278) + flat1283 := p.tryFlat(msg, func() { p.pretty_algorithm(msg) }) + if flat1283 != nil { + p.write(*flat1283) return nil } else { _dollar_dollar := msg - var _t1779 []*pb.Attribute + var _t1789 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1779 = _dollar_dollar.GetAttrs() + _t1789 = _dollar_dollar.GetAttrs() } - fields1270 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1779} - unwrapped_fields1271 := fields1270 + fields1275 := []interface{}{_dollar_dollar.GetGlobal(), _dollar_dollar.GetBody(), _t1789} + unwrapped_fields1276 := fields1275 p.write("(") p.write("algorithm") p.indentSexp() - field1272 := unwrapped_fields1271[0].([]*pb.RelationId) - if !(len(field1272) == 0) { + field1277 := unwrapped_fields1276[0].([]*pb.RelationId) + if !(len(field1277) == 0) { p.newline() - for i1274, elem1273 := range field1272 { - if (i1274 > 0) { + for i1279, elem1278 := range field1277 { + if (i1279 > 0) { p.newline() } - p.pretty_relation_id(elem1273) + p.pretty_relation_id(elem1278) } } p.newline() - field1275 := unwrapped_fields1271[1].(*pb.Script) - p.pretty_script(field1275) - field1276 := unwrapped_fields1271[2].([]*pb.Attribute) - if field1276 != nil { + field1280 := unwrapped_fields1276[1].(*pb.Script) + p.pretty_script(field1280) + field1281 := unwrapped_fields1276[2].([]*pb.Attribute) + if field1281 != nil { p.newline() - opt_val1277 := field1276 - p.pretty_attrs(opt_val1277) ->>>>>>> origin/main + opt_val1282 := field1281 + p.pretty_attrs(opt_val1282) } p.dedent() p.write(")") @@ -5230,45 +3003,24 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { -<<<<<<< HEAD - flat1245 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1245 != nil { - p.write(*flat1245) - return nil - } else { - _dollar_dollar := msg - fields1241 := _dollar_dollar.GetConstructs() - unwrapped_fields1242 := fields1241 - p.write("(") - p.write("script") - p.indentSexp() - if !(len(unwrapped_fields1242) == 0) { - p.newline() - for i1244, elem1243 := range unwrapped_fields1242 { - if (i1244 > 0) { - p.newline() - } - p.pretty_construct(elem1243) -======= - flat1283 := p.tryFlat(msg, func() { p.pretty_script(msg) }) - if flat1283 != nil { - p.write(*flat1283) + flat1288 := p.tryFlat(msg, func() { p.pretty_script(msg) }) + if flat1288 != nil { + p.write(*flat1288) return nil } else { _dollar_dollar := msg - fields1279 := _dollar_dollar.GetConstructs() - unwrapped_fields1280 := fields1279 + fields1284 := _dollar_dollar.GetConstructs() + unwrapped_fields1285 := fields1284 p.write("(") p.write("script") p.indentSexp() - if !(len(unwrapped_fields1280) == 0) { + if !(len(unwrapped_fields1285) == 0) { p.newline() - for i1282, elem1281 := range unwrapped_fields1280 { - if (i1282 > 0) { + for i1287, elem1286 := range unwrapped_fields1285 { + if (i1287 > 0) { p.newline() } - p.pretty_construct(elem1281) ->>>>>>> origin/main + p.pretty_construct(elem1286) } } p.dedent() @@ -5278,57 +3030,30 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { -<<<<<<< HEAD - flat1250 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1250 != nil { - p.write(*flat1250) - return nil - } else { - _dollar_dollar := msg - var _t1704 *pb.Loop - if hasProtoField(_dollar_dollar, "loop") { - _t1704 = _dollar_dollar.GetLoop() - } - deconstruct_result1248 := _t1704 - if deconstruct_result1248 != nil { - unwrapped1249 := deconstruct_result1248 - p.pretty_loop(unwrapped1249) - } else { - _dollar_dollar := msg - var _t1705 *pb.Instruction - if hasProtoField(_dollar_dollar, "instruction") { - _t1705 = _dollar_dollar.GetInstruction() - } - deconstruct_result1246 := _t1705 - if deconstruct_result1246 != nil { - unwrapped1247 := deconstruct_result1246 - p.pretty_instruction(unwrapped1247) -======= - flat1288 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) - if flat1288 != nil { - p.write(*flat1288) + flat1293 := p.tryFlat(msg, func() { p.pretty_construct(msg) }) + if flat1293 != nil { + p.write(*flat1293) return nil } else { _dollar_dollar := msg - var _t1780 *pb.Loop + var _t1790 *pb.Loop if hasProtoField(_dollar_dollar, "loop") { - _t1780 = _dollar_dollar.GetLoop() + _t1790 = _dollar_dollar.GetLoop() } - deconstruct_result1286 := _t1780 - if deconstruct_result1286 != nil { - unwrapped1287 := deconstruct_result1286 - p.pretty_loop(unwrapped1287) + deconstruct_result1291 := _t1790 + if deconstruct_result1291 != nil { + unwrapped1292 := deconstruct_result1291 + p.pretty_loop(unwrapped1292) } else { _dollar_dollar := msg - var _t1781 *pb.Instruction + var _t1791 *pb.Instruction if hasProtoField(_dollar_dollar, "instruction") { - _t1781 = _dollar_dollar.GetInstruction() + _t1791 = _dollar_dollar.GetInstruction() } - deconstruct_result1284 := _t1781 - if deconstruct_result1284 != nil { - unwrapped1285 := deconstruct_result1284 - p.pretty_instruction(unwrapped1285) ->>>>>>> origin/main + deconstruct_result1289 := _t1791 + if deconstruct_result1289 != nil { + unwrapped1290 := deconstruct_result1289 + p.pretty_instruction(unwrapped1290) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -5338,60 +3063,32 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { -<<<<<<< HEAD - flat1257 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1257 != nil { - p.write(*flat1257) - return nil - } else { - _dollar_dollar := msg - var _t1706 []*pb.Attribute - if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1706 = _dollar_dollar.GetAttrs() - } - fields1251 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1706} - unwrapped_fields1252 := fields1251 -======= - flat1295 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) - if flat1295 != nil { - p.write(*flat1295) + flat1300 := p.tryFlat(msg, func() { p.pretty_loop(msg) }) + if flat1300 != nil { + p.write(*flat1300) return nil } else { _dollar_dollar := msg - var _t1782 []*pb.Attribute + var _t1792 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1782 = _dollar_dollar.GetAttrs() + _t1792 = _dollar_dollar.GetAttrs() } - fields1289 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1782} - unwrapped_fields1290 := fields1289 ->>>>>>> origin/main + fields1294 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1792} + unwrapped_fields1295 := fields1294 p.write("(") p.write("loop") p.indentSexp() p.newline() -<<<<<<< HEAD - field1253 := unwrapped_fields1252[0].([]*pb.Instruction) - p.pretty_init(field1253) + field1296 := unwrapped_fields1295[0].([]*pb.Instruction) + p.pretty_init(field1296) p.newline() - field1254 := unwrapped_fields1252[1].(*pb.Script) - p.pretty_script(field1254) - field1255 := unwrapped_fields1252[2].([]*pb.Attribute) - if field1255 != nil { + field1297 := unwrapped_fields1295[1].(*pb.Script) + p.pretty_script(field1297) + field1298 := unwrapped_fields1295[2].([]*pb.Attribute) + if field1298 != nil { p.newline() - opt_val1256 := field1255 - p.pretty_attrs(opt_val1256) -======= - field1291 := unwrapped_fields1290[0].([]*pb.Instruction) - p.pretty_init(field1291) - p.newline() - field1292 := unwrapped_fields1290[1].(*pb.Script) - p.pretty_script(field1292) - field1293 := unwrapped_fields1290[2].([]*pb.Attribute) - if field1293 != nil { - p.newline() - opt_val1294 := field1293 - p.pretty_attrs(opt_val1294) ->>>>>>> origin/main + opt_val1299 := field1298 + p.pretty_attrs(opt_val1299) } p.dedent() p.write(")") @@ -5400,41 +3097,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { -<<<<<<< HEAD - flat1261 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1261 != nil { - p.write(*flat1261) - return nil - } else { - fields1258 := msg - p.write("(") - p.write("init") - p.indentSexp() - if !(len(fields1258) == 0) { - p.newline() - for i1260, elem1259 := range fields1258 { - if (i1260 > 0) { - p.newline() - } - p.pretty_instruction(elem1259) -======= - flat1299 := p.tryFlat(msg, func() { p.pretty_init(msg) }) - if flat1299 != nil { - p.write(*flat1299) + flat1304 := p.tryFlat(msg, func() { p.pretty_init(msg) }) + if flat1304 != nil { + p.write(*flat1304) return nil } else { - fields1296 := msg + fields1301 := msg p.write("(") p.write("init") p.indentSexp() - if !(len(fields1296) == 0) { + if !(len(fields1301) == 0) { p.newline() - for i1298, elem1297 := range fields1296 { - if (i1298 > 0) { + for i1303, elem1302 := range fields1301 { + if (i1303 > 0) { p.newline() } - p.pretty_instruction(elem1297) ->>>>>>> origin/main + p.pretty_instruction(elem1302) } } p.dedent() @@ -5444,117 +3122,60 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { -<<<<<<< HEAD - flat1272 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1272 != nil { - p.write(*flat1272) - return nil - } else { - _dollar_dollar := msg - var _t1707 *pb.Assign - if hasProtoField(_dollar_dollar, "assign") { - _t1707 = _dollar_dollar.GetAssign() - } - deconstruct_result1270 := _t1707 - if deconstruct_result1270 != nil { - unwrapped1271 := deconstruct_result1270 - p.pretty_assign(unwrapped1271) - } else { - _dollar_dollar := msg - var _t1708 *pb.Upsert - if hasProtoField(_dollar_dollar, "upsert") { - _t1708 = _dollar_dollar.GetUpsert() - } - deconstruct_result1268 := _t1708 - if deconstruct_result1268 != nil { - unwrapped1269 := deconstruct_result1268 - p.pretty_upsert(unwrapped1269) - } else { - _dollar_dollar := msg - var _t1709 *pb.Break - if hasProtoField(_dollar_dollar, "break") { - _t1709 = _dollar_dollar.GetBreak() - } - deconstruct_result1266 := _t1709 - if deconstruct_result1266 != nil { - unwrapped1267 := deconstruct_result1266 - p.pretty_break(unwrapped1267) - } else { - _dollar_dollar := msg - var _t1710 *pb.MonoidDef - if hasProtoField(_dollar_dollar, "monoid_def") { - _t1710 = _dollar_dollar.GetMonoidDef() - } - deconstruct_result1264 := _t1710 - if deconstruct_result1264 != nil { - unwrapped1265 := deconstruct_result1264 - p.pretty_monoid_def(unwrapped1265) - } else { - _dollar_dollar := msg - var _t1711 *pb.MonusDef - if hasProtoField(_dollar_dollar, "monus_def") { - _t1711 = _dollar_dollar.GetMonusDef() - } - deconstruct_result1262 := _t1711 - if deconstruct_result1262 != nil { - unwrapped1263 := deconstruct_result1262 - p.pretty_monus_def(unwrapped1263) -======= - flat1310 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) - if flat1310 != nil { - p.write(*flat1310) + flat1315 := p.tryFlat(msg, func() { p.pretty_instruction(msg) }) + if flat1315 != nil { + p.write(*flat1315) return nil } else { _dollar_dollar := msg - var _t1783 *pb.Assign + var _t1793 *pb.Assign if hasProtoField(_dollar_dollar, "assign") { - _t1783 = _dollar_dollar.GetAssign() + _t1793 = _dollar_dollar.GetAssign() } - deconstruct_result1308 := _t1783 - if deconstruct_result1308 != nil { - unwrapped1309 := deconstruct_result1308 - p.pretty_assign(unwrapped1309) + deconstruct_result1313 := _t1793 + if deconstruct_result1313 != nil { + unwrapped1314 := deconstruct_result1313 + p.pretty_assign(unwrapped1314) } else { _dollar_dollar := msg - var _t1784 *pb.Upsert + var _t1794 *pb.Upsert if hasProtoField(_dollar_dollar, "upsert") { - _t1784 = _dollar_dollar.GetUpsert() + _t1794 = _dollar_dollar.GetUpsert() } - deconstruct_result1306 := _t1784 - if deconstruct_result1306 != nil { - unwrapped1307 := deconstruct_result1306 - p.pretty_upsert(unwrapped1307) + deconstruct_result1311 := _t1794 + if deconstruct_result1311 != nil { + unwrapped1312 := deconstruct_result1311 + p.pretty_upsert(unwrapped1312) } else { _dollar_dollar := msg - var _t1785 *pb.Break + var _t1795 *pb.Break if hasProtoField(_dollar_dollar, "break") { - _t1785 = _dollar_dollar.GetBreak() + _t1795 = _dollar_dollar.GetBreak() } - deconstruct_result1304 := _t1785 - if deconstruct_result1304 != nil { - unwrapped1305 := deconstruct_result1304 - p.pretty_break(unwrapped1305) + deconstruct_result1309 := _t1795 + if deconstruct_result1309 != nil { + unwrapped1310 := deconstruct_result1309 + p.pretty_break(unwrapped1310) } else { _dollar_dollar := msg - var _t1786 *pb.MonoidDef + var _t1796 *pb.MonoidDef if hasProtoField(_dollar_dollar, "monoid_def") { - _t1786 = _dollar_dollar.GetMonoidDef() + _t1796 = _dollar_dollar.GetMonoidDef() } - deconstruct_result1302 := _t1786 - if deconstruct_result1302 != nil { - unwrapped1303 := deconstruct_result1302 - p.pretty_monoid_def(unwrapped1303) + deconstruct_result1307 := _t1796 + if deconstruct_result1307 != nil { + unwrapped1308 := deconstruct_result1307 + p.pretty_monoid_def(unwrapped1308) } else { _dollar_dollar := msg - var _t1787 *pb.MonusDef + var _t1797 *pb.MonusDef if hasProtoField(_dollar_dollar, "monus_def") { - _t1787 = _dollar_dollar.GetMonusDef() + _t1797 = _dollar_dollar.GetMonusDef() } - deconstruct_result1300 := _t1787 - if deconstruct_result1300 != nil { - unwrapped1301 := deconstruct_result1300 - p.pretty_monus_def(unwrapped1301) ->>>>>>> origin/main + deconstruct_result1305 := _t1797 + if deconstruct_result1305 != nil { + unwrapped1306 := deconstruct_result1305 + p.pretty_monus_def(unwrapped1306) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -5567,60 +3188,32 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { -<<<<<<< HEAD - flat1279 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1279 != nil { - p.write(*flat1279) - return nil - } else { - _dollar_dollar := msg - var _t1712 []*pb.Attribute - if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1712 = _dollar_dollar.GetAttrs() - } - fields1273 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1712} - unwrapped_fields1274 := fields1273 -======= - flat1317 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) - if flat1317 != nil { - p.write(*flat1317) + flat1322 := p.tryFlat(msg, func() { p.pretty_assign(msg) }) + if flat1322 != nil { + p.write(*flat1322) return nil } else { _dollar_dollar := msg - var _t1788 []*pb.Attribute + var _t1798 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1788 = _dollar_dollar.GetAttrs() + _t1798 = _dollar_dollar.GetAttrs() } - fields1311 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1788} - unwrapped_fields1312 := fields1311 ->>>>>>> origin/main + fields1316 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1798} + unwrapped_fields1317 := fields1316 p.write("(") p.write("assign") p.indentSexp() p.newline() -<<<<<<< HEAD - field1275 := unwrapped_fields1274[0].(*pb.RelationId) - p.pretty_relation_id(field1275) + field1318 := unwrapped_fields1317[0].(*pb.RelationId) + p.pretty_relation_id(field1318) p.newline() - field1276 := unwrapped_fields1274[1].(*pb.Abstraction) - p.pretty_abstraction(field1276) - field1277 := unwrapped_fields1274[2].([]*pb.Attribute) - if field1277 != nil { - p.newline() - opt_val1278 := field1277 - p.pretty_attrs(opt_val1278) -======= - field1313 := unwrapped_fields1312[0].(*pb.RelationId) - p.pretty_relation_id(field1313) - p.newline() - field1314 := unwrapped_fields1312[1].(*pb.Abstraction) - p.pretty_abstraction(field1314) - field1315 := unwrapped_fields1312[2].([]*pb.Attribute) - if field1315 != nil { + field1319 := unwrapped_fields1317[1].(*pb.Abstraction) + p.pretty_abstraction(field1319) + field1320 := unwrapped_fields1317[2].([]*pb.Attribute) + if field1320 != nil { p.newline() - opt_val1316 := field1315 - p.pretty_attrs(opt_val1316) ->>>>>>> origin/main + opt_val1321 := field1320 + p.pretty_attrs(opt_val1321) } p.dedent() p.write(")") @@ -5629,60 +3222,32 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { -<<<<<<< HEAD - flat1286 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1286 != nil { - p.write(*flat1286) - return nil - } else { - _dollar_dollar := msg - var _t1713 []*pb.Attribute - if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1713 = _dollar_dollar.GetAttrs() - } - fields1280 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1713} - unwrapped_fields1281 := fields1280 -======= - flat1324 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) - if flat1324 != nil { - p.write(*flat1324) + flat1329 := p.tryFlat(msg, func() { p.pretty_upsert(msg) }) + if flat1329 != nil { + p.write(*flat1329) return nil } else { _dollar_dollar := msg - var _t1789 []*pb.Attribute + var _t1799 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1789 = _dollar_dollar.GetAttrs() + _t1799 = _dollar_dollar.GetAttrs() } - fields1318 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1789} - unwrapped_fields1319 := fields1318 ->>>>>>> origin/main + fields1323 := []interface{}{_dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1799} + unwrapped_fields1324 := fields1323 p.write("(") p.write("upsert") p.indentSexp() p.newline() -<<<<<<< HEAD - field1282 := unwrapped_fields1281[0].(*pb.RelationId) - p.pretty_relation_id(field1282) + field1325 := unwrapped_fields1324[0].(*pb.RelationId) + p.pretty_relation_id(field1325) p.newline() - field1283 := unwrapped_fields1281[1].([]interface{}) - p.pretty_abstraction_with_arity(field1283) - field1284 := unwrapped_fields1281[2].([]*pb.Attribute) - if field1284 != nil { + field1326 := unwrapped_fields1324[1].([]interface{}) + p.pretty_abstraction_with_arity(field1326) + field1327 := unwrapped_fields1324[2].([]*pb.Attribute) + if field1327 != nil { p.newline() - opt_val1285 := field1284 - p.pretty_attrs(opt_val1285) -======= - field1320 := unwrapped_fields1319[0].(*pb.RelationId) - p.pretty_relation_id(field1320) - p.newline() - field1321 := unwrapped_fields1319[1].([]interface{}) - p.pretty_abstraction_with_arity(field1321) - field1322 := unwrapped_fields1319[2].([]*pb.Attribute) - if field1322 != nil { - p.newline() - opt_val1323 := field1322 - p.pretty_attrs(opt_val1323) ->>>>>>> origin/main + opt_val1328 := field1327 + p.pretty_attrs(opt_val1328) } p.dedent() p.write(")") @@ -5691,102 +3256,55 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { -<<<<<<< HEAD - flat1291 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1291 != nil { - p.write(*flat1291) - return nil - } else { - _dollar_dollar := msg - _t1714 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - fields1287 := []interface{}{_t1714, _dollar_dollar[0].(*pb.Abstraction).GetValue()} - unwrapped_fields1288 := fields1287 - p.write("(") - p.indent() - field1289 := unwrapped_fields1288[0].([]interface{}) - p.pretty_bindings(field1289) - p.newline() - field1290 := unwrapped_fields1288[1].(*pb.Formula) - p.pretty_formula(field1290) -======= - flat1329 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) - if flat1329 != nil { - p.write(*flat1329) + flat1334 := p.tryFlat(msg, func() { p.pretty_abstraction_with_arity(msg) }) + if flat1334 != nil { + p.write(*flat1334) return nil } else { _dollar_dollar := msg - _t1790 := p.deconstruct_bindings_with_arity(_dollar_dollar[0].(*pb.Abstraction), _dollar_dollar[1].(int64)) - fields1325 := []interface{}{_t1790, _dollar_dollar[0].(*pb.Abstraction).GetValue()} - unwrapped_fields1326 := fields1325 + _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 p.write("(") p.indent() - field1327 := unwrapped_fields1326[0].([]interface{}) - p.pretty_bindings(field1327) + field1332 := unwrapped_fields1331[0].([]interface{}) + p.pretty_bindings(field1332) p.newline() - field1328 := unwrapped_fields1326[1].(*pb.Formula) - p.pretty_formula(field1328) ->>>>>>> origin/main + field1333 := unwrapped_fields1331[1].(*pb.Formula) + p.pretty_formula(field1333) p.dedent() p.write(")") } return nil -} - -func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { -<<<<<<< HEAD - flat1298 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1298 != nil { - p.write(*flat1298) - return nil - } else { - _dollar_dollar := msg - var _t1715 []*pb.Attribute - if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1715 = _dollar_dollar.GetAttrs() - } - fields1292 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1715} - unwrapped_fields1293 := fields1292 -======= - flat1336 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1336 != nil { - p.write(*flat1336) +} + +func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { + flat1341 := p.tryFlat(msg, func() { p.pretty_break(msg) }) + if flat1341 != nil { + p.write(*flat1341) return nil } else { _dollar_dollar := msg - var _t1791 []*pb.Attribute + var _t1801 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1791 = _dollar_dollar.GetAttrs() + _t1801 = _dollar_dollar.GetAttrs() } - fields1330 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1791} - unwrapped_fields1331 := fields1330 ->>>>>>> origin/main + fields1335 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1801} + unwrapped_fields1336 := fields1335 p.write("(") p.write("break") p.indentSexp() p.newline() -<<<<<<< HEAD - field1294 := unwrapped_fields1293[0].(*pb.RelationId) - p.pretty_relation_id(field1294) + field1337 := unwrapped_fields1336[0].(*pb.RelationId) + p.pretty_relation_id(field1337) p.newline() - field1295 := unwrapped_fields1293[1].(*pb.Abstraction) - p.pretty_abstraction(field1295) - field1296 := unwrapped_fields1293[2].([]*pb.Attribute) - if field1296 != nil { + field1338 := unwrapped_fields1336[1].(*pb.Abstraction) + p.pretty_abstraction(field1338) + field1339 := unwrapped_fields1336[2].([]*pb.Attribute) + if field1339 != nil { p.newline() - opt_val1297 := field1296 - p.pretty_attrs(opt_val1297) -======= - field1332 := unwrapped_fields1331[0].(*pb.RelationId) - p.pretty_relation_id(field1332) - p.newline() - field1333 := unwrapped_fields1331[1].(*pb.Abstraction) - p.pretty_abstraction(field1333) - field1334 := unwrapped_fields1331[2].([]*pb.Attribute) - if field1334 != nil { - p.newline() - opt_val1335 := field1334 - p.pretty_attrs(opt_val1335) ->>>>>>> origin/main + opt_val1340 := field1339 + p.pretty_attrs(opt_val1340) } p.dedent() p.write(")") @@ -5795,66 +3313,35 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { -<<<<<<< HEAD - flat1306 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1306 != nil { - p.write(*flat1306) - return nil - } else { - _dollar_dollar := msg - var _t1716 []*pb.Attribute - if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1716 = _dollar_dollar.GetAttrs() - } - fields1299 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1716} - unwrapped_fields1300 := fields1299 -======= - flat1344 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) - if flat1344 != nil { - p.write(*flat1344) + flat1349 := p.tryFlat(msg, func() { p.pretty_monoid_def(msg) }) + if flat1349 != nil { + p.write(*flat1349) return nil } else { _dollar_dollar := msg - var _t1792 []*pb.Attribute + var _t1802 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1792 = _dollar_dollar.GetAttrs() + _t1802 = _dollar_dollar.GetAttrs() } - fields1337 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1792} - unwrapped_fields1338 := fields1337 ->>>>>>> origin/main + fields1342 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1802} + unwrapped_fields1343 := fields1342 p.write("(") p.write("monoid") p.indentSexp() p.newline() -<<<<<<< HEAD - field1301 := unwrapped_fields1300[0].(*pb.Monoid) - p.pretty_monoid(field1301) + field1344 := unwrapped_fields1343[0].(*pb.Monoid) + p.pretty_monoid(field1344) p.newline() - field1302 := unwrapped_fields1300[1].(*pb.RelationId) - p.pretty_relation_id(field1302) + field1345 := unwrapped_fields1343[1].(*pb.RelationId) + p.pretty_relation_id(field1345) p.newline() - field1303 := unwrapped_fields1300[2].([]interface{}) - p.pretty_abstraction_with_arity(field1303) - field1304 := unwrapped_fields1300[3].([]*pb.Attribute) - if field1304 != nil { + field1346 := unwrapped_fields1343[2].([]interface{}) + p.pretty_abstraction_with_arity(field1346) + field1347 := unwrapped_fields1343[3].([]*pb.Attribute) + if field1347 != nil { p.newline() - opt_val1305 := field1304 - p.pretty_attrs(opt_val1305) -======= - field1339 := unwrapped_fields1338[0].(*pb.Monoid) - p.pretty_monoid(field1339) - p.newline() - field1340 := unwrapped_fields1338[1].(*pb.RelationId) - p.pretty_relation_id(field1340) - p.newline() - field1341 := unwrapped_fields1338[2].([]interface{}) - p.pretty_abstraction_with_arity(field1341) - field1342 := unwrapped_fields1338[3].([]*pb.Attribute) - if field1342 != nil { - p.newline() - opt_val1343 := field1342 - p.pretty_attrs(opt_val1343) ->>>>>>> origin/main + opt_val1348 := field1347 + p.pretty_attrs(opt_val1348) } p.dedent() p.write(")") @@ -5863,97 +3350,50 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { -<<<<<<< HEAD - flat1315 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1315 != nil { - p.write(*flat1315) - return nil - } else { - _dollar_dollar := msg - var _t1717 *pb.OrMonoid - if hasProtoField(_dollar_dollar, "or_monoid") { - _t1717 = _dollar_dollar.GetOrMonoid() - } - deconstruct_result1313 := _t1717 - if deconstruct_result1313 != nil { - unwrapped1314 := deconstruct_result1313 - p.pretty_or_monoid(unwrapped1314) - } else { - _dollar_dollar := msg - var _t1718 *pb.MinMonoid - if hasProtoField(_dollar_dollar, "min_monoid") { - _t1718 = _dollar_dollar.GetMinMonoid() - } - deconstruct_result1311 := _t1718 - if deconstruct_result1311 != nil { - unwrapped1312 := deconstruct_result1311 - p.pretty_min_monoid(unwrapped1312) - } else { - _dollar_dollar := msg - var _t1719 *pb.MaxMonoid - if hasProtoField(_dollar_dollar, "max_monoid") { - _t1719 = _dollar_dollar.GetMaxMonoid() - } - deconstruct_result1309 := _t1719 - if deconstruct_result1309 != nil { - unwrapped1310 := deconstruct_result1309 - p.pretty_max_monoid(unwrapped1310) - } else { - _dollar_dollar := msg - var _t1720 *pb.SumMonoid - if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1720 = _dollar_dollar.GetSumMonoid() - } - deconstruct_result1307 := _t1720 - if deconstruct_result1307 != nil { - unwrapped1308 := deconstruct_result1307 - p.pretty_sum_monoid(unwrapped1308) -======= - flat1353 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) - if flat1353 != nil { - p.write(*flat1353) + flat1358 := p.tryFlat(msg, func() { p.pretty_monoid(msg) }) + if flat1358 != nil { + p.write(*flat1358) return nil } else { _dollar_dollar := msg - var _t1793 *pb.OrMonoid + var _t1803 *pb.OrMonoid if hasProtoField(_dollar_dollar, "or_monoid") { - _t1793 = _dollar_dollar.GetOrMonoid() + _t1803 = _dollar_dollar.GetOrMonoid() } - deconstruct_result1351 := _t1793 - if deconstruct_result1351 != nil { - unwrapped1352 := deconstruct_result1351 - p.pretty_or_monoid(unwrapped1352) + deconstruct_result1356 := _t1803 + if deconstruct_result1356 != nil { + unwrapped1357 := deconstruct_result1356 + p.pretty_or_monoid(unwrapped1357) } else { _dollar_dollar := msg - var _t1794 *pb.MinMonoid + var _t1804 *pb.MinMonoid if hasProtoField(_dollar_dollar, "min_monoid") { - _t1794 = _dollar_dollar.GetMinMonoid() + _t1804 = _dollar_dollar.GetMinMonoid() } - deconstruct_result1349 := _t1794 - if deconstruct_result1349 != nil { - unwrapped1350 := deconstruct_result1349 - p.pretty_min_monoid(unwrapped1350) + deconstruct_result1354 := _t1804 + if deconstruct_result1354 != nil { + unwrapped1355 := deconstruct_result1354 + p.pretty_min_monoid(unwrapped1355) } else { _dollar_dollar := msg - var _t1795 *pb.MaxMonoid + var _t1805 *pb.MaxMonoid if hasProtoField(_dollar_dollar, "max_monoid") { - _t1795 = _dollar_dollar.GetMaxMonoid() + _t1805 = _dollar_dollar.GetMaxMonoid() } - deconstruct_result1347 := _t1795 - if deconstruct_result1347 != nil { - unwrapped1348 := deconstruct_result1347 - p.pretty_max_monoid(unwrapped1348) + deconstruct_result1352 := _t1805 + if deconstruct_result1352 != nil { + unwrapped1353 := deconstruct_result1352 + p.pretty_max_monoid(unwrapped1353) } else { _dollar_dollar := msg - var _t1796 *pb.SumMonoid + var _t1806 *pb.SumMonoid if hasProtoField(_dollar_dollar, "sum_monoid") { - _t1796 = _dollar_dollar.GetSumMonoid() + _t1806 = _dollar_dollar.GetSumMonoid() } - deconstruct_result1345 := _t1796 - if deconstruct_result1345 != nil { - unwrapped1346 := deconstruct_result1345 - p.pretty_sum_monoid(unwrapped1346) ->>>>>>> origin/main + deconstruct_result1350 := _t1806 + if deconstruct_result1350 != nil { + unwrapped1351 := deconstruct_result1350 + p.pretty_sum_monoid(unwrapped1351) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -5965,13 +3405,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { -<<<<<<< HEAD - fields1316 := msg - _ = fields1316 -======= - fields1354 := msg - _ = fields1354 ->>>>>>> origin/main + fields1359 := msg + _ = fields1359 p.write("(") p.write("or") p.write(")") @@ -5979,34 +3414,19 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { -<<<<<<< HEAD - flat1319 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1319 != nil { - p.write(*flat1319) + flat1362 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1362 != nil { + p.write(*flat1362) return nil } else { _dollar_dollar := msg - fields1317 := _dollar_dollar.GetType() - unwrapped_fields1318 := fields1317 -======= - flat1357 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1357 != nil { - p.write(*flat1357) - return nil - } else { - _dollar_dollar := msg - fields1355 := _dollar_dollar.GetType() - unwrapped_fields1356 := fields1355 ->>>>>>> origin/main + fields1360 := _dollar_dollar.GetType() + unwrapped_fields1361 := fields1360 p.write("(") p.write("min") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_type(unwrapped_fields1318) -======= - p.pretty_type(unwrapped_fields1356) ->>>>>>> origin/main + p.pretty_type(unwrapped_fields1361) p.dedent() p.write(")") } @@ -6014,34 +3434,19 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { -<<<<<<< HEAD - flat1322 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1322 != nil { - p.write(*flat1322) - return nil - } else { - _dollar_dollar := msg - fields1320 := _dollar_dollar.GetType() - unwrapped_fields1321 := fields1320 -======= - flat1360 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) - if flat1360 != nil { - p.write(*flat1360) + flat1365 := p.tryFlat(msg, func() { p.pretty_max_monoid(msg) }) + if flat1365 != nil { + p.write(*flat1365) return nil } else { _dollar_dollar := msg - fields1358 := _dollar_dollar.GetType() - unwrapped_fields1359 := fields1358 ->>>>>>> origin/main + fields1363 := _dollar_dollar.GetType() + unwrapped_fields1364 := fields1363 p.write("(") p.write("max") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_type(unwrapped_fields1321) -======= - p.pretty_type(unwrapped_fields1359) ->>>>>>> origin/main + p.pretty_type(unwrapped_fields1364) p.dedent() p.write(")") } @@ -6049,34 +3454,19 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { -<<<<<<< HEAD - flat1325 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1325 != nil { - p.write(*flat1325) + flat1368 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1368 != nil { + p.write(*flat1368) return nil } else { _dollar_dollar := msg - fields1323 := _dollar_dollar.GetType() - unwrapped_fields1324 := fields1323 -======= - flat1363 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1363 != nil { - p.write(*flat1363) - return nil - } else { - _dollar_dollar := msg - fields1361 := _dollar_dollar.GetType() - unwrapped_fields1362 := fields1361 ->>>>>>> origin/main + fields1366 := _dollar_dollar.GetType() + unwrapped_fields1367 := fields1366 p.write("(") p.write("sum") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_type(unwrapped_fields1324) -======= - p.pretty_type(unwrapped_fields1362) ->>>>>>> origin/main + p.pretty_type(unwrapped_fields1367) p.dedent() p.write(")") } @@ -6084,66 +3474,35 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { -<<<<<<< HEAD - flat1333 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1333 != nil { - p.write(*flat1333) - return nil - } else { - _dollar_dollar := msg - var _t1721 []*pb.Attribute - if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1721 = _dollar_dollar.GetAttrs() - } - fields1326 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1721} - unwrapped_fields1327 := fields1326 -======= - flat1371 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) - if flat1371 != nil { - p.write(*flat1371) + flat1376 := p.tryFlat(msg, func() { p.pretty_monus_def(msg) }) + if flat1376 != nil { + p.write(*flat1376) return nil } else { _dollar_dollar := msg - var _t1797 []*pb.Attribute + var _t1807 []*pb.Attribute if !(len(_dollar_dollar.GetAttrs()) == 0) { - _t1797 = _dollar_dollar.GetAttrs() + _t1807 = _dollar_dollar.GetAttrs() } - fields1364 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1797} - unwrapped_fields1365 := fields1364 ->>>>>>> origin/main + fields1369 := []interface{}{_dollar_dollar.GetMonoid(), _dollar_dollar.GetName(), []interface{}{_dollar_dollar.GetBody(), _dollar_dollar.GetValueArity()}, _t1807} + unwrapped_fields1370 := fields1369 p.write("(") p.write("monus") p.indentSexp() p.newline() -<<<<<<< HEAD - field1328 := unwrapped_fields1327[0].(*pb.Monoid) - p.pretty_monoid(field1328) + field1371 := unwrapped_fields1370[0].(*pb.Monoid) + p.pretty_monoid(field1371) p.newline() - field1329 := unwrapped_fields1327[1].(*pb.RelationId) - p.pretty_relation_id(field1329) + field1372 := unwrapped_fields1370[1].(*pb.RelationId) + p.pretty_relation_id(field1372) p.newline() - field1330 := unwrapped_fields1327[2].([]interface{}) - p.pretty_abstraction_with_arity(field1330) - field1331 := unwrapped_fields1327[3].([]*pb.Attribute) - if field1331 != nil { - p.newline() - opt_val1332 := field1331 - p.pretty_attrs(opt_val1332) -======= - field1366 := unwrapped_fields1365[0].(*pb.Monoid) - p.pretty_monoid(field1366) - p.newline() - field1367 := unwrapped_fields1365[1].(*pb.RelationId) - p.pretty_relation_id(field1367) - p.newline() - field1368 := unwrapped_fields1365[2].([]interface{}) - p.pretty_abstraction_with_arity(field1368) - field1369 := unwrapped_fields1365[3].([]*pb.Attribute) - if field1369 != nil { + field1373 := unwrapped_fields1370[2].([]interface{}) + p.pretty_abstraction_with_arity(field1373) + field1374 := unwrapped_fields1370[3].([]*pb.Attribute) + if field1374 != nil { p.newline() - opt_val1370 := field1369 - p.pretty_attrs(opt_val1370) ->>>>>>> origin/main + opt_val1375 := field1374 + p.pretty_attrs(opt_val1375) } p.dedent() p.write(")") @@ -6152,54 +3511,29 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { -<<<<<<< HEAD - flat1340 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1340 != nil { - p.write(*flat1340) - return nil - } else { - _dollar_dollar := msg - fields1334 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} - unwrapped_fields1335 := fields1334 -======= - flat1378 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) - if flat1378 != nil { - p.write(*flat1378) + flat1383 := p.tryFlat(msg, func() { p.pretty_constraint(msg) }) + if flat1383 != nil { + p.write(*flat1383) return nil } else { _dollar_dollar := msg - fields1372 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} - unwrapped_fields1373 := fields1372 ->>>>>>> origin/main + fields1377 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetFunctionalDependency().GetGuard(), _dollar_dollar.GetFunctionalDependency().GetKeys(), _dollar_dollar.GetFunctionalDependency().GetValues()} + unwrapped_fields1378 := fields1377 p.write("(") p.write("functional_dependency") p.indentSexp() p.newline() -<<<<<<< HEAD - field1336 := unwrapped_fields1335[0].(*pb.RelationId) - p.pretty_relation_id(field1336) - p.newline() - field1337 := unwrapped_fields1335[1].(*pb.Abstraction) - p.pretty_abstraction(field1337) - p.newline() - field1338 := unwrapped_fields1335[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1338) + field1379 := unwrapped_fields1378[0].(*pb.RelationId) + p.pretty_relation_id(field1379) p.newline() - field1339 := unwrapped_fields1335[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1339) -======= - field1374 := unwrapped_fields1373[0].(*pb.RelationId) - p.pretty_relation_id(field1374) + field1380 := unwrapped_fields1378[1].(*pb.Abstraction) + p.pretty_abstraction(field1380) p.newline() - field1375 := unwrapped_fields1373[1].(*pb.Abstraction) - p.pretty_abstraction(field1375) + field1381 := unwrapped_fields1378[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1381) p.newline() - field1376 := unwrapped_fields1373[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1376) - p.newline() - field1377 := unwrapped_fields1373[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1377) ->>>>>>> origin/main + field1382 := unwrapped_fields1378[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1382) p.dedent() p.write(")") } @@ -6207,41 +3541,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { -<<<<<<< HEAD - flat1344 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1344 != nil { - p.write(*flat1344) - return nil - } else { - fields1341 := msg - p.write("(") - p.write("keys") - p.indentSexp() - if !(len(fields1341) == 0) { - p.newline() - for i1343, elem1342 := range fields1341 { - if (i1343 > 0) { - p.newline() - } - p.pretty_var(elem1342) -======= - flat1382 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) - if flat1382 != nil { - p.write(*flat1382) + flat1387 := p.tryFlat(msg, func() { p.pretty_functional_dependency_keys(msg) }) + if flat1387 != nil { + p.write(*flat1387) return nil } else { - fields1379 := msg + fields1384 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1379) == 0) { + if !(len(fields1384) == 0) { p.newline() - for i1381, elem1380 := range fields1379 { - if (i1381 > 0) { + for i1386, elem1385 := range fields1384 { + if (i1386 > 0) { p.newline() } - p.pretty_var(elem1380) ->>>>>>> origin/main + p.pretty_var(elem1385) } } p.dedent() @@ -6251,41 +3566,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { -<<<<<<< HEAD - flat1348 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1348 != nil { - p.write(*flat1348) - return nil - } else { - fields1345 := msg - p.write("(") - p.write("values") - p.indentSexp() - if !(len(fields1345) == 0) { - p.newline() - for i1347, elem1346 := range fields1345 { - if (i1347 > 0) { - p.newline() - } - p.pretty_var(elem1346) -======= - flat1386 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) - if flat1386 != nil { - p.write(*flat1386) + flat1391 := p.tryFlat(msg, func() { p.pretty_functional_dependency_values(msg) }) + if flat1391 != nil { + p.write(*flat1391) return nil } else { - fields1383 := msg + fields1388 := msg p.write("(") p.write("values") p.indentSexp() - if !(len(fields1383) == 0) { + if !(len(fields1388) == 0) { p.newline() - for i1385, elem1384 := range fields1383 { - if (i1385 > 0) { + for i1390, elem1389 := range fields1388 { + if (i1390 > 0) { p.newline() } - p.pretty_var(elem1384) ->>>>>>> origin/main + p.pretty_var(elem1389) } } p.dedent() @@ -6295,97 +3591,50 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { -<<<<<<< HEAD - flat1357 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1357 != nil { - p.write(*flat1357) - return nil - } else { - _dollar_dollar := msg - var _t1722 *pb.EDB - if hasProtoField(_dollar_dollar, "edb") { - _t1722 = _dollar_dollar.GetEdb() - } - deconstruct_result1355 := _t1722 - if deconstruct_result1355 != nil { - unwrapped1356 := deconstruct_result1355 - p.pretty_edb(unwrapped1356) - } else { - _dollar_dollar := msg - var _t1723 *pb.BeTreeRelation - if hasProtoField(_dollar_dollar, "betree_relation") { - _t1723 = _dollar_dollar.GetBetreeRelation() - } - deconstruct_result1353 := _t1723 - if deconstruct_result1353 != nil { - unwrapped1354 := deconstruct_result1353 - p.pretty_betree_relation(unwrapped1354) - } else { - _dollar_dollar := msg - var _t1724 *pb.CSVData - if hasProtoField(_dollar_dollar, "csv_data") { - _t1724 = _dollar_dollar.GetCsvData() - } - deconstruct_result1351 := _t1724 - if deconstruct_result1351 != nil { - unwrapped1352 := deconstruct_result1351 - p.pretty_csv_data(unwrapped1352) - } else { - _dollar_dollar := msg - var _t1725 *pb.IcebergData - if hasProtoField(_dollar_dollar, "iceberg_data") { - _t1725 = _dollar_dollar.GetIcebergData() - } - deconstruct_result1349 := _t1725 - if deconstruct_result1349 != nil { - unwrapped1350 := deconstruct_result1349 - p.pretty_iceberg_data(unwrapped1350) -======= - flat1395 := p.tryFlat(msg, func() { p.pretty_data(msg) }) - if flat1395 != nil { - p.write(*flat1395) + flat1400 := p.tryFlat(msg, func() { p.pretty_data(msg) }) + if flat1400 != nil { + p.write(*flat1400) return nil } else { _dollar_dollar := msg - var _t1798 *pb.EDB + var _t1808 *pb.EDB if hasProtoField(_dollar_dollar, "edb") { - _t1798 = _dollar_dollar.GetEdb() + _t1808 = _dollar_dollar.GetEdb() } - deconstruct_result1393 := _t1798 - if deconstruct_result1393 != nil { - unwrapped1394 := deconstruct_result1393 - p.pretty_edb(unwrapped1394) + deconstruct_result1398 := _t1808 + if deconstruct_result1398 != nil { + unwrapped1399 := deconstruct_result1398 + p.pretty_edb(unwrapped1399) } else { _dollar_dollar := msg - var _t1799 *pb.BeTreeRelation + var _t1809 *pb.BeTreeRelation if hasProtoField(_dollar_dollar, "betree_relation") { - _t1799 = _dollar_dollar.GetBetreeRelation() + _t1809 = _dollar_dollar.GetBetreeRelation() } - deconstruct_result1391 := _t1799 - if deconstruct_result1391 != nil { - unwrapped1392 := deconstruct_result1391 - p.pretty_betree_relation(unwrapped1392) + deconstruct_result1396 := _t1809 + if deconstruct_result1396 != nil { + unwrapped1397 := deconstruct_result1396 + p.pretty_betree_relation(unwrapped1397) } else { _dollar_dollar := msg - var _t1800 *pb.CSVData + var _t1810 *pb.CSVData if hasProtoField(_dollar_dollar, "csv_data") { - _t1800 = _dollar_dollar.GetCsvData() + _t1810 = _dollar_dollar.GetCsvData() } - deconstruct_result1389 := _t1800 - if deconstruct_result1389 != nil { - unwrapped1390 := deconstruct_result1389 - p.pretty_csv_data(unwrapped1390) + deconstruct_result1394 := _t1810 + if deconstruct_result1394 != nil { + unwrapped1395 := deconstruct_result1394 + p.pretty_csv_data(unwrapped1395) } else { _dollar_dollar := msg - var _t1801 *pb.IcebergData + var _t1811 *pb.IcebergData if hasProtoField(_dollar_dollar, "iceberg_data") { - _t1801 = _dollar_dollar.GetIcebergData() + _t1811 = _dollar_dollar.GetIcebergData() } - deconstruct_result1387 := _t1801 - if deconstruct_result1387 != nil { - unwrapped1388 := deconstruct_result1387 - p.pretty_iceberg_data(unwrapped1388) ->>>>>>> origin/main + deconstruct_result1392 := _t1811 + if deconstruct_result1392 != nil { + unwrapped1393 := deconstruct_result1392 + p.pretty_iceberg_data(unwrapped1393) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -6397,48 +3646,26 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { -<<<<<<< HEAD - flat1363 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) - if flat1363 != nil { - p.write(*flat1363) - return nil - } else { - _dollar_dollar := msg - fields1358 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} - unwrapped_fields1359 := fields1358 -======= - flat1401 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) - if flat1401 != nil { - p.write(*flat1401) + flat1406 := p.tryFlat(msg, func() { p.pretty_edb(msg) }) + if flat1406 != nil { + p.write(*flat1406) return nil } else { _dollar_dollar := msg - fields1396 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} - unwrapped_fields1397 := fields1396 ->>>>>>> origin/main + fields1401 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} + unwrapped_fields1402 := fields1401 p.write("(") p.write("edb") p.indentSexp() p.newline() -<<<<<<< HEAD - field1360 := unwrapped_fields1359[0].(*pb.RelationId) - p.pretty_relation_id(field1360) - p.newline() - field1361 := unwrapped_fields1359[1].([]string) - p.pretty_edb_path(field1361) + field1403 := unwrapped_fields1402[0].(*pb.RelationId) + p.pretty_relation_id(field1403) p.newline() - field1362 := unwrapped_fields1359[2].([]*pb.Type) - p.pretty_edb_types(field1362) -======= - field1398 := unwrapped_fields1397[0].(*pb.RelationId) - p.pretty_relation_id(field1398) + field1404 := unwrapped_fields1402[1].([]string) + p.pretty_edb_path(field1404) p.newline() - field1399 := unwrapped_fields1397[1].([]string) - p.pretty_edb_path(field1399) - p.newline() - field1400 := unwrapped_fields1397[2].([]*pb.Type) - p.pretty_edb_types(field1400) ->>>>>>> origin/main + field1405 := unwrapped_fields1402[2].([]*pb.Type) + p.pretty_edb_types(field1405) p.dedent() p.write(")") } @@ -6446,35 +3673,19 @@ func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { } func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { -<<<<<<< HEAD - flat1367 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) - if flat1367 != nil { - p.write(*flat1367) - return nil - } else { - fields1364 := msg - p.write("[") - p.indent() - for i1366, elem1365 := range fields1364 { - if (i1366 > 0) { - p.newline() - } - p.write(p.formatStringValue(elem1365)) -======= - flat1405 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) - if flat1405 != nil { - p.write(*flat1405) + flat1410 := p.tryFlat(msg, func() { p.pretty_edb_path(msg) }) + if flat1410 != nil { + p.write(*flat1410) return nil } else { - fields1402 := msg + fields1407 := msg p.write("[") p.indent() - for i1404, elem1403 := range fields1402 { - if (i1404 > 0) { + for i1409, elem1408 := range fields1407 { + if (i1409 > 0) { p.newline() } - p.write(p.formatStringValue(elem1403)) ->>>>>>> origin/main + p.write(p.formatStringValue(elem1408)) } p.dedent() p.write("]") @@ -6483,35 +3694,19 @@ func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { -<<<<<<< HEAD - flat1371 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) - if flat1371 != nil { - p.write(*flat1371) - return nil - } else { - fields1368 := msg - p.write("[") - p.indent() - for i1370, elem1369 := range fields1368 { - if (i1370 > 0) { - p.newline() - } - p.pretty_type(elem1369) -======= - flat1409 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) - if flat1409 != nil { - p.write(*flat1409) + flat1414 := p.tryFlat(msg, func() { p.pretty_edb_types(msg) }) + if flat1414 != nil { + p.write(*flat1414) return nil } else { - fields1406 := msg + fields1411 := msg p.write("[") p.indent() - for i1408, elem1407 := range fields1406 { - if (i1408 > 0) { + for i1413, elem1412 := range fields1411 { + if (i1413 > 0) { p.newline() } - p.pretty_type(elem1407) ->>>>>>> origin/main + p.pretty_type(elem1412) } p.dedent() p.write("]") @@ -6520,42 +3715,23 @@ func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { -<<<<<<< HEAD - flat1376 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1376 != nil { - p.write(*flat1376) - return nil - } else { - _dollar_dollar := msg - fields1372 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} - unwrapped_fields1373 := fields1372 -======= - flat1414 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) - if flat1414 != nil { - p.write(*flat1414) + flat1419 := p.tryFlat(msg, func() { p.pretty_betree_relation(msg) }) + if flat1419 != nil { + p.write(*flat1419) return nil } else { _dollar_dollar := msg - fields1410 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} - unwrapped_fields1411 := fields1410 ->>>>>>> origin/main + fields1415 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} + unwrapped_fields1416 := fields1415 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() -<<<<<<< HEAD - field1374 := unwrapped_fields1373[0].(*pb.RelationId) - p.pretty_relation_id(field1374) - p.newline() - field1375 := unwrapped_fields1373[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1375) -======= - field1412 := unwrapped_fields1411[0].(*pb.RelationId) - p.pretty_relation_id(field1412) + field1417 := unwrapped_fields1416[0].(*pb.RelationId) + p.pretty_relation_id(field1417) p.newline() - field1413 := unwrapped_fields1411[1].(*pb.BeTreeInfo) - p.pretty_betree_info(field1413) ->>>>>>> origin/main + field1418 := unwrapped_fields1416[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1418) p.dedent() p.write(")") } @@ -6563,50 +3739,27 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { -<<<<<<< HEAD - flat1382 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1382 != nil { - p.write(*flat1382) - return nil - } else { - _dollar_dollar := msg - _t1726 := p.deconstruct_betree_info_config(_dollar_dollar) - fields1377 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1726} - unwrapped_fields1378 := fields1377 -======= - flat1420 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) - if flat1420 != nil { - p.write(*flat1420) + flat1425 := p.tryFlat(msg, func() { p.pretty_betree_info(msg) }) + if flat1425 != nil { + p.write(*flat1425) return nil } else { _dollar_dollar := msg - _t1802 := p.deconstruct_betree_info_config(_dollar_dollar) - fields1415 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1802} - unwrapped_fields1416 := fields1415 ->>>>>>> origin/main + _t1812 := p.deconstruct_betree_info_config(_dollar_dollar) + fields1420 := []interface{}{_dollar_dollar.GetKeyTypes(), _dollar_dollar.GetValueTypes(), _t1812} + unwrapped_fields1421 := fields1420 p.write("(") p.write("betree_info") p.indentSexp() p.newline() -<<<<<<< HEAD - field1379 := unwrapped_fields1378[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1379) - p.newline() - field1380 := unwrapped_fields1378[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1380) + field1422 := unwrapped_fields1421[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1422) p.newline() - field1381 := unwrapped_fields1378[2].([][]interface{}) - p.pretty_config_dict(field1381) -======= - field1417 := unwrapped_fields1416[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1417) + field1423 := unwrapped_fields1421[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1423) p.newline() - field1418 := unwrapped_fields1416[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1418) - p.newline() - field1419 := unwrapped_fields1416[2].([][]interface{}) - p.pretty_config_dict(field1419) ->>>>>>> origin/main + field1424 := unwrapped_fields1421[2].([][]interface{}) + p.pretty_config_dict(field1424) p.dedent() p.write(")") } @@ -6614,41 +3767,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { -<<<<<<< HEAD - flat1386 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1386 != nil { - p.write(*flat1386) - return nil - } else { - fields1383 := msg - p.write("(") - p.write("key_types") - p.indentSexp() - if !(len(fields1383) == 0) { - p.newline() - for i1385, elem1384 := range fields1383 { - if (i1385 > 0) { - p.newline() - } - p.pretty_type(elem1384) -======= - flat1424 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) - if flat1424 != nil { - p.write(*flat1424) + flat1429 := p.tryFlat(msg, func() { p.pretty_betree_info_key_types(msg) }) + if flat1429 != nil { + p.write(*flat1429) return nil } else { - fields1421 := msg + fields1426 := msg p.write("(") p.write("key_types") p.indentSexp() - if !(len(fields1421) == 0) { + if !(len(fields1426) == 0) { p.newline() - for i1423, elem1422 := range fields1421 { - if (i1423 > 0) { + for i1428, elem1427 := range fields1426 { + if (i1428 > 0) { p.newline() } - p.pretty_type(elem1422) ->>>>>>> origin/main + p.pretty_type(elem1427) } } p.dedent() @@ -6658,41 +3792,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{} { -<<<<<<< HEAD - flat1390 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1390 != nil { - p.write(*flat1390) - return nil - } else { - fields1387 := msg - p.write("(") - p.write("value_types") - p.indentSexp() - if !(len(fields1387) == 0) { - p.newline() - for i1389, elem1388 := range fields1387 { - if (i1389 > 0) { - p.newline() - } - p.pretty_type(elem1388) -======= - flat1428 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) - if flat1428 != nil { - p.write(*flat1428) + flat1433 := p.tryFlat(msg, func() { p.pretty_betree_info_value_types(msg) }) + if flat1433 != nil { + p.write(*flat1433) return nil } else { - fields1425 := msg + fields1430 := msg p.write("(") p.write("value_types") p.indentSexp() - if !(len(fields1425) == 0) { + if !(len(fields1430) == 0) { p.newline() - for i1427, elem1426 := range fields1425 { - if (i1427 > 0) { + for i1432, elem1431 := range fields1430 { + if (i1432 > 0) { p.newline() } - p.pretty_type(elem1426) ->>>>>>> origin/main + p.pretty_type(elem1431) } } p.dedent() @@ -6702,65 +3817,40 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { -<<<<<<< HEAD - flat1397 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1397 != nil { - p.write(*flat1397) - return nil - } else { - _dollar_dollar := msg - fields1391 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _dollar_dollar.GetAsof()} - unwrapped_fields1392 := fields1391 -======= - flat1438 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) - if flat1438 != nil { - p.write(*flat1438) + flat1443 := p.tryFlat(msg, func() { p.pretty_csv_data(msg) }) + if flat1443 != nil { + p.write(*flat1443) return nil } else { _dollar_dollar := msg - _t1803 := p.deconstruct_csv_data_columns_optional(_dollar_dollar) - _t1804 := p.deconstruct_csv_data_relations_optional(_dollar_dollar) - fields1429 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _t1803, _t1804, _dollar_dollar.GetAsof()} - unwrapped_fields1430 := fields1429 ->>>>>>> origin/main + _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 p.write("(") p.write("csv_data") p.indentSexp() p.newline() -<<<<<<< HEAD - field1393 := unwrapped_fields1392[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1393) - p.newline() - field1394 := unwrapped_fields1392[1].(*pb.CSVConfig) - p.pretty_csv_config(field1394) - p.newline() - field1395 := unwrapped_fields1392[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1395) + field1436 := unwrapped_fields1435[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1436) p.newline() - field1396 := unwrapped_fields1392[3].(string) - p.pretty_csv_asof(field1396) -======= - field1431 := unwrapped_fields1430[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1431) - p.newline() - field1432 := unwrapped_fields1430[1].(*pb.CSVConfig) - p.pretty_csv_config(field1432) - field1433 := unwrapped_fields1430[2].([]*pb.GNFColumn) - if field1433 != nil { + field1437 := unwrapped_fields1435[1].(*pb.CSVConfig) + p.pretty_csv_config(field1437) + field1438 := unwrapped_fields1435[2].([]*pb.GNFColumn) + if field1438 != nil { p.newline() - opt_val1434 := field1433 - p.pretty_gnf_columns(opt_val1434) + opt_val1439 := field1438 + p.pretty_gnf_columns(opt_val1439) } - field1435 := unwrapped_fields1430[3].(*pb.TargetRelations) - if field1435 != nil { + field1440 := unwrapped_fields1435[3].(*pb.TargetRelations) + if field1440 != nil { p.newline() - opt_val1436 := field1435 - p.pretty_target_relations(opt_val1436) + opt_val1441 := field1440 + p.pretty_target_relations(opt_val1441) } p.newline() - field1437 := unwrapped_fields1430[4].(string) - p.pretty_csv_asof(field1437) ->>>>>>> origin/main + field1442 := unwrapped_fields1435[4].(string) + p.pretty_csv_asof(field1442) p.dedent() p.write(")") } @@ -6768,69 +3858,36 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { -<<<<<<< HEAD - flat1404 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1404 != nil { - p.write(*flat1404) - return nil - } else { - _dollar_dollar := msg - var _t1727 []string - if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1727 = _dollar_dollar.GetPaths() - } - var _t1728 *string - if string(_dollar_dollar.GetInlineData()) != "" { - _t1728 = ptr(string(_dollar_dollar.GetInlineData())) - } - fields1398 := []interface{}{_t1727, _t1728} - unwrapped_fields1399 := fields1398 - p.write("(") - p.write("csv_locator") - p.indentSexp() - field1400 := unwrapped_fields1399[0].([]string) - if field1400 != nil { - p.newline() - opt_val1401 := field1400 - p.pretty_csv_locator_paths(opt_val1401) - } - field1402 := unwrapped_fields1399[1].(*string) - if field1402 != nil { - p.newline() - opt_val1403 := *field1402 - p.pretty_csv_locator_inline_data(opt_val1403) -======= - flat1445 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) - if flat1445 != nil { - p.write(*flat1445) + flat1450 := p.tryFlat(msg, func() { p.pretty_csvlocator(msg) }) + if flat1450 != nil { + p.write(*flat1450) return nil } else { _dollar_dollar := msg - var _t1805 []string + var _t1815 []string if !(len(_dollar_dollar.GetPaths()) == 0) { - _t1805 = _dollar_dollar.GetPaths() + _t1815 = _dollar_dollar.GetPaths() } - var _t1806 *string + var _t1816 *string if string(_dollar_dollar.GetInlineData()) != "" { - _t1806 = ptr(string(_dollar_dollar.GetInlineData())) + _t1816 = ptr(string(_dollar_dollar.GetInlineData())) } - fields1439 := []interface{}{_t1805, _t1806} - unwrapped_fields1440 := fields1439 + fields1444 := []interface{}{_t1815, _t1816} + unwrapped_fields1445 := fields1444 p.write("(") p.write("csv_locator") p.indentSexp() - field1441 := unwrapped_fields1440[0].([]string) - if field1441 != nil { + field1446 := unwrapped_fields1445[0].([]string) + if field1446 != nil { p.newline() - opt_val1442 := field1441 - p.pretty_csv_locator_paths(opt_val1442) + opt_val1447 := field1446 + p.pretty_csv_locator_paths(opt_val1447) } - field1443 := unwrapped_fields1440[1].(*string) - if field1443 != nil { + field1448 := unwrapped_fields1445[1].(*string) + if field1448 != nil { p.newline() - opt_val1444 := *field1443 - p.pretty_csv_locator_inline_data(opt_val1444) ->>>>>>> origin/main + opt_val1449 := *field1448 + p.pretty_csv_locator_inline_data(opt_val1449) } p.dedent() p.write(")") @@ -6839,41 +3896,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { -<<<<<<< HEAD - flat1408 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1408 != nil { - p.write(*flat1408) - return nil - } else { - fields1405 := msg - p.write("(") - p.write("paths") - p.indentSexp() - if !(len(fields1405) == 0) { - p.newline() - for i1407, elem1406 := range fields1405 { - if (i1407 > 0) { - p.newline() - } - p.write(p.formatStringValue(elem1406)) -======= - flat1449 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) - if flat1449 != nil { - p.write(*flat1449) + flat1454 := p.tryFlat(msg, func() { p.pretty_csv_locator_paths(msg) }) + if flat1454 != nil { + p.write(*flat1454) return nil } else { - fields1446 := msg + fields1451 := msg p.write("(") p.write("paths") p.indentSexp() - if !(len(fields1446) == 0) { + if !(len(fields1451) == 0) { p.newline() - for i1448, elem1447 := range fields1446 { - if (i1448 > 0) { + for i1453, elem1452 := range fields1451 { + if (i1453 > 0) { p.newline() } - p.write(p.formatStringValue(elem1447)) ->>>>>>> origin/main + p.write(p.formatStringValue(elem1452)) } } p.dedent() @@ -6883,30 +3921,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { -<<<<<<< HEAD - flat1410 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1410 != nil { - p.write(*flat1410) - return nil - } else { - fields1409 := msg -======= - flat1451 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) - if flat1451 != nil { - p.write(*flat1451) + flat1456 := p.tryFlat(msg, func() { p.pretty_csv_locator_inline_data(msg) }) + if flat1456 != nil { + p.write(*flat1456) return nil } else { - fields1450 := msg ->>>>>>> origin/main + fields1455 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() -<<<<<<< HEAD - p.write(p.formatStringValue(fields1409)) -======= - p.write(p.formatStringValue(fields1450)) ->>>>>>> origin/main + p.write(p.formatStringValue(fields1455)) p.dedent() p.write(")") } @@ -6914,50 +3939,27 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { -<<<<<<< HEAD - flat1416 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1416 != nil { - p.write(*flat1416) - return nil - } else { - _dollar_dollar := msg - _t1729 := p.deconstruct_csv_config(_dollar_dollar) - _t1730 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1411 := []interface{}{_t1729, _t1730} - unwrapped_fields1412 := fields1411 -======= - flat1457 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) - if flat1457 != nil { - p.write(*flat1457) + flat1462 := p.tryFlat(msg, func() { p.pretty_csv_config(msg) }) + if flat1462 != nil { + p.write(*flat1462) return nil } else { _dollar_dollar := msg - _t1807 := p.deconstruct_csv_config(_dollar_dollar) - _t1808 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1452 := []interface{}{_t1807, _t1808} - unwrapped_fields1453 := fields1452 ->>>>>>> origin/main + _t1817 := p.deconstruct_csv_config(_dollar_dollar) + _t1818 := p.deconstruct_csv_storage_integration_optional(_dollar_dollar) + fields1457 := []interface{}{_t1817, _t1818} + unwrapped_fields1458 := fields1457 p.write("(") p.write("csv_config") p.indentSexp() p.newline() -<<<<<<< HEAD - field1413 := unwrapped_fields1412[0].([][]interface{}) - p.pretty_config_dict(field1413) - field1414 := unwrapped_fields1412[1].([][]interface{}) - if field1414 != nil { + field1459 := unwrapped_fields1458[0].([][]interface{}) + p.pretty_config_dict(field1459) + field1460 := unwrapped_fields1458[1].([][]interface{}) + if field1460 != nil { p.newline() - opt_val1415 := field1414 - p.pretty__storage_integration(opt_val1415) -======= - field1454 := unwrapped_fields1453[0].([][]interface{}) - p.pretty_config_dict(field1454) - field1455 := unwrapped_fields1453[1].([][]interface{}) - if field1455 != nil { - p.newline() - opt_val1456 := field1455 - p.pretty__storage_integration(opt_val1456) ->>>>>>> origin/main + opt_val1461 := field1460 + p.pretty__storage_integration(opt_val1461) } p.dedent() p.write(")") @@ -6966,30 +3968,17 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interface{} { -<<<<<<< HEAD - flat1418 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) - if flat1418 != nil { - p.write(*flat1418) - return nil - } else { - fields1417 := msg -======= - flat1459 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) - if flat1459 != nil { - p.write(*flat1459) + flat1464 := p.tryFlat(msg, func() { p.pretty__storage_integration(msg) }) + if flat1464 != nil { + p.write(*flat1464) return nil } else { - fields1458 := msg ->>>>>>> origin/main + fields1463 := msg p.write("(") p.write("storage_integration") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_config_dict(fields1417) -======= - p.pretty_config_dict(fields1458) ->>>>>>> origin/main + p.pretty_config_dict(fields1463) p.dedent() p.write(")") } @@ -6997,41 +3986,22 @@ func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interfa } func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { -<<<<<<< HEAD - flat1422 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) - if flat1422 != nil { - p.write(*flat1422) - return nil - } else { - fields1419 := msg - p.write("(") - p.write("columns") - p.indentSexp() - if !(len(fields1419) == 0) { - p.newline() - for i1421, elem1420 := range fields1419 { - if (i1421 > 0) { - p.newline() - } - p.pretty_gnf_column(elem1420) -======= - flat1463 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) - if flat1463 != nil { - p.write(*flat1463) + flat1468 := p.tryFlat(msg, func() { p.pretty_gnf_columns(msg) }) + if flat1468 != nil { + p.write(*flat1468) return nil } else { - fields1460 := msg + fields1465 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1460) == 0) { + if !(len(fields1465) == 0) { p.newline() - for i1462, elem1461 := range fields1460 { - if (i1462 > 0) { + for i1467, elem1466 := range fields1465 { + if (i1467 > 0) { p.newline() } - p.pretty_gnf_column(elem1461) ->>>>>>> origin/main + p.pretty_gnf_column(elem1466) } } p.dedent() @@ -7041,72 +4011,38 @@ func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { -<<<<<<< HEAD - flat1431 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) - if flat1431 != nil { - p.write(*flat1431) - return nil - } else { - _dollar_dollar := msg - var _t1731 *pb.RelationId - if hasProtoField(_dollar_dollar, "target_id") { - _t1731 = _dollar_dollar.GetTargetId() - } - fields1423 := []interface{}{_dollar_dollar.GetColumnPath(), _t1731, _dollar_dollar.GetTypes()} - unwrapped_fields1424 := fields1423 -======= - flat1472 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) - if flat1472 != nil { - p.write(*flat1472) + flat1477 := p.tryFlat(msg, func() { p.pretty_gnf_column(msg) }) + if flat1477 != nil { + p.write(*flat1477) return nil } else { _dollar_dollar := msg - var _t1809 *pb.RelationId + var _t1819 *pb.RelationId if hasProtoField(_dollar_dollar, "target_id") { - _t1809 = _dollar_dollar.GetTargetId() + _t1819 = _dollar_dollar.GetTargetId() } - fields1464 := []interface{}{_dollar_dollar.GetColumnPath(), _t1809, _dollar_dollar.GetTypes()} - unwrapped_fields1465 := fields1464 ->>>>>>> origin/main + fields1469 := []interface{}{_dollar_dollar.GetColumnPath(), _t1819, _dollar_dollar.GetTypes()} + unwrapped_fields1470 := fields1469 p.write("(") p.write("column") p.indentSexp() p.newline() -<<<<<<< HEAD - field1425 := unwrapped_fields1424[0].([]string) - p.pretty_gnf_column_path(field1425) - field1426 := unwrapped_fields1424[1].(*pb.RelationId) - if field1426 != nil { - p.newline() - opt_val1427 := field1426 - p.pretty_relation_id(opt_val1427) - } - p.newline() - p.write("[") - field1428 := unwrapped_fields1424[2].([]*pb.Type) - for i1430, elem1429 := range field1428 { - if (i1430 > 0) { - p.newline() - } - p.pretty_type(elem1429) -======= - field1466 := unwrapped_fields1465[0].([]string) - p.pretty_gnf_column_path(field1466) - field1467 := unwrapped_fields1465[1].(*pb.RelationId) - if field1467 != nil { + field1471 := unwrapped_fields1470[0].([]string) + p.pretty_gnf_column_path(field1471) + field1472 := unwrapped_fields1470[1].(*pb.RelationId) + if field1472 != nil { p.newline() - opt_val1468 := field1467 - p.pretty_relation_id(opt_val1468) + opt_val1473 := field1472 + p.pretty_relation_id(opt_val1473) } p.newline() p.write("[") - field1469 := unwrapped_fields1465[2].([]*pb.Type) - for i1471, elem1470 := range field1469 { - if (i1471 > 0) { + field1474 := unwrapped_fields1470[2].([]*pb.Type) + for i1476, elem1475 := range field1474 { + if (i1476 > 0) { p.newline() } - p.pretty_type(elem1470) ->>>>>>> origin/main + p.pretty_type(elem1475) } p.write("]") p.dedent() @@ -7116,69 +4052,36 @@ func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { -<<<<<<< HEAD - flat1438 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) - if flat1438 != nil { - p.write(*flat1438) - return nil - } else { - _dollar_dollar := msg - var _t1732 *string - if int64(len(_dollar_dollar)) == 1 { - _t1732 = ptr(_dollar_dollar[0]) - } - deconstruct_result1436 := _t1732 - if deconstruct_result1436 != nil { - unwrapped1437 := *deconstruct_result1436 - p.write(p.formatStringValue(unwrapped1437)) - } else { - _dollar_dollar := msg - var _t1733 []string - if int64(len(_dollar_dollar)) != 1 { - _t1733 = _dollar_dollar - } - deconstruct_result1432 := _t1733 - if deconstruct_result1432 != nil { - unwrapped1433 := deconstruct_result1432 - p.write("[") - p.indent() - for i1435, elem1434 := range unwrapped1433 { - if (i1435 > 0) { - p.newline() - } - p.write(p.formatStringValue(elem1434)) -======= - flat1479 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) - if flat1479 != nil { - p.write(*flat1479) + flat1484 := p.tryFlat(msg, func() { p.pretty_gnf_column_path(msg) }) + if flat1484 != nil { + p.write(*flat1484) return nil } else { _dollar_dollar := msg - var _t1810 *string + var _t1820 *string if int64(len(_dollar_dollar)) == 1 { - _t1810 = ptr(_dollar_dollar[0]) + _t1820 = ptr(_dollar_dollar[0]) } - deconstruct_result1477 := _t1810 - if deconstruct_result1477 != nil { - unwrapped1478 := *deconstruct_result1477 - p.write(p.formatStringValue(unwrapped1478)) + deconstruct_result1482 := _t1820 + if deconstruct_result1482 != nil { + unwrapped1483 := *deconstruct_result1482 + p.write(p.formatStringValue(unwrapped1483)) } else { _dollar_dollar := msg - var _t1811 []string + var _t1821 []string if int64(len(_dollar_dollar)) != 1 { - _t1811 = _dollar_dollar + _t1821 = _dollar_dollar } - deconstruct_result1473 := _t1811 - if deconstruct_result1473 != nil { - unwrapped1474 := deconstruct_result1473 + deconstruct_result1478 := _t1821 + if deconstruct_result1478 != nil { + unwrapped1479 := deconstruct_result1478 p.write("[") p.indent() - for i1476, elem1475 := range unwrapped1474 { - if (i1476 > 0) { + for i1481, elem1480 := range unwrapped1479 { + if (i1481 > 0) { p.newline() } - p.write(p.formatStringValue(elem1475)) ->>>>>>> origin/main + p.write(p.formatStringValue(elem1480)) } p.dedent() p.write("]") @@ -7190,33 +4093,24 @@ func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { return nil } -<<<<<<< HEAD -func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1440 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1440 != nil { - p.write(*flat1440) - return nil - } else { - fields1439 := msg -======= func (p *PrettyPrinter) pretty_target_relations(msg *pb.TargetRelations) interface{} { - flat1484 := p.tryFlat(msg, func() { p.pretty_target_relations(msg) }) - if flat1484 != nil { - p.write(*flat1484) + flat1489 := p.tryFlat(msg, func() { p.pretty_target_relations(msg) }) + if flat1489 != nil { + p.write(*flat1489) return nil } else { _dollar_dollar := msg - fields1480 := []interface{}{_dollar_dollar.GetKeys(), _dollar_dollar} - unwrapped_fields1481 := fields1480 + fields1485 := []interface{}{_dollar_dollar.GetKeys(), _dollar_dollar} + unwrapped_fields1486 := fields1485 p.write("(") p.write("relations") p.indentSexp() p.newline() - field1482 := unwrapped_fields1481[0].([]*pb.NamedColumn) - p.pretty_relation_keys(field1482) + field1487 := unwrapped_fields1486[0].([]*pb.NamedColumn) + p.pretty_relation_keys(field1487) p.newline() - field1483 := unwrapped_fields1481[1].(*pb.TargetRelations) - p.pretty_relation_body(field1483) + field1488 := unwrapped_fields1486[1].(*pb.TargetRelations) + p.pretty_relation_body(field1488) p.dedent() p.write(")") } @@ -7224,22 +4118,22 @@ func (p *PrettyPrinter) pretty_target_relations(msg *pb.TargetRelations) interfa } func (p *PrettyPrinter) pretty_relation_keys(msg []*pb.NamedColumn) interface{} { - flat1488 := p.tryFlat(msg, func() { p.pretty_relation_keys(msg) }) - if flat1488 != nil { - p.write(*flat1488) + flat1493 := p.tryFlat(msg, func() { p.pretty_relation_keys(msg) }) + if flat1493 != nil { + p.write(*flat1493) return nil } else { - fields1485 := msg + fields1490 := msg p.write("(") p.write("keys") p.indentSexp() - if !(len(fields1485) == 0) { + if !(len(fields1490) == 0) { p.newline() - for i1487, elem1486 := range fields1485 { - if (i1487 > 0) { + for i1492, elem1491 := range fields1490 { + if (i1492 > 0) { p.newline() } - p.pretty_named_column(elem1486) + p.pretty_named_column(elem1491) } } p.dedent() @@ -7249,23 +4143,23 @@ func (p *PrettyPrinter) pretty_relation_keys(msg []*pb.NamedColumn) interface{} } func (p *PrettyPrinter) pretty_named_column(msg *pb.NamedColumn) interface{} { - flat1493 := p.tryFlat(msg, func() { p.pretty_named_column(msg) }) - if flat1493 != nil { - p.write(*flat1493) + flat1498 := p.tryFlat(msg, func() { p.pretty_named_column(msg) }) + if flat1498 != nil { + p.write(*flat1498) return nil } else { _dollar_dollar := msg - fields1489 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetType()} - unwrapped_fields1490 := fields1489 + fields1494 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetType()} + unwrapped_fields1495 := fields1494 p.write("(") p.write("column") p.indentSexp() p.newline() - field1491 := unwrapped_fields1490[0].(string) - p.write(p.formatStringValue(field1491)) + field1496 := unwrapped_fields1495[0].(string) + p.write(p.formatStringValue(field1496)) p.newline() - field1492 := unwrapped_fields1490[1].(*pb.Type) - p.pretty_type(field1492) + field1497 := unwrapped_fields1495[1].(*pb.Type) + p.pretty_type(field1497) p.dedent() p.write(")") } @@ -7273,34 +4167,34 @@ func (p *PrettyPrinter) pretty_named_column(msg *pb.NamedColumn) interface{} { } func (p *PrettyPrinter) pretty_relation_body(msg *pb.TargetRelations) interface{} { - flat1500 := p.tryFlat(msg, func() { p.pretty_relation_body(msg) }) - if flat1500 != nil { - p.write(*flat1500) + flat1505 := p.tryFlat(msg, func() { p.pretty_relation_body(msg) }) + if flat1505 != nil { + p.write(*flat1505) return nil } else { _dollar_dollar := msg - var _t1812 []*pb.TargetRelation + var _t1822 []*pb.TargetRelation if hasProtoField(_dollar_dollar, "plain") { - _t1812 = _dollar_dollar.GetPlain().GetTargets() + _t1822 = _dollar_dollar.GetPlain().GetTargets() } - deconstruct_result1498 := _t1812 - if deconstruct_result1498 != nil { - unwrapped1499 := deconstruct_result1498 - p.pretty_non_cdc_relations(unwrapped1499) + deconstruct_result1503 := _t1822 + if deconstruct_result1503 != nil { + unwrapped1504 := deconstruct_result1503 + p.pretty_non_cdc_relations(unwrapped1504) } else { _dollar_dollar := msg - var _t1813 []interface{} + var _t1823 []interface{} if hasProtoField(_dollar_dollar, "cdc") { - _t1813 = []interface{}{_dollar_dollar.GetCdc().GetInserts(), _dollar_dollar.GetCdc().GetDeletes()} + _t1823 = []interface{}{_dollar_dollar.GetCdc().GetInserts(), _dollar_dollar.GetCdc().GetDeletes()} } - deconstruct_result1494 := _t1813 - if deconstruct_result1494 != nil { - unwrapped1495 := deconstruct_result1494 - field1496 := unwrapped1495[0].([]*pb.TargetRelation) - p.pretty_cdc_inserts(field1496) + deconstruct_result1499 := _t1823 + if deconstruct_result1499 != nil { + unwrapped1500 := deconstruct_result1499 + field1501 := unwrapped1500[0].([]*pb.TargetRelation) + p.pretty_cdc_inserts(field1501) p.write(" ") - field1497 := unwrapped1495[1].([]*pb.TargetRelation) - p.pretty_cdc_deletes(field1497) + field1502 := unwrapped1500[1].([]*pb.TargetRelation) + p.pretty_cdc_deletes(field1502) } else { panic(ParseError{msg: "No matching rule for relation_body"}) } @@ -7310,45 +4204,45 @@ func (p *PrettyPrinter) pretty_relation_body(msg *pb.TargetRelations) interface{ } func (p *PrettyPrinter) pretty_non_cdc_relations(msg []*pb.TargetRelation) interface{} { - flat1504 := p.tryFlat(msg, func() { p.pretty_non_cdc_relations(msg) }) - if flat1504 != nil { - p.write(*flat1504) + flat1509 := p.tryFlat(msg, func() { p.pretty_non_cdc_relations(msg) }) + if flat1509 != nil { + p.write(*flat1509) return nil } else { - fields1501 := msg - for i1503, elem1502 := range fields1501 { - if (i1503 > 0) { + fields1506 := msg + for i1508, elem1507 := range fields1506 { + if (i1508 > 0) { p.newline() } - p.pretty_target_relation(elem1502) + p.pretty_target_relation(elem1507) } } return nil } func (p *PrettyPrinter) pretty_target_relation(msg *pb.TargetRelation) interface{} { - flat1511 := p.tryFlat(msg, func() { p.pretty_target_relation(msg) }) - if flat1511 != nil { - p.write(*flat1511) + flat1516 := p.tryFlat(msg, func() { p.pretty_target_relation(msg) }) + if flat1516 != nil { + p.write(*flat1516) return nil } else { _dollar_dollar := msg - fields1505 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetValues()} - unwrapped_fields1506 := fields1505 + fields1510 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetValues()} + unwrapped_fields1511 := fields1510 p.write("(") p.write("relation") p.indentSexp() p.newline() - field1507 := unwrapped_fields1506[0].(*pb.RelationId) - p.pretty_relation_id(field1507) - field1508 := unwrapped_fields1506[1].([]*pb.NamedColumn) - if !(len(field1508) == 0) { + field1512 := unwrapped_fields1511[0].(*pb.RelationId) + p.pretty_relation_id(field1512) + field1513 := unwrapped_fields1511[1].([]*pb.NamedColumn) + if !(len(field1513) == 0) { p.newline() - for i1510, elem1509 := range field1508 { - if (i1510 > 0) { + for i1515, elem1514 := range field1513 { + if (i1515 > 0) { p.newline() } - p.pretty_named_column(elem1509) + p.pretty_named_column(elem1514) } } p.dedent() @@ -7358,22 +4252,22 @@ func (p *PrettyPrinter) pretty_target_relation(msg *pb.TargetRelation) interface } func (p *PrettyPrinter) pretty_cdc_inserts(msg []*pb.TargetRelation) interface{} { - flat1515 := p.tryFlat(msg, func() { p.pretty_cdc_inserts(msg) }) - if flat1515 != nil { - p.write(*flat1515) + flat1520 := p.tryFlat(msg, func() { p.pretty_cdc_inserts(msg) }) + if flat1520 != nil { + p.write(*flat1520) return nil } else { - fields1512 := msg + fields1517 := msg p.write("(") p.write("inserts") p.indentSexp() - if !(len(fields1512) == 0) { + if !(len(fields1517) == 0) { p.newline() - for i1514, elem1513 := range fields1512 { - if (i1514 > 0) { + for i1519, elem1518 := range fields1517 { + if (i1519 > 0) { p.newline() } - p.pretty_target_relation(elem1513) + p.pretty_target_relation(elem1518) } } p.dedent() @@ -7383,22 +4277,22 @@ func (p *PrettyPrinter) pretty_cdc_inserts(msg []*pb.TargetRelation) interface{} } func (p *PrettyPrinter) pretty_cdc_deletes(msg []*pb.TargetRelation) interface{} { - flat1519 := p.tryFlat(msg, func() { p.pretty_cdc_deletes(msg) }) - if flat1519 != nil { - p.write(*flat1519) + flat1524 := p.tryFlat(msg, func() { p.pretty_cdc_deletes(msg) }) + if flat1524 != nil { + p.write(*flat1524) return nil } else { - fields1516 := msg + fields1521 := msg p.write("(") p.write("deletes") p.indentSexp() - if !(len(fields1516) == 0) { + if !(len(fields1521) == 0) { p.newline() - for i1518, elem1517 := range fields1516 { - if (i1518 > 0) { + for i1523, elem1522 := range fields1521 { + if (i1523 > 0) { p.newline() } - p.pretty_target_relation(elem1517) + p.pretty_target_relation(elem1522) } } p.dedent() @@ -7408,22 +4302,17 @@ func (p *PrettyPrinter) pretty_cdc_deletes(msg []*pb.TargetRelation) interface{} } func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { - flat1521 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) - if flat1521 != nil { - p.write(*flat1521) + flat1526 := p.tryFlat(msg, func() { p.pretty_csv_asof(msg) }) + if flat1526 != nil { + p.write(*flat1526) return nil } else { - fields1520 := msg ->>>>>>> origin/main + fields1525 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() -<<<<<<< HEAD - p.write(p.formatStringValue(fields1439)) -======= - p.write(p.formatStringValue(fields1520)) ->>>>>>> origin/main + p.write(p.formatStringValue(fields1525)) p.dedent() p.write(")") } @@ -7431,82 +4320,43 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { -<<<<<<< HEAD - flat1451 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) - if flat1451 != nil { - p.write(*flat1451) - return nil - } else { - _dollar_dollar := msg - _t1734 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1735 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1441 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1734, _t1735, _dollar_dollar.GetReturnsDelta()} - unwrapped_fields1442 := fields1441 -======= - flat1532 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) - if flat1532 != nil { - p.write(*flat1532) + flat1537 := p.tryFlat(msg, func() { p.pretty_iceberg_data(msg) }) + if flat1537 != nil { + p.write(*flat1537) return nil } else { _dollar_dollar := msg - _t1814 := p.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1815 := p.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1522 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetColumns(), _t1814, _t1815, _dollar_dollar.GetReturnsDelta()} - unwrapped_fields1523 := fields1522 ->>>>>>> origin/main + _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 p.write("(") p.write("iceberg_data") - p.indentSexp() - p.newline() -<<<<<<< HEAD - field1443 := unwrapped_fields1442[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1443) - p.newline() - field1444 := unwrapped_fields1442[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1444) - p.newline() - field1445 := unwrapped_fields1442[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1445) - field1446 := unwrapped_fields1442[3].(*string) - if field1446 != nil { - p.newline() - opt_val1447 := *field1446 - p.pretty_iceberg_from_snapshot(opt_val1447) - } - field1448 := unwrapped_fields1442[4].(*string) - if field1448 != nil { - p.newline() - opt_val1449 := *field1448 - p.pretty_iceberg_to_snapshot(opt_val1449) - } + p.indentSexp() p.newline() - field1450 := unwrapped_fields1442[5].(bool) - p.pretty_boolean_value(field1450) -======= - field1524 := unwrapped_fields1523[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1524) + field1529 := unwrapped_fields1528[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1529) p.newline() - field1525 := unwrapped_fields1523[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1525) + field1530 := unwrapped_fields1528[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1530) p.newline() - field1526 := unwrapped_fields1523[2].([]*pb.GNFColumn) - p.pretty_gnf_columns(field1526) - field1527 := unwrapped_fields1523[3].(*string) - if field1527 != nil { + field1531 := unwrapped_fields1528[2].([]*pb.GNFColumn) + p.pretty_gnf_columns(field1531) + field1532 := unwrapped_fields1528[3].(*string) + if field1532 != nil { p.newline() - opt_val1528 := *field1527 - p.pretty_iceberg_from_snapshot(opt_val1528) + opt_val1533 := *field1532 + p.pretty_iceberg_from_snapshot(opt_val1533) } - field1529 := unwrapped_fields1523[4].(*string) - if field1529 != nil { + field1534 := unwrapped_fields1528[4].(*string) + if field1534 != nil { p.newline() - opt_val1530 := *field1529 - p.pretty_iceberg_to_snapshot(opt_val1530) + opt_val1535 := *field1534 + p.pretty_iceberg_to_snapshot(opt_val1535) } p.newline() - field1531 := unwrapped_fields1523[5].(bool) - p.pretty_boolean_value(field1531) ->>>>>>> origin/main + field1536 := unwrapped_fields1528[5].(bool) + p.pretty_boolean_value(field1536) p.dedent() p.write(")") } @@ -7514,48 +4364,26 @@ func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { } func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface{} { -<<<<<<< HEAD - flat1457 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) - if flat1457 != nil { - p.write(*flat1457) - return nil - } else { - _dollar_dollar := msg - fields1452 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} - unwrapped_fields1453 := fields1452 -======= - flat1538 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) - if flat1538 != nil { - p.write(*flat1538) + flat1543 := p.tryFlat(msg, func() { p.pretty_iceberg_locator(msg) }) + if flat1543 != nil { + p.write(*flat1543) return nil } else { _dollar_dollar := msg - fields1533 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} - unwrapped_fields1534 := fields1533 ->>>>>>> origin/main + fields1538 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} + unwrapped_fields1539 := fields1538 p.write("(") p.write("iceberg_locator") p.indentSexp() p.newline() -<<<<<<< HEAD - field1454 := unwrapped_fields1453[0].(string) - p.pretty_iceberg_locator_table_name(field1454) - p.newline() - field1455 := unwrapped_fields1453[1].([]string) - p.pretty_iceberg_locator_namespace(field1455) - p.newline() - field1456 := unwrapped_fields1453[2].(string) - p.pretty_iceberg_locator_warehouse(field1456) -======= - field1535 := unwrapped_fields1534[0].(string) - p.pretty_iceberg_locator_table_name(field1535) + field1540 := unwrapped_fields1539[0].(string) + p.pretty_iceberg_locator_table_name(field1540) p.newline() - field1536 := unwrapped_fields1534[1].([]string) - p.pretty_iceberg_locator_namespace(field1536) + field1541 := unwrapped_fields1539[1].([]string) + p.pretty_iceberg_locator_namespace(field1541) p.newline() - field1537 := unwrapped_fields1534[2].(string) - p.pretty_iceberg_locator_warehouse(field1537) ->>>>>>> origin/main + field1542 := unwrapped_fields1539[2].(string) + p.pretty_iceberg_locator_warehouse(field1542) p.dedent() p.write(")") } @@ -7563,30 +4391,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface } func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{} { -<<<<<<< HEAD - flat1459 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) - if flat1459 != nil { - p.write(*flat1459) + flat1545 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) + if flat1545 != nil { + p.write(*flat1545) return nil } else { - fields1458 := msg -======= - flat1540 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) - if flat1540 != nil { - p.write(*flat1540) - return nil - } else { - fields1539 := msg ->>>>>>> origin/main + fields1544 := msg p.write("(") p.write("table_name") p.indentSexp() p.newline() -<<<<<<< HEAD - p.write(p.formatStringValue(fields1458)) -======= - p.write(p.formatStringValue(fields1539)) ->>>>>>> origin/main + p.write(p.formatStringValue(fields1544)) p.dedent() p.write(")") } @@ -7594,41 +4409,22 @@ func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{ } func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface{} { -<<<<<<< HEAD - flat1463 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) - if flat1463 != nil { - p.write(*flat1463) - return nil - } else { - fields1460 := msg - p.write("(") - p.write("namespace") - p.indentSexp() - if !(len(fields1460) == 0) { - p.newline() - for i1462, elem1461 := range fields1460 { - if (i1462 > 0) { - p.newline() - } - p.write(p.formatStringValue(elem1461)) -======= - flat1544 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) - if flat1544 != nil { - p.write(*flat1544) + flat1549 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_namespace(msg) }) + if flat1549 != nil { + p.write(*flat1549) return nil } else { - fields1541 := msg + fields1546 := msg p.write("(") p.write("namespace") p.indentSexp() - if !(len(fields1541) == 0) { + if !(len(fields1546) == 0) { p.newline() - for i1543, elem1542 := range fields1541 { - if (i1543 > 0) { + for i1548, elem1547 := range fields1546 { + if (i1548 > 0) { p.newline() } - p.write(p.formatStringValue(elem1542)) ->>>>>>> origin/main + p.write(p.formatStringValue(elem1547)) } } p.dedent() @@ -7638,30 +4434,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface } func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} { -<<<<<<< HEAD - flat1465 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) - if flat1465 != nil { - p.write(*flat1465) - return nil - } else { - fields1464 := msg -======= - flat1546 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) - if flat1546 != nil { - p.write(*flat1546) + flat1551 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_warehouse(msg) }) + if flat1551 != nil { + p.write(*flat1551) return nil } else { - fields1545 := msg ->>>>>>> origin/main + fields1550 := msg p.write("(") p.write("warehouse") p.indentSexp() p.newline() -<<<<<<< HEAD - p.write(p.formatStringValue(fields1464)) -======= - p.write(p.formatStringValue(fields1545)) ->>>>>>> origin/main + p.write(p.formatStringValue(fields1550)) p.dedent() p.write(")") } @@ -7669,62 +4452,33 @@ func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} } func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConfig) interface{} { -<<<<<<< HEAD - flat1473 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) - if flat1473 != nil { - p.write(*flat1473) + flat1559 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) + if flat1559 != nil { + p.write(*flat1559) return nil } else { _dollar_dollar := msg - _t1736 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1466 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1736, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} - unwrapped_fields1467 := fields1466 -======= - flat1554 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) - if flat1554 != nil { - p.write(*flat1554) - return nil - } else { - _dollar_dollar := msg - _t1816 := p.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1547 := []interface{}{_dollar_dollar.GetCatalogUri(), _t1816, dictToPairs(_dollar_dollar.GetProperties()), dictToPairs(_dollar_dollar.GetAuthProperties())} - unwrapped_fields1548 := fields1547 ->>>>>>> origin/main + _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 p.write("(") p.write("iceberg_catalog_config") p.indentSexp() p.newline() -<<<<<<< HEAD - field1468 := unwrapped_fields1467[0].(string) - p.pretty_iceberg_catalog_uri(field1468) - field1469 := unwrapped_fields1467[1].(*string) - if field1469 != nil { - p.newline() - opt_val1470 := *field1469 - p.pretty_iceberg_catalog_config_scope(opt_val1470) - } - p.newline() - field1471 := unwrapped_fields1467[2].([][]interface{}) - p.pretty_iceberg_properties(field1471) - p.newline() - field1472 := unwrapped_fields1467[3].([][]interface{}) - p.pretty_iceberg_auth_properties(field1472) -======= - field1549 := unwrapped_fields1548[0].(string) - p.pretty_iceberg_catalog_uri(field1549) - field1550 := unwrapped_fields1548[1].(*string) - if field1550 != nil { + field1554 := unwrapped_fields1553[0].(string) + p.pretty_iceberg_catalog_uri(field1554) + field1555 := unwrapped_fields1553[1].(*string) + if field1555 != nil { p.newline() - opt_val1551 := *field1550 - p.pretty_iceberg_catalog_config_scope(opt_val1551) + opt_val1556 := *field1555 + p.pretty_iceberg_catalog_config_scope(opt_val1556) } p.newline() - field1552 := unwrapped_fields1548[2].([][]interface{}) - p.pretty_iceberg_properties(field1552) + field1557 := unwrapped_fields1553[2].([][]interface{}) + p.pretty_iceberg_properties(field1557) p.newline() - field1553 := unwrapped_fields1548[3].([][]interface{}) - p.pretty_iceberg_auth_properties(field1553) ->>>>>>> origin/main + field1558 := unwrapped_fields1553[3].([][]interface{}) + p.pretty_iceberg_auth_properties(field1558) p.dedent() p.write(")") } @@ -7732,30 +4486,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConf } func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { -<<<<<<< HEAD - flat1475 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) - if flat1475 != nil { - p.write(*flat1475) - return nil - } else { - fields1474 := msg -======= - flat1556 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) - if flat1556 != nil { - p.write(*flat1556) + flat1561 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_uri(msg) }) + if flat1561 != nil { + p.write(*flat1561) return nil } else { - fields1555 := msg ->>>>>>> origin/main + fields1560 := msg p.write("(") p.write("catalog_uri") p.indentSexp() p.newline() -<<<<<<< HEAD - p.write(p.formatStringValue(fields1474)) -======= - p.write(p.formatStringValue(fields1555)) ->>>>>>> origin/main + p.write(p.formatStringValue(fields1560)) p.dedent() p.write(")") } @@ -7763,30 +4504,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interface{} { -<<<<<<< HEAD - flat1477 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) - if flat1477 != nil { - p.write(*flat1477) - return nil - } else { - fields1476 := msg -======= - flat1558 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) - if flat1558 != nil { - p.write(*flat1558) + flat1563 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config_scope(msg) }) + if flat1563 != nil { + p.write(*flat1563) return nil } else { - fields1557 := msg ->>>>>>> origin/main + fields1562 := msg p.write("(") p.write("scope") p.indentSexp() p.newline() -<<<<<<< HEAD - p.write(p.formatStringValue(fields1476)) -======= - p.write(p.formatStringValue(fields1557)) ->>>>>>> origin/main + p.write(p.formatStringValue(fields1562)) p.dedent() p.write(")") } @@ -7794,41 +4522,22 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interfac } func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface{} { -<<<<<<< HEAD - flat1481 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) - if flat1481 != nil { - p.write(*flat1481) - return nil - } else { - fields1478 := msg - p.write("(") - p.write("properties") - p.indentSexp() - if !(len(fields1478) == 0) { - p.newline() - for i1480, elem1479 := range fields1478 { - if (i1480 > 0) { - p.newline() - } - p.pretty_iceberg_property_entry(elem1479) -======= - flat1562 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) - if flat1562 != nil { - p.write(*flat1562) + flat1567 := p.tryFlat(msg, func() { p.pretty_iceberg_properties(msg) }) + if flat1567 != nil { + p.write(*flat1567) return nil } else { - fields1559 := msg + fields1564 := msg p.write("(") p.write("properties") p.indentSexp() - if !(len(fields1559) == 0) { + if !(len(fields1564) == 0) { p.newline() - for i1561, elem1560 := range fields1559 { - if (i1561 > 0) { + for i1566, elem1565 := range fields1564 { + if (i1566 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1560) ->>>>>>> origin/main + p.pretty_iceberg_property_entry(elem1565) } } p.dedent() @@ -7838,42 +4547,23 @@ func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface } func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interface{} { -<<<<<<< HEAD - flat1486 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) - if flat1486 != nil { - p.write(*flat1486) - return nil - } else { - _dollar_dollar := msg - fields1482 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} - unwrapped_fields1483 := fields1482 -======= - flat1567 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) - if flat1567 != nil { - p.write(*flat1567) + flat1572 := p.tryFlat(msg, func() { p.pretty_iceberg_property_entry(msg) }) + if flat1572 != nil { + p.write(*flat1572) return nil } else { _dollar_dollar := msg - fields1563 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} - unwrapped_fields1564 := fields1563 ->>>>>>> origin/main + fields1568 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} + unwrapped_fields1569 := fields1568 p.write("(") p.write("prop") p.indentSexp() p.newline() -<<<<<<< HEAD - field1484 := unwrapped_fields1483[0].(string) - p.write(p.formatStringValue(field1484)) + field1570 := unwrapped_fields1569[0].(string) + p.write(p.formatStringValue(field1570)) p.newline() - field1485 := unwrapped_fields1483[1].(string) - p.write(p.formatStringValue(field1485)) -======= - field1565 := unwrapped_fields1564[0].(string) - p.write(p.formatStringValue(field1565)) - p.newline() - field1566 := unwrapped_fields1564[1].(string) - p.write(p.formatStringValue(field1566)) ->>>>>>> origin/main + field1571 := unwrapped_fields1569[1].(string) + p.write(p.formatStringValue(field1571)) p.dedent() p.write(")") } @@ -7881,41 +4571,22 @@ func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) interface{} { -<<<<<<< HEAD - flat1490 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) - if flat1490 != nil { - p.write(*flat1490) - return nil - } else { - fields1487 := msg - p.write("(") - p.write("auth_properties") - p.indentSexp() - if !(len(fields1487) == 0) { - p.newline() - for i1489, elem1488 := range fields1487 { - if (i1489 > 0) { - p.newline() - } - p.pretty_iceberg_masked_property_entry(elem1488) -======= - flat1571 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) - if flat1571 != nil { - p.write(*flat1571) + flat1576 := p.tryFlat(msg, func() { p.pretty_iceberg_auth_properties(msg) }) + if flat1576 != nil { + p.write(*flat1576) return nil } else { - fields1568 := msg + fields1573 := msg p.write("(") p.write("auth_properties") p.indentSexp() - if !(len(fields1568) == 0) { + if !(len(fields1573) == 0) { p.newline() - for i1570, elem1569 := range fields1568 { - if (i1570 > 0) { + for i1575, elem1574 := range fields1573 { + if (i1575 > 0) { p.newline() } - p.pretty_iceberg_masked_property_entry(elem1569) ->>>>>>> origin/main + p.pretty_iceberg_masked_property_entry(elem1574) } } p.dedent() @@ -7925,44 +4596,24 @@ func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) inte } func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) interface{} { -<<<<<<< HEAD - flat1495 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) - if flat1495 != nil { - p.write(*flat1495) - return nil - } else { - _dollar_dollar := msg - _t1737 := p.mask_secret_value(_dollar_dollar) - fields1491 := []interface{}{_dollar_dollar[0].(string), _t1737} - unwrapped_fields1492 := fields1491 -======= - flat1576 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) - if flat1576 != nil { - p.write(*flat1576) + flat1581 := p.tryFlat(msg, func() { p.pretty_iceberg_masked_property_entry(msg) }) + if flat1581 != nil { + p.write(*flat1581) return nil } else { _dollar_dollar := msg - _t1817 := p.mask_secret_value(_dollar_dollar) - fields1572 := []interface{}{_dollar_dollar[0].(string), _t1817} - unwrapped_fields1573 := fields1572 ->>>>>>> origin/main + _t1827 := p.mask_secret_value(_dollar_dollar) + fields1577 := []interface{}{_dollar_dollar[0].(string), _t1827} + unwrapped_fields1578 := fields1577 p.write("(") p.write("prop") p.indentSexp() p.newline() -<<<<<<< HEAD - field1493 := unwrapped_fields1492[0].(string) - p.write(p.formatStringValue(field1493)) + field1579 := unwrapped_fields1578[0].(string) + p.write(p.formatStringValue(field1579)) p.newline() - field1494 := unwrapped_fields1492[1].(string) - p.write(p.formatStringValue(field1494)) -======= - field1574 := unwrapped_fields1573[0].(string) - p.write(p.formatStringValue(field1574)) - p.newline() - field1575 := unwrapped_fields1573[1].(string) - p.write(p.formatStringValue(field1575)) ->>>>>>> origin/main + field1580 := unwrapped_fields1578[1].(string) + p.write(p.formatStringValue(field1580)) p.dedent() p.write(")") } @@ -7970,30 +4621,17 @@ func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) } func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { -<<<<<<< HEAD - flat1497 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) - if flat1497 != nil { - p.write(*flat1497) - return nil - } else { - fields1496 := msg -======= - flat1578 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) - if flat1578 != nil { - p.write(*flat1578) + flat1583 := p.tryFlat(msg, func() { p.pretty_iceberg_from_snapshot(msg) }) + if flat1583 != nil { + p.write(*flat1583) return nil } else { - fields1577 := msg ->>>>>>> origin/main + fields1582 := msg p.write("(") p.write("from_snapshot") p.indentSexp() p.newline() -<<<<<<< HEAD - p.write(p.formatStringValue(fields1496)) -======= - p.write(p.formatStringValue(fields1577)) ->>>>>>> origin/main + p.write(p.formatStringValue(fields1582)) p.dedent() p.write(")") } @@ -8001,30 +4639,17 @@ func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { -<<<<<<< HEAD - flat1499 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) - if flat1499 != nil { - p.write(*flat1499) - return nil - } else { - fields1498 := msg -======= - flat1580 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) - if flat1580 != nil { - p.write(*flat1580) + flat1585 := p.tryFlat(msg, func() { p.pretty_iceberg_to_snapshot(msg) }) + if flat1585 != nil { + p.write(*flat1585) return nil } else { - fields1579 := msg ->>>>>>> origin/main + fields1584 := msg p.write("(") p.write("to_snapshot") p.indentSexp() p.newline() -<<<<<<< HEAD - p.write(p.formatStringValue(fields1498)) -======= - p.write(p.formatStringValue(fields1579)) ->>>>>>> origin/main + p.write(p.formatStringValue(fields1584)) p.dedent() p.write(")") } @@ -8032,34 +4657,19 @@ func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { -<<<<<<< HEAD - flat1502 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1502 != nil { - p.write(*flat1502) - return nil - } else { - _dollar_dollar := msg - fields1500 := _dollar_dollar.GetFragmentId() - unwrapped_fields1501 := fields1500 -======= - flat1583 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) - if flat1583 != nil { - p.write(*flat1583) + flat1588 := p.tryFlat(msg, func() { p.pretty_undefine(msg) }) + if flat1588 != nil { + p.write(*flat1588) return nil } else { _dollar_dollar := msg - fields1581 := _dollar_dollar.GetFragmentId() - unwrapped_fields1582 := fields1581 ->>>>>>> origin/main + fields1586 := _dollar_dollar.GetFragmentId() + unwrapped_fields1587 := fields1586 p.write("(") p.write("undefine") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_fragment_id(unwrapped_fields1501) -======= - p.pretty_fragment_id(unwrapped_fields1582) ->>>>>>> origin/main + p.pretty_fragment_id(unwrapped_fields1587) p.dedent() p.write(")") } @@ -8067,45 +4677,24 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { -<<<<<<< HEAD - flat1507 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1507 != nil { - p.write(*flat1507) + flat1593 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1593 != nil { + p.write(*flat1593) return nil } else { _dollar_dollar := msg - fields1503 := _dollar_dollar.GetRelations() - unwrapped_fields1504 := fields1503 - p.write("(") - p.write("context") - p.indentSexp() - if !(len(unwrapped_fields1504) == 0) { - p.newline() - for i1506, elem1505 := range unwrapped_fields1504 { - if (i1506 > 0) { - p.newline() - } - p.pretty_relation_id(elem1505) -======= - flat1588 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1588 != nil { - p.write(*flat1588) - return nil - } else { - _dollar_dollar := msg - fields1584 := _dollar_dollar.GetRelations() - unwrapped_fields1585 := fields1584 + fields1589 := _dollar_dollar.GetRelations() + unwrapped_fields1590 := fields1589 p.write("(") p.write("context") p.indentSexp() - if !(len(unwrapped_fields1585) == 0) { + if !(len(unwrapped_fields1590) == 0) { p.newline() - for i1587, elem1586 := range unwrapped_fields1585 { - if (i1587 > 0) { + for i1592, elem1591 := range unwrapped_fields1590 { + if (i1592 > 0) { p.newline() } - p.pretty_relation_id(elem1586) ->>>>>>> origin/main + p.pretty_relation_id(elem1591) } } p.dedent() @@ -8115,52 +4704,28 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { -<<<<<<< HEAD - flat1514 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1514 != nil { - p.write(*flat1514) - return nil - } else { - _dollar_dollar := msg - fields1508 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} - unwrapped_fields1509 := fields1508 -======= - flat1595 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) - if flat1595 != nil { - p.write(*flat1595) + flat1600 := p.tryFlat(msg, func() { p.pretty_snapshot(msg) }) + if flat1600 != nil { + p.write(*flat1600) return nil } else { _dollar_dollar := msg - fields1589 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} - unwrapped_fields1590 := fields1589 ->>>>>>> origin/main + fields1594 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} + unwrapped_fields1595 := fields1594 p.write("(") p.write("snapshot") p.indentSexp() p.newline() -<<<<<<< HEAD - field1510 := unwrapped_fields1509[0].([]string) - p.pretty_edb_path(field1510) - field1511 := unwrapped_fields1509[1].([]*pb.SnapshotMapping) - if !(len(field1511) == 0) { - p.newline() - for i1513, elem1512 := range field1511 { - if (i1513 > 0) { - p.newline() - } - p.pretty_snapshot_mapping(elem1512) -======= - field1591 := unwrapped_fields1590[0].([]string) - p.pretty_edb_path(field1591) - field1592 := unwrapped_fields1590[1].([]*pb.SnapshotMapping) - if !(len(field1592) == 0) { + field1596 := unwrapped_fields1595[0].([]string) + p.pretty_edb_path(field1596) + field1597 := unwrapped_fields1595[1].([]*pb.SnapshotMapping) + if !(len(field1597) == 0) { p.newline() - for i1594, elem1593 := range field1592 { - if (i1594 > 0) { + for i1599, elem1598 := range field1597 { + if (i1599 > 0) { p.newline() } - p.pretty_snapshot_mapping(elem1593) ->>>>>>> origin/main + p.pretty_snapshot_mapping(elem1598) } } p.dedent() @@ -8170,75 +4735,40 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} { -<<<<<<< HEAD - flat1519 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) - if flat1519 != nil { - p.write(*flat1519) - return nil - } else { - _dollar_dollar := msg - fields1515 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} - unwrapped_fields1516 := fields1515 - field1517 := unwrapped_fields1516[0].([]string) - p.pretty_edb_path(field1517) - p.write(" ") - field1518 := unwrapped_fields1516[1].(*pb.RelationId) - p.pretty_relation_id(field1518) -======= - flat1600 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) - if flat1600 != nil { - p.write(*flat1600) + flat1605 := p.tryFlat(msg, func() { p.pretty_snapshot_mapping(msg) }) + if flat1605 != nil { + p.write(*flat1605) return nil } else { _dollar_dollar := msg - fields1596 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} - unwrapped_fields1597 := fields1596 - field1598 := unwrapped_fields1597[0].([]string) - p.pretty_edb_path(field1598) + fields1601 := []interface{}{_dollar_dollar.GetDestinationPath(), _dollar_dollar.GetSourceRelation()} + unwrapped_fields1602 := fields1601 + field1603 := unwrapped_fields1602[0].([]string) + p.pretty_edb_path(field1603) p.write(" ") - field1599 := unwrapped_fields1597[1].(*pb.RelationId) - p.pretty_relation_id(field1599) ->>>>>>> origin/main + field1604 := unwrapped_fields1602[1].(*pb.RelationId) + p.pretty_relation_id(field1604) } return nil } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { -<<<<<<< HEAD - flat1523 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1523 != nil { - p.write(*flat1523) - return nil - } else { - fields1520 := msg - p.write("(") - p.write("reads") - p.indentSexp() - if !(len(fields1520) == 0) { - p.newline() - for i1522, elem1521 := range fields1520 { - if (i1522 > 0) { - p.newline() - } - p.pretty_read(elem1521) -======= - flat1604 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) - if flat1604 != nil { - p.write(*flat1604) + flat1609 := p.tryFlat(msg, func() { p.pretty_epoch_reads(msg) }) + if flat1609 != nil { + p.write(*flat1609) return nil } else { - fields1601 := msg + fields1606 := msg p.write("(") p.write("reads") p.indentSexp() - if !(len(fields1601) == 0) { + if !(len(fields1606) == 0) { p.newline() - for i1603, elem1602 := range fields1601 { - if (i1603 > 0) { + for i1608, elem1607 := range fields1606 { + if (i1608 > 0) { p.newline() } - p.pretty_read(elem1602) ->>>>>>> origin/main + p.pretty_read(elem1607) } } p.dedent() @@ -8248,117 +4778,60 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { -<<<<<<< HEAD - flat1534 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1534 != nil { - p.write(*flat1534) - return nil - } else { - _dollar_dollar := msg - var _t1738 *pb.Demand - if hasProtoField(_dollar_dollar, "demand") { - _t1738 = _dollar_dollar.GetDemand() - } - deconstruct_result1532 := _t1738 - if deconstruct_result1532 != nil { - unwrapped1533 := deconstruct_result1532 - p.pretty_demand(unwrapped1533) - } else { - _dollar_dollar := msg - var _t1739 *pb.Output - if hasProtoField(_dollar_dollar, "output") { - _t1739 = _dollar_dollar.GetOutput() - } - deconstruct_result1530 := _t1739 - if deconstruct_result1530 != nil { - unwrapped1531 := deconstruct_result1530 - p.pretty_output(unwrapped1531) - } else { - _dollar_dollar := msg - var _t1740 *pb.WhatIf - if hasProtoField(_dollar_dollar, "what_if") { - _t1740 = _dollar_dollar.GetWhatIf() - } - deconstruct_result1528 := _t1740 - if deconstruct_result1528 != nil { - unwrapped1529 := deconstruct_result1528 - p.pretty_what_if(unwrapped1529) - } else { - _dollar_dollar := msg - var _t1741 *pb.Abort - if hasProtoField(_dollar_dollar, "abort") { - _t1741 = _dollar_dollar.GetAbort() - } - deconstruct_result1526 := _t1741 - if deconstruct_result1526 != nil { - unwrapped1527 := deconstruct_result1526 - p.pretty_abort(unwrapped1527) - } else { - _dollar_dollar := msg - var _t1742 *pb.Export - if hasProtoField(_dollar_dollar, "export") { - _t1742 = _dollar_dollar.GetExport() - } - deconstruct_result1524 := _t1742 - if deconstruct_result1524 != nil { - unwrapped1525 := deconstruct_result1524 - p.pretty_export(unwrapped1525) -======= - flat1615 := p.tryFlat(msg, func() { p.pretty_read(msg) }) - if flat1615 != nil { - p.write(*flat1615) + flat1620 := p.tryFlat(msg, func() { p.pretty_read(msg) }) + if flat1620 != nil { + p.write(*flat1620) return nil } else { _dollar_dollar := msg - var _t1818 *pb.Demand + var _t1828 *pb.Demand if hasProtoField(_dollar_dollar, "demand") { - _t1818 = _dollar_dollar.GetDemand() + _t1828 = _dollar_dollar.GetDemand() } - deconstruct_result1613 := _t1818 - if deconstruct_result1613 != nil { - unwrapped1614 := deconstruct_result1613 - p.pretty_demand(unwrapped1614) + deconstruct_result1618 := _t1828 + if deconstruct_result1618 != nil { + unwrapped1619 := deconstruct_result1618 + p.pretty_demand(unwrapped1619) } else { _dollar_dollar := msg - var _t1819 *pb.Output + var _t1829 *pb.Output if hasProtoField(_dollar_dollar, "output") { - _t1819 = _dollar_dollar.GetOutput() + _t1829 = _dollar_dollar.GetOutput() } - deconstruct_result1611 := _t1819 - if deconstruct_result1611 != nil { - unwrapped1612 := deconstruct_result1611 - p.pretty_output(unwrapped1612) + deconstruct_result1616 := _t1829 + if deconstruct_result1616 != nil { + unwrapped1617 := deconstruct_result1616 + p.pretty_output(unwrapped1617) } else { _dollar_dollar := msg - var _t1820 *pb.WhatIf + var _t1830 *pb.WhatIf if hasProtoField(_dollar_dollar, "what_if") { - _t1820 = _dollar_dollar.GetWhatIf() + _t1830 = _dollar_dollar.GetWhatIf() } - deconstruct_result1609 := _t1820 - if deconstruct_result1609 != nil { - unwrapped1610 := deconstruct_result1609 - p.pretty_what_if(unwrapped1610) + deconstruct_result1614 := _t1830 + if deconstruct_result1614 != nil { + unwrapped1615 := deconstruct_result1614 + p.pretty_what_if(unwrapped1615) } else { _dollar_dollar := msg - var _t1821 *pb.Abort + var _t1831 *pb.Abort if hasProtoField(_dollar_dollar, "abort") { - _t1821 = _dollar_dollar.GetAbort() + _t1831 = _dollar_dollar.GetAbort() } - deconstruct_result1607 := _t1821 - if deconstruct_result1607 != nil { - unwrapped1608 := deconstruct_result1607 - p.pretty_abort(unwrapped1608) + deconstruct_result1612 := _t1831 + if deconstruct_result1612 != nil { + unwrapped1613 := deconstruct_result1612 + p.pretty_abort(unwrapped1613) } else { _dollar_dollar := msg - var _t1822 *pb.Export + var _t1832 *pb.Export if hasProtoField(_dollar_dollar, "export") { - _t1822 = _dollar_dollar.GetExport() + _t1832 = _dollar_dollar.GetExport() } - deconstruct_result1605 := _t1822 - if deconstruct_result1605 != nil { - unwrapped1606 := deconstruct_result1605 - p.pretty_export(unwrapped1606) ->>>>>>> origin/main + deconstruct_result1610 := _t1832 + if deconstruct_result1610 != nil { + unwrapped1611 := deconstruct_result1610 + p.pretty_export(unwrapped1611) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -8371,34 +4844,19 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { -<<<<<<< HEAD - flat1537 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1537 != nil { - p.write(*flat1537) - return nil - } else { - _dollar_dollar := msg - fields1535 := _dollar_dollar.GetRelationId() - unwrapped_fields1536 := fields1535 -======= - flat1618 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) - if flat1618 != nil { - p.write(*flat1618) + flat1623 := p.tryFlat(msg, func() { p.pretty_demand(msg) }) + if flat1623 != nil { + p.write(*flat1623) return nil } else { _dollar_dollar := msg - fields1616 := _dollar_dollar.GetRelationId() - unwrapped_fields1617 := fields1616 ->>>>>>> origin/main + fields1621 := _dollar_dollar.GetRelationId() + unwrapped_fields1622 := fields1621 p.write("(") p.write("demand") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_relation_id(unwrapped_fields1536) -======= - p.pretty_relation_id(unwrapped_fields1617) ->>>>>>> origin/main + p.pretty_relation_id(unwrapped_fields1622) p.dedent() p.write(")") } @@ -8406,42 +4864,23 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { -<<<<<<< HEAD - flat1542 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1542 != nil { - p.write(*flat1542) - return nil - } else { - _dollar_dollar := msg - fields1538 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} - unwrapped_fields1539 := fields1538 -======= - flat1623 := p.tryFlat(msg, func() { p.pretty_output(msg) }) - if flat1623 != nil { - p.write(*flat1623) + flat1628 := p.tryFlat(msg, func() { p.pretty_output(msg) }) + if flat1628 != nil { + p.write(*flat1628) return nil } else { _dollar_dollar := msg - fields1619 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} - unwrapped_fields1620 := fields1619 ->>>>>>> origin/main + fields1624 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} + unwrapped_fields1625 := fields1624 p.write("(") p.write("output") p.indentSexp() p.newline() -<<<<<<< HEAD - field1540 := unwrapped_fields1539[0].(string) - p.pretty_name(field1540) - p.newline() - field1541 := unwrapped_fields1539[1].(*pb.RelationId) - p.pretty_relation_id(field1541) -======= - field1621 := unwrapped_fields1620[0].(string) - p.pretty_name(field1621) + field1626 := unwrapped_fields1625[0].(string) + p.pretty_name(field1626) p.newline() - field1622 := unwrapped_fields1620[1].(*pb.RelationId) - p.pretty_relation_id(field1622) ->>>>>>> origin/main + field1627 := unwrapped_fields1625[1].(*pb.RelationId) + p.pretty_relation_id(field1627) p.dedent() p.write(")") } @@ -8449,42 +4888,23 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { -<<<<<<< HEAD - flat1547 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1547 != nil { - p.write(*flat1547) - return nil - } else { - _dollar_dollar := msg - fields1543 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} - unwrapped_fields1544 := fields1543 -======= - flat1628 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) - if flat1628 != nil { - p.write(*flat1628) + flat1633 := p.tryFlat(msg, func() { p.pretty_what_if(msg) }) + if flat1633 != nil { + p.write(*flat1633) return nil } else { _dollar_dollar := msg - fields1624 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} - unwrapped_fields1625 := fields1624 ->>>>>>> origin/main + fields1629 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} + unwrapped_fields1630 := fields1629 p.write("(") p.write("what_if") p.indentSexp() p.newline() -<<<<<<< HEAD - field1545 := unwrapped_fields1544[0].(string) - p.pretty_name(field1545) - p.newline() - field1546 := unwrapped_fields1544[1].(*pb.Epoch) - p.pretty_epoch(field1546) -======= - field1626 := unwrapped_fields1625[0].(string) - p.pretty_name(field1626) + field1631 := unwrapped_fields1630[0].(string) + p.pretty_name(field1631) p.newline() - field1627 := unwrapped_fields1625[1].(*pb.Epoch) - p.pretty_epoch(field1627) ->>>>>>> origin/main + field1632 := unwrapped_fields1630[1].(*pb.Epoch) + p.pretty_epoch(field1632) p.dedent() p.write(")") } @@ -8492,57 +4912,30 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { -<<<<<<< HEAD - flat1553 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1553 != nil { - p.write(*flat1553) - return nil - } else { - _dollar_dollar := msg - var _t1743 *string - if _dollar_dollar.GetName() != "abort" { - _t1743 = ptr(_dollar_dollar.GetName()) - } - fields1548 := []interface{}{_t1743, _dollar_dollar.GetRelationId()} - unwrapped_fields1549 := fields1548 - p.write("(") - p.write("abort") - p.indentSexp() - field1550 := unwrapped_fields1549[0].(*string) - if field1550 != nil { - p.newline() - opt_val1551 := *field1550 - p.pretty_name(opt_val1551) - } - p.newline() - field1552 := unwrapped_fields1549[1].(*pb.RelationId) - p.pretty_relation_id(field1552) -======= - flat1634 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) - if flat1634 != nil { - p.write(*flat1634) + flat1639 := p.tryFlat(msg, func() { p.pretty_abort(msg) }) + if flat1639 != nil { + p.write(*flat1639) return nil } else { _dollar_dollar := msg - var _t1823 *string + var _t1833 *string if _dollar_dollar.GetName() != "abort" { - _t1823 = ptr(_dollar_dollar.GetName()) + _t1833 = ptr(_dollar_dollar.GetName()) } - fields1629 := []interface{}{_t1823, _dollar_dollar.GetRelationId()} - unwrapped_fields1630 := fields1629 + fields1634 := []interface{}{_t1833, _dollar_dollar.GetRelationId()} + unwrapped_fields1635 := fields1634 p.write("(") p.write("abort") p.indentSexp() - field1631 := unwrapped_fields1630[0].(*string) - if field1631 != nil { + field1636 := unwrapped_fields1635[0].(*string) + if field1636 != nil { p.newline() - opt_val1632 := *field1631 - p.pretty_name(opt_val1632) + opt_val1637 := *field1636 + p.pretty_name(opt_val1637) } p.newline() - field1633 := unwrapped_fields1630[1].(*pb.RelationId) - p.pretty_relation_id(field1633) ->>>>>>> origin/main + field1638 := unwrapped_fields1635[1].(*pb.RelationId) + p.pretty_relation_id(field1638) p.dedent() p.write(")") } @@ -8550,74 +4943,40 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { -<<<<<<< HEAD - flat1558 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1558 != nil { - p.write(*flat1558) - return nil - } else { - _dollar_dollar := msg - var _t1744 *pb.ExportCSVConfig - if hasProtoField(_dollar_dollar, "csv_config") { - _t1744 = _dollar_dollar.GetCsvConfig() - } - deconstruct_result1556 := _t1744 - if deconstruct_result1556 != nil { - unwrapped1557 := deconstruct_result1556 -======= - flat1639 := p.tryFlat(msg, func() { p.pretty_export(msg) }) - if flat1639 != nil { - p.write(*flat1639) + flat1644 := p.tryFlat(msg, func() { p.pretty_export(msg) }) + if flat1644 != nil { + p.write(*flat1644) return nil } else { _dollar_dollar := msg - var _t1824 *pb.ExportCSVConfig + var _t1834 *pb.ExportCSVConfig if hasProtoField(_dollar_dollar, "csv_config") { - _t1824 = _dollar_dollar.GetCsvConfig() + _t1834 = _dollar_dollar.GetCsvConfig() } - deconstruct_result1637 := _t1824 - if deconstruct_result1637 != nil { - unwrapped1638 := deconstruct_result1637 ->>>>>>> origin/main + deconstruct_result1642 := _t1834 + if deconstruct_result1642 != nil { + unwrapped1643 := deconstruct_result1642 p.write("(") p.write("export") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_export_csv_config(unwrapped1557) -======= - p.pretty_export_csv_config(unwrapped1638) ->>>>>>> origin/main + p.pretty_export_csv_config(unwrapped1643) p.dedent() p.write(")") } else { _dollar_dollar := msg -<<<<<<< HEAD - var _t1745 *pb.ExportIcebergConfig - if hasProtoField(_dollar_dollar, "iceberg_config") { - _t1745 = _dollar_dollar.GetIcebergConfig() - } - deconstruct_result1554 := _t1745 - if deconstruct_result1554 != nil { - unwrapped1555 := deconstruct_result1554 -======= - var _t1825 *pb.ExportIcebergConfig + var _t1835 *pb.ExportIcebergConfig if hasProtoField(_dollar_dollar, "iceberg_config") { - _t1825 = _dollar_dollar.GetIcebergConfig() + _t1835 = _dollar_dollar.GetIcebergConfig() } - deconstruct_result1635 := _t1825 - if deconstruct_result1635 != nil { - unwrapped1636 := deconstruct_result1635 ->>>>>>> origin/main + deconstruct_result1640 := _t1835 + if deconstruct_result1640 != nil { + unwrapped1641 := deconstruct_result1640 p.write("(") p.write("export_iceberg") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_export_iceberg_config(unwrapped1555) -======= - p.pretty_export_iceberg_config(unwrapped1636) ->>>>>>> origin/main + p.pretty_export_iceberg_config(unwrapped1641) p.dedent() p.write(")") } else { @@ -8629,105 +4988,56 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { -<<<<<<< HEAD - flat1569 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1569 != nil { - p.write(*flat1569) - return nil - } else { - _dollar_dollar := msg - var _t1746 []interface{} - if int64(len(_dollar_dollar.GetDataColumns())) == 0 { - _t1747 := p.deconstruct_export_csv_output_location(_dollar_dollar) - _t1746 = []interface{}{_t1747, _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} - } - deconstruct_result1564 := _t1746 - if deconstruct_result1564 != nil { - unwrapped1565 := deconstruct_result1564 -======= - flat1650 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) - if flat1650 != nil { - p.write(*flat1650) + flat1655 := p.tryFlat(msg, func() { p.pretty_export_csv_config(msg) }) + if flat1655 != nil { + p.write(*flat1655) return nil } else { _dollar_dollar := msg - var _t1826 []interface{} + var _t1836 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) == 0 { - _t1826 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} + _t1837 := p.deconstruct_export_csv_output_location(_dollar_dollar) + _t1836 = []interface{}{_t1837, _dollar_dollar.GetCsvSource(), _dollar_dollar.GetCsvConfig()} } - deconstruct_result1645 := _t1826 - if deconstruct_result1645 != nil { - unwrapped1646 := deconstruct_result1645 ->>>>>>> origin/main + deconstruct_result1650 := _t1836 + if deconstruct_result1650 != nil { + unwrapped1651 := deconstruct_result1650 p.write("(") p.write("export_csv_config_v2") p.indentSexp() p.newline() -<<<<<<< HEAD - field1566 := unwrapped1565[0].([]interface{}) - p.pretty_export_csv_output_location(field1566) + field1652 := unwrapped1651[0].([]interface{}) + p.pretty_export_csv_output_location(field1652) p.newline() - field1567 := unwrapped1565[1].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1567) + field1653 := unwrapped1651[1].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1653) p.newline() - field1568 := unwrapped1565[2].(*pb.CSVConfig) - p.pretty_csv_config(field1568) -======= - field1647 := unwrapped1646[0].(string) - p.pretty_export_csv_path(field1647) - p.newline() - field1648 := unwrapped1646[1].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1648) - p.newline() - field1649 := unwrapped1646[2].(*pb.CSVConfig) - p.pretty_csv_config(field1649) ->>>>>>> origin/main + field1654 := unwrapped1651[2].(*pb.CSVConfig) + p.pretty_csv_config(field1654) p.dedent() p.write(")") } else { _dollar_dollar := msg -<<<<<<< HEAD - var _t1748 []interface{} - if int64(len(_dollar_dollar.GetDataColumns())) != 0 { - _t1749 := p.deconstruct_export_csv_config(_dollar_dollar) - _t1748 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1749} - } - deconstruct_result1559 := _t1748 - if deconstruct_result1559 != nil { - unwrapped1560 := deconstruct_result1559 -======= - var _t1827 []interface{} + var _t1838 []interface{} if int64(len(_dollar_dollar.GetDataColumns())) != 0 { - _t1828 := p.deconstruct_export_csv_config(_dollar_dollar) - _t1827 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1828} + _t1839 := p.deconstruct_export_csv_config(_dollar_dollar) + _t1838 = []interface{}{_dollar_dollar.GetPath(), _dollar_dollar.GetDataColumns(), _t1839} } - deconstruct_result1640 := _t1827 - if deconstruct_result1640 != nil { - unwrapped1641 := deconstruct_result1640 ->>>>>>> origin/main + deconstruct_result1645 := _t1838 + if deconstruct_result1645 != nil { + unwrapped1646 := deconstruct_result1645 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() -<<<<<<< HEAD - field1561 := unwrapped1560[0].(string) - p.pretty_export_csv_path(field1561) - p.newline() - field1562 := unwrapped1560[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns_list(field1562) - p.newline() - field1563 := unwrapped1560[2].([][]interface{}) - p.pretty_config_dict(field1563) -======= - field1642 := unwrapped1641[0].(string) - p.pretty_export_csv_path(field1642) + field1647 := unwrapped1646[0].(string) + p.pretty_export_csv_path(field1647) p.newline() - field1643 := unwrapped1641[1].([]*pb.ExportCSVColumn) - p.pretty_export_csv_columns_list(field1643) + field1648 := unwrapped1646[1].([]*pb.ExportCSVColumn) + p.pretty_export_csv_columns_list(field1648) p.newline() - field1644 := unwrapped1641[2].([][]interface{}) - p.pretty_config_dict(field1644) ->>>>>>> origin/main + field1649 := unwrapped1646[2].([][]interface{}) + p.pretty_config_dict(field1649) p.dedent() p.write(")") } else { @@ -8738,150 +5048,93 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf return nil } -<<<<<<< HEAD func (p *PrettyPrinter) pretty_export_csv_output_location(msg []interface{}) interface{} { - flat1574 := p.tryFlat(msg, func() { p.pretty_export_csv_output_location(msg) }) - if flat1574 != nil { - p.write(*flat1574) + flat1660 := p.tryFlat(msg, func() { p.pretty_export_csv_output_location(msg) }) + if flat1660 != nil { + p.write(*flat1660) return nil } else { _dollar_dollar := msg - var _t1750 *string + var _t1840 *string if _dollar_dollar[0].(string) != "" { - _t1750 = ptr(_dollar_dollar[0].(string)) + _t1840 = ptr(_dollar_dollar[0].(string)) } - deconstruct_result1572 := _t1750 - if deconstruct_result1572 != nil { - unwrapped1573 := *deconstruct_result1572 + deconstruct_result1658 := _t1840 + if deconstruct_result1658 != nil { + unwrapped1659 := *deconstruct_result1658 p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(unwrapped1573)) + p.write(p.formatStringValue(unwrapped1659)) p.dedent() p.write(")") } else { _dollar_dollar := msg - var _t1751 *string + var _t1841 *string if _dollar_dollar[1].(string) != "" { - _t1751 = ptr(_dollar_dollar[1].(string)) + _t1841 = ptr(_dollar_dollar[1].(string)) } - deconstruct_result1570 := _t1751 - if deconstruct_result1570 != nil { - unwrapped1571 := *deconstruct_result1570 + deconstruct_result1656 := _t1841 + if deconstruct_result1656 != nil { + unwrapped1657 := *deconstruct_result1656 p.write("(") p.write("transaction_output_name") p.indentSexp() p.newline() - p.pretty_name(unwrapped1571) + p.pretty_name(unwrapped1657) p.dedent() p.write(")") } else { panic(ParseError{msg: "No matching rule for export_csv_output_location"}) } } -======= -func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1652 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1652 != nil { - p.write(*flat1652) - return nil - } else { - fields1651 := msg - p.write("(") - p.write("path") - p.indentSexp() - p.newline() - p.write(p.formatStringValue(fields1651)) - p.dedent() - p.write(")") ->>>>>>> origin/main } return nil } func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interface{} { -<<<<<<< HEAD - flat1581 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) - if flat1581 != nil { - p.write(*flat1581) - return nil - } else { - _dollar_dollar := msg - var _t1752 []*pb.ExportCSVColumn - if hasProtoField(_dollar_dollar, "gnf_columns") { - _t1752 = _dollar_dollar.GetGnfColumns().GetColumns() - } - deconstruct_result1577 := _t1752 - if deconstruct_result1577 != nil { - unwrapped1578 := deconstruct_result1577 - p.write("(") - p.write("gnf_columns") - p.indentSexp() - if !(len(unwrapped1578) == 0) { - p.newline() - for i1580, elem1579 := range unwrapped1578 { - if (i1580 > 0) { - p.newline() - } - p.pretty_export_csv_column(elem1579) -======= - flat1659 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) - if flat1659 != nil { - p.write(*flat1659) + flat1667 := p.tryFlat(msg, func() { p.pretty_export_csv_source(msg) }) + if flat1667 != nil { + p.write(*flat1667) return nil } else { _dollar_dollar := msg - var _t1829 []*pb.ExportCSVColumn + var _t1842 []*pb.ExportCSVColumn if hasProtoField(_dollar_dollar, "gnf_columns") { - _t1829 = _dollar_dollar.GetGnfColumns().GetColumns() + _t1842 = _dollar_dollar.GetGnfColumns().GetColumns() } - deconstruct_result1655 := _t1829 - if deconstruct_result1655 != nil { - unwrapped1656 := deconstruct_result1655 + deconstruct_result1663 := _t1842 + if deconstruct_result1663 != nil { + unwrapped1664 := deconstruct_result1663 p.write("(") p.write("gnf_columns") p.indentSexp() - if !(len(unwrapped1656) == 0) { + if !(len(unwrapped1664) == 0) { p.newline() - for i1658, elem1657 := range unwrapped1656 { - if (i1658 > 0) { + for i1666, elem1665 := range unwrapped1664 { + if (i1666 > 0) { p.newline() } - p.pretty_export_csv_column(elem1657) ->>>>>>> origin/main + p.pretty_export_csv_column(elem1665) } } p.dedent() p.write(")") } else { _dollar_dollar := msg -<<<<<<< HEAD - var _t1753 *pb.RelationId - if hasProtoField(_dollar_dollar, "table_def") { - _t1753 = _dollar_dollar.GetTableDef() - } - deconstruct_result1575 := _t1753 - if deconstruct_result1575 != nil { - unwrapped1576 := deconstruct_result1575 -======= - var _t1830 *pb.RelationId + var _t1843 *pb.RelationId if hasProtoField(_dollar_dollar, "table_def") { - _t1830 = _dollar_dollar.GetTableDef() + _t1843 = _dollar_dollar.GetTableDef() } - deconstruct_result1653 := _t1830 - if deconstruct_result1653 != nil { - unwrapped1654 := deconstruct_result1653 ->>>>>>> origin/main + deconstruct_result1661 := _t1843 + if deconstruct_result1661 != nil { + unwrapped1662 := deconstruct_result1661 p.write("(") p.write("table_def") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_relation_id(unwrapped1576) -======= - p.pretty_relation_id(unwrapped1654) ->>>>>>> origin/main + p.pretty_relation_id(unwrapped1662) p.dedent() p.write(")") } else { @@ -8893,35 +5146,23 @@ func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interf } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { -<<<<<<< HEAD - flat1586 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1586 != nil { - p.write(*flat1586) + flat1672 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1672 != nil { + p.write(*flat1672) return nil } else { _dollar_dollar := msg - fields1582 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} - unwrapped_fields1583 := fields1582 -======= - flat1664 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1664 != nil { - p.write(*flat1664) - return nil - } else { - _dollar_dollar := msg - fields1660 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} - unwrapped_fields1661 := fields1660 ->>>>>>> origin/main + fields1668 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} + unwrapped_fields1669 := fields1668 p.write("(") p.write("column") p.indentSexp() p.newline() -<<<<<<< HEAD - field1584 := unwrapped_fields1583[0].(string) - p.write(p.formatStringValue(field1584)) + field1670 := unwrapped_fields1669[0].(string) + p.write(p.formatStringValue(field1670)) p.newline() - field1585 := unwrapped_fields1583[1].(*pb.RelationId) - p.pretty_relation_id(field1585) + field1671 := unwrapped_fields1669[1].(*pb.RelationId) + p.pretty_relation_id(field1671) p.dedent() p.write(")") } @@ -8929,24 +5170,17 @@ func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interf } func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { - flat1588 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) - if flat1588 != nil { - p.write(*flat1588) + flat1674 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1674 != nil { + p.write(*flat1674) return nil } else { - fields1587 := msg + fields1673 := msg p.write("(") p.write("path") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1587)) -======= - field1662 := unwrapped_fields1661[0].(string) - p.write(p.formatStringValue(field1662)) - p.newline() - field1663 := unwrapped_fields1661[1].(*pb.RelationId) - p.pretty_relation_id(field1663) ->>>>>>> origin/main + p.write(p.formatStringValue(fields1673)) p.dedent() p.write(")") } @@ -8954,41 +5188,22 @@ func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { } func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn) interface{} { -<<<<<<< HEAD - flat1592 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) - if flat1592 != nil { - p.write(*flat1592) - return nil - } else { - fields1589 := msg - p.write("(") - p.write("columns") - p.indentSexp() - if !(len(fields1589) == 0) { - p.newline() - for i1591, elem1590 := range fields1589 { - if (i1591 > 0) { - p.newline() - } - p.pretty_export_csv_column(elem1590) -======= - flat1668 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) - if flat1668 != nil { - p.write(*flat1668) + flat1678 := p.tryFlat(msg, func() { p.pretty_export_csv_columns_list(msg) }) + if flat1678 != nil { + p.write(*flat1678) return nil } else { - fields1665 := msg + fields1675 := msg p.write("(") p.write("columns") p.indentSexp() - if !(len(fields1665) == 0) { + if !(len(fields1675) == 0) { p.newline() - for i1667, elem1666 := range fields1665 { - if (i1667 > 0) { + for i1677, elem1676 := range fields1675 { + if (i1677 > 0) { p.newline() } - p.pretty_export_csv_column(elem1666) ->>>>>>> origin/main + p.pretty_export_csv_column(elem1676) } } p.dedent() @@ -8998,66 +5213,35 @@ func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn } func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig) interface{} { -<<<<<<< HEAD - flat1601 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) - if flat1601 != nil { - p.write(*flat1601) - return nil - } else { - _dollar_dollar := msg - _t1754 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1593 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1754} - unwrapped_fields1594 := fields1593 -======= - flat1677 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) - if flat1677 != nil { - p.write(*flat1677) + flat1687 := p.tryFlat(msg, func() { p.pretty_export_iceberg_config(msg) }) + if flat1687 != nil { + p.write(*flat1687) return nil } else { _dollar_dollar := msg - _t1831 := p.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1669 := []interface{}{_dollar_dollar.GetLocator(), _dollar_dollar.GetConfig(), _dollar_dollar.GetTableDef(), dictToPairs(_dollar_dollar.GetTableProperties()), _t1831} - unwrapped_fields1670 := fields1669 ->>>>>>> origin/main + _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 p.write("(") p.write("export_iceberg_config") p.indentSexp() p.newline() -<<<<<<< HEAD - field1595 := unwrapped_fields1594[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1595) + field1681 := unwrapped_fields1680[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1681) p.newline() - field1596 := unwrapped_fields1594[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1596) + field1682 := unwrapped_fields1680[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1682) p.newline() - field1597 := unwrapped_fields1594[2].(*pb.RelationId) - p.pretty_export_iceberg_table_def(field1597) + field1683 := unwrapped_fields1680[2].(*pb.RelationId) + p.pretty_export_iceberg_table_def(field1683) p.newline() - field1598 := unwrapped_fields1594[3].([][]interface{}) - p.pretty_iceberg_table_properties(field1598) - field1599 := unwrapped_fields1594[4].([][]interface{}) - if field1599 != nil { - p.newline() - opt_val1600 := field1599 - p.pretty_config_dict(opt_val1600) -======= - field1671 := unwrapped_fields1670[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1671) - p.newline() - field1672 := unwrapped_fields1670[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1672) - p.newline() - field1673 := unwrapped_fields1670[2].(*pb.RelationId) - p.pretty_export_iceberg_table_def(field1673) - p.newline() - field1674 := unwrapped_fields1670[3].([][]interface{}) - p.pretty_iceberg_table_properties(field1674) - field1675 := unwrapped_fields1670[4].([][]interface{}) - if field1675 != nil { + field1684 := unwrapped_fields1680[3].([][]interface{}) + p.pretty_iceberg_table_properties(field1684) + field1685 := unwrapped_fields1680[4].([][]interface{}) + if field1685 != nil { p.newline() - opt_val1676 := field1675 - p.pretty_config_dict(opt_val1676) ->>>>>>> origin/main + opt_val1686 := field1685 + p.pretty_config_dict(opt_val1686) } p.dedent() p.write(")") @@ -9066,30 +5250,17 @@ func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig } func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) interface{} { -<<<<<<< HEAD - flat1603 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) - if flat1603 != nil { - p.write(*flat1603) - return nil - } else { - fields1602 := msg -======= - flat1679 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) - if flat1679 != nil { - p.write(*flat1679) + flat1689 := p.tryFlat(msg, func() { p.pretty_export_iceberg_table_def(msg) }) + if flat1689 != nil { + p.write(*flat1689) return nil } else { - fields1678 := msg ->>>>>>> origin/main + fields1688 := msg p.write("(") p.write("table_def") p.indentSexp() p.newline() -<<<<<<< HEAD - p.pretty_relation_id(fields1602) -======= - p.pretty_relation_id(fields1678) ->>>>>>> origin/main + p.pretty_relation_id(fields1688) p.dedent() p.write(")") } @@ -9097,41 +5268,22 @@ func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) inte } func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) interface{} { -<<<<<<< HEAD - flat1607 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) - if flat1607 != nil { - p.write(*flat1607) - return nil - } else { - fields1604 := msg - p.write("(") - p.write("table_properties") - p.indentSexp() - if !(len(fields1604) == 0) { - p.newline() - for i1606, elem1605 := range fields1604 { - if (i1606 > 0) { - p.newline() - } - p.pretty_iceberg_property_entry(elem1605) -======= - flat1683 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) - if flat1683 != nil { - p.write(*flat1683) + flat1693 := p.tryFlat(msg, func() { p.pretty_iceberg_table_properties(msg) }) + if flat1693 != nil { + p.write(*flat1693) return nil } else { - fields1680 := msg + fields1690 := msg p.write("(") p.write("table_properties") p.indentSexp() - if !(len(fields1680) == 0) { + if !(len(fields1690) == 0) { p.newline() - for i1682, elem1681 := range fields1680 { - if (i1682 > 0) { + for i1692, elem1691 := range fields1690 { + if (i1692 > 0) { p.newline() } - p.pretty_iceberg_property_entry(elem1681) ->>>>>>> origin/main + p.pretty_iceberg_property_entry(elem1691) } } p.dedent() @@ -9149,13 +5301,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") -<<<<<<< HEAD - _t1806 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1806) -======= - _t1885 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1885) ->>>>>>> origin/main + _t1898 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} + p.pprintDispatch(_t1898) p.write(" ") p.write(p.formatStringValue(msg.GetOrigNames()[_idx])) p.write(")") diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index 2c3df2a2..f8d74db1 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -424,393 +424,219 @@ def relation_id_to_uint128(self, msg): def _extract_value_int32(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None -<<<<<<< HEAD - _t2100 = value.HasField("int32_value") + _t2199 = value.HasField("int32_value") else: - _t2100 = False - if _t2100: - assert value is not None - return value.int32_value - else: - _t2101 = None -======= - _t2187 = value.HasField("int32_value") - else: - _t2187 = False - if _t2187: + _t2199 = False + if _t2199: assert value is not None return value.int32_value else: - _t2188 = None ->>>>>>> origin/main + _t2200 = None return int(default) def _extract_value_int64(self, value: logic_pb2.Value | None, default: int) -> int: if value is not None: assert value is not None -<<<<<<< HEAD - _t2102 = value.HasField("int_value") - else: - _t2102 = False - if _t2102: - assert value is not None - return value.int_value + _t2201 = value.HasField("int_value") else: - _t2103 = None -======= - _t2189 = value.HasField("int_value") - else: - _t2189 = False - if _t2189: + _t2201 = False + if _t2201: assert value is not None return value.int_value else: - _t2190 = None ->>>>>>> origin/main + _t2202 = 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 -<<<<<<< HEAD - _t2104 = value.HasField("string_value") - else: - _t2104 = False - if _t2104: - assert value is not None - return value.string_value - else: - _t2105 = None -======= - _t2191 = value.HasField("string_value") + _t2203 = value.HasField("string_value") else: - _t2191 = False - if _t2191: + _t2203 = False + if _t2203: assert value is not None return value.string_value else: - _t2192 = None ->>>>>>> origin/main + _t2204 = 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 -<<<<<<< HEAD - _t2106 = value.HasField("boolean_value") - else: - _t2106 = False - if _t2106: - assert value is not None - return value.boolean_value + _t2205 = value.HasField("boolean_value") else: - _t2107 = None -======= - _t2193 = value.HasField("boolean_value") - else: - _t2193 = False - if _t2193: + _t2205 = False + if _t2205: assert value is not None return value.boolean_value else: - _t2194 = None ->>>>>>> origin/main + _t2206 = 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 -<<<<<<< HEAD - _t2108 = value.HasField("string_value") - else: - _t2108 = False - if _t2108: - assert value is not None - return [value.string_value] - else: - _t2109 = None -======= - _t2195 = value.HasField("string_value") + _t2207 = value.HasField("string_value") else: - _t2195 = False - if _t2195: + _t2207 = False + if _t2207: assert value is not None return [value.string_value] else: - _t2196 = None ->>>>>>> origin/main + _t2208 = 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 -<<<<<<< HEAD - _t2110 = value.HasField("int_value") - else: - _t2110 = False - if _t2110: - assert value is not None - return value.int_value - else: - _t2111 = None -======= - _t2197 = value.HasField("int_value") + _t2209 = value.HasField("int_value") else: - _t2197 = False - if _t2197: + _t2209 = False + if _t2209: assert value is not None return value.int_value else: - _t2198 = None ->>>>>>> origin/main + _t2210 = 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 -<<<<<<< HEAD - _t2112 = value.HasField("float_value") - else: - _t2112 = False - if _t2112: - assert value is not None - return value.float_value - else: - _t2113 = None -======= - _t2199 = value.HasField("float_value") + _t2211 = value.HasField("float_value") else: - _t2199 = False - if _t2199: + _t2211 = False + if _t2211: assert value is not None return value.float_value else: - _t2200 = None ->>>>>>> origin/main + _t2212 = 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 -<<<<<<< HEAD - _t2114 = value.HasField("string_value") - else: - _t2114 = False - if _t2114: - assert value is not None - return value.string_value.encode() + _t2213 = value.HasField("string_value") else: - _t2115 = None -======= - _t2201 = value.HasField("string_value") - else: - _t2201 = False - if _t2201: + _t2213 = False + if _t2213: assert value is not None return value.string_value.encode() else: - _t2202 = None ->>>>>>> origin/main + _t2214 = 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 -<<<<<<< HEAD - _t2116 = value.HasField("uint128_value") + _t2215 = value.HasField("uint128_value") else: - _t2116 = False - if _t2116: + _t2215 = False + if _t2215: assert value is not None return value.uint128_value else: - _t2117 = None -======= - _t2203 = value.HasField("uint128_value") - else: - _t2203 = False - if _t2203: - assert value is not None - return value.uint128_value - else: - _t2204 = None ->>>>>>> origin/main + _t2216 = None return None def construct_non_cdc_relations(self, targets: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2205 = logic_pb2.PlainTargets(targets=targets) - _t2206 = logic_pb2.TargetRelations(keys=[], plain=_t2205) - return _t2206 + _t2217 = logic_pb2.PlainTargets(targets=targets) + _t2218 = logic_pb2.TargetRelations(keys=[], plain=_t2217) + return _t2218 def construct_cdc_relations(self, inserts: Sequence[logic_pb2.TargetRelation], deletes: Sequence[logic_pb2.TargetRelation]) -> logic_pb2.TargetRelations: - _t2207 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) - _t2208 = logic_pb2.TargetRelations(keys=[], cdc=_t2207) - return _t2208 + _t2219 = logic_pb2.CDCTargets(inserts=inserts, deletes=deletes) + _t2220 = logic_pb2.TargetRelations(keys=[], cdc=_t2219) + return _t2220 def construct_relations(self, keys: Sequence[logic_pb2.NamedColumn], body: logic_pb2.TargetRelations) -> logic_pb2.TargetRelations: if body.HasField("plain"): - _t2210 = logic_pb2.TargetRelations(keys=keys, plain=body.plain) - return _t2210 + _t2222 = logic_pb2.TargetRelations(keys=keys, plain=body.plain) + return _t2222 else: - _t2209 = None - _t2211 = logic_pb2.TargetRelations(keys=keys, cdc=body.cdc) - return _t2211 + _t2221 = None + _t2223 = logic_pb2.TargetRelations(keys=keys, cdc=body.cdc) + return _t2223 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: - _t2212 = logic_pb2.CSVData(locator=locator, config=config, columns=(columns_opt if columns_opt is not None else []), asof=asof, relations=relations_opt) - return _t2212 + _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 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) -<<<<<<< HEAD - _t2118 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2118 - _t2119 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2119 - _t2120 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2120 - _t2121 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2121 - _t2122 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2122 - _t2123 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2123 - _t2124 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2124 - _t2125 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2125 - _t2126 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2126 - _t2127 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2127 - _t2128 = self._extract_value_string(config.get("csv_compression"), "") - compression = _t2128 - _t2129 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2129 - _t2130 = self.construct_csv_storage_integration(storage_integration_opt) - storage_integration = _t2130 - _t2131 = 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 _t2131 -======= - _t2213 = self._extract_value_int32(config.get("csv_header_row"), 1) - header_row = _t2213 - _t2214 = self._extract_value_int64(config.get("csv_skip"), 0) - skip = _t2214 - _t2215 = self._extract_value_string(config.get("csv_new_line"), "") - new_line = _t2215 - _t2216 = self._extract_value_string(config.get("csv_delimiter"), ",") - delimiter = _t2216 - _t2217 = self._extract_value_string(config.get("csv_quotechar"), '"') - quotechar = _t2217 - _t2218 = self._extract_value_string(config.get("csv_escapechar"), '"') - escapechar = _t2218 - _t2219 = self._extract_value_string(config.get("csv_comment"), "") - comment = _t2219 - _t2220 = self._extract_value_string_list(config.get("csv_missing_strings"), []) - missing_strings = _t2220 - _t2221 = self._extract_value_string(config.get("csv_decimal_separator"), ".") - decimal_separator = _t2221 - _t2222 = self._extract_value_string(config.get("csv_encoding"), "utf-8") - encoding = _t2222 - _t2223 = self._extract_value_string(config.get("csv_compression"), "") - compression = _t2223 - _t2224 = self._extract_value_int64(config.get("csv_partition_size_mb"), 0) - partition_size_mb = _t2224 - _t2225 = self.construct_csv_storage_integration(storage_integration_opt) - storage_integration = _t2225 - _t2226 = 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 _t2226 ->>>>>>> origin/main + _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 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: -<<<<<<< HEAD - _t2132 = None - assert storage_integration_opt is not None - config = dict(storage_integration_opt) - _t2133 = self._extract_value_string(config.get("provider"), "") - _t2134 = self._extract_value_string(config.get("azure_sas_token"), "") - _t2135 = self._extract_value_string(config.get("s3_region"), "") - _t2136 = self._extract_value_string(config.get("s3_access_key_id"), "") - _t2137 = self._extract_value_string(config.get("s3_secret_access_key"), "") - _t2138 = logic_pb2.StorageIntegration(provider=_t2133, azure_sas_token=_t2134, s3_region=_t2135, s3_access_key_id=_t2136, s3_secret_access_key=_t2137) - return _t2138 - - 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) - _t2139 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2139 - _t2140 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2140 - _t2141 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2141 - _t2142 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2142 - _t2143 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2143 - _t2144 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2144 - _t2145 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2145 - _t2146 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2146 - _t2147 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2147 - _t2148 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2148 - _t2149 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2149 - - def default_configure(self) -> transactions_pb2.Configure: - _t2150 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2150 - _t2151 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2151 -======= - _t2227 = None + _t2239 = None assert storage_integration_opt is not None config = dict(storage_integration_opt) - _t2228 = self._extract_value_string(config.get("provider"), "") - _t2229 = self._extract_value_string(config.get("azure_sas_token"), "") - _t2230 = self._extract_value_string(config.get("s3_region"), "") - _t2231 = self._extract_value_string(config.get("s3_access_key_id"), "") - _t2232 = self._extract_value_string(config.get("s3_secret_access_key"), "") - _t2233 = logic_pb2.StorageIntegration(provider=_t2228, azure_sas_token=_t2229, s3_region=_t2230, s3_access_key_id=_t2231, s3_secret_access_key=_t2232) - return _t2233 + _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 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) - _t2234 = self._try_extract_value_float64(config.get("betree_config_epsilon")) - epsilon = _t2234 - _t2235 = self._try_extract_value_int64(config.get("betree_config_max_pivots")) - max_pivots = _t2235 - _t2236 = self._try_extract_value_int64(config.get("betree_config_max_deltas")) - max_deltas = _t2236 - _t2237 = self._try_extract_value_int64(config.get("betree_config_max_leaf")) - max_leaf = _t2237 - _t2238 = logic_pb2.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2238 - _t2239 = self._try_extract_value_uint128(config.get("betree_locator_root_pageid")) - root_pageid = _t2239 - _t2240 = self._try_extract_value_bytes(config.get("betree_locator_inline_data")) - inline_data = _t2240 - _t2241 = self._try_extract_value_int64(config.get("betree_locator_element_count")) - element_count = _t2241 - _t2242 = self._try_extract_value_int64(config.get("betree_locator_tree_height")) - tree_height = _t2242 - _t2243 = logic_pb2.BeTreeLocator(root_pageid=root_pageid, inline_data=inline_data, element_count=element_count, tree_height=tree_height) - relation_locator = _t2243 - _t2244 = logic_pb2.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2244 + _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 def default_configure(self) -> transactions_pb2.Configure: - _t2245 = transactions_pb2.IVMConfig(level=transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2245 - _t2246 = transactions_pb2.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2246 ->>>>>>> origin/main + _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 def construct_configure(self, config_dict: Sequence[tuple[str, logic_pb2.Value]]) -> transactions_pb2.Configure: config = dict(config_dict) @@ -827,6902 +653,3553 @@ 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 -<<<<<<< HEAD - _t2152 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2152 - _t2153 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2153 - _t2154 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2154 + _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 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) - _t2155 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2155 - _t2156 = self._extract_value_string(config.get("compression"), "") - compression = _t2156 - _t2157 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2157 - _t2158 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2158 - _t2159 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2159 - _t2160 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2160 - _t2161 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2161 - _t2162 = 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 _t2162 + _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 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: - _t2163 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) - return _t2163 -======= - _t2247 = transactions_pb2.IVMConfig(level=maintenance_level) - ivm_config = _t2247 - _t2248 = self._extract_value_int64(config.get("semantics_version"), 0) - semantics_version = _t2248 - _t2249 = transactions_pb2.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2249 - - 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) - _t2250 = self._extract_value_int64(config.get("partition_size"), 0) - partition_size = _t2250 - _t2251 = self._extract_value_string(config.get("compression"), "") - compression = _t2251 - _t2252 = self._extract_value_boolean(config.get("syntax_header_row"), True) - syntax_header_row = _t2252 - _t2253 = self._extract_value_string(config.get("syntax_missing_string"), "") - syntax_missing_string = _t2253 - _t2254 = self._extract_value_string(config.get("syntax_delim"), ",") - syntax_delim = _t2254 - _t2255 = self._extract_value_string(config.get("syntax_quotechar"), '"') - syntax_quotechar = _t2255 - _t2256 = self._extract_value_string(config.get("syntax_escapechar"), "\\") - syntax_escapechar = _t2256 - _t2257 = 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 _t2257 - - def construct_export_csv_config_with_source(self, path: str, csv_source: transactions_pb2.ExportCSVSource, csv_config: logic_pb2.CSVConfig) -> transactions_pb2.ExportCSVConfig: - _t2258 = transactions_pb2.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2258 ->>>>>>> origin/main + _t2270 = transactions_pb2.ExportCSVConfig(path=location[0], transaction_output_name=location[1], csv_source=csv_source, csv_config=csv_config) + return _t2270 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) -<<<<<<< HEAD - _t2164 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2164 - - 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: - _t2165 = 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 _t2165 - - 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 [])) - _t2166 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2166 - _t2167 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2167 - _t2168 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2168 - table_props = dict(table_property_pairs) - _t2169 = 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 _t2169 -======= - _t2259 = logic_pb2.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(scope_opt if scope_opt is not None else ""), properties=props, auth_properties=auth_props) - return _t2259 + _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 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: - _t2260 = 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 _t2260 + _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 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 [])) - _t2261 = self._extract_value_string(cfg.get("prefix"), "") - prefix = _t2261 - _t2262 = self._extract_value_int64(cfg.get("target_file_size_bytes"), 0) - target_file_size_bytes = _t2262 - _t2263 = self._extract_value_string(cfg.get("compression"), "") - compression = _t2263 + _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 table_props = dict(table_property_pairs) - _t2264 = 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 _t2264 ->>>>>>> origin/main + _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 # --- Parse methods --- def parse_transaction(self) -> transactions_pb2.Transaction: -<<<<<<< HEAD - span_start676 = self.span_start() - self.consume_literal("(") - self.consume_literal("transaction") - if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t1341 = self.parse_configure() - _t1340 = _t1341 - else: - _t1340 = None - configure670 = _t1340 - if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t1343 = self.parse_sync() - _t1342 = _t1343 - else: - _t1342 = None - sync671 = _t1342 - xs672 = [] - cond673 = self.match_lookahead_literal("(", 0) - while cond673: - _t1344 = self.parse_epoch() - item674 = _t1344 - xs672.append(item674) - cond673 = self.match_lookahead_literal("(", 0) - epochs675 = xs672 - self.consume_literal(")") - _t1345 = self.default_configure() - _t1346 = transactions_pb2.Transaction(epochs=epochs675, configure=(configure670 if configure670 is not None else _t1345), sync=sync671) - result677 = _t1346 - self.record_span(span_start676, "Transaction") - return result677 - - def parse_configure(self) -> transactions_pb2.Configure: - span_start679 = self.span_start() - self.consume_literal("(") - self.consume_literal("configure") - _t1347 = self.parse_config_dict() - config_dict678 = _t1347 - self.consume_literal(")") - _t1348 = self.construct_configure(config_dict678) - result680 = _t1348 - self.record_span(span_start679, "Configure") - return result680 - - def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: - self.consume_literal("{") - xs681 = [] - cond682 = self.match_lookahead_literal(":", 0) - while cond682: - _t1349 = self.parse_config_key_value() - item683 = _t1349 - xs681.append(item683) - cond682 = self.match_lookahead_literal(":", 0) - config_key_values684 = xs681 - self.consume_literal("}") - return config_key_values684 - - def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: - self.consume_literal(":") - symbol685 = self.consume_terminal("SYMBOL") - _t1350 = self.parse_raw_value() - raw_value686 = _t1350 - return (symbol685, raw_value686,) - - def parse_raw_value(self) -> logic_pb2.Value: - span_start700 = self.span_start() - if self.match_lookahead_literal("true", 0): - _t1351 = 12 - else: - if self.match_lookahead_literal("missing", 0): - _t1352 = 11 - else: - if self.match_lookahead_literal("false", 0): - _t1353 = 12 - else: - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("datetime", 1): - _t1355 = 1 - else: - if self.match_lookahead_literal("date", 1): - _t1356 = 0 - else: - _t1356 = -1 - _t1355 = _t1356 - _t1354 = _t1355 - else: - if self.match_lookahead_terminal("UINT32", 0): - _t1357 = 7 - else: - if self.match_lookahead_terminal("UINT128", 0): - _t1358 = 8 - else: - if self.match_lookahead_terminal("STRING", 0): - _t1359 = 2 - else: - if self.match_lookahead_terminal("INT32", 0): - _t1360 = 3 - else: - if self.match_lookahead_terminal("INT128", 0): - _t1361 = 9 - else: - if self.match_lookahead_terminal("INT", 0): - _t1362 = 4 - else: - if self.match_lookahead_terminal("FLOAT32", 0): - _t1363 = 5 - else: - if self.match_lookahead_terminal("FLOAT", 0): - _t1364 = 6 - else: - if self.match_lookahead_terminal("DECIMAL", 0): - _t1365 = 10 - else: - _t1365 = -1 - _t1364 = _t1365 - _t1363 = _t1364 - _t1362 = _t1363 - _t1361 = _t1362 - _t1360 = _t1361 - _t1359 = _t1360 - _t1358 = _t1359 - _t1357 = _t1358 - _t1354 = _t1357 - _t1353 = _t1354 - _t1352 = _t1353 - _t1351 = _t1352 - prediction687 = _t1351 - if prediction687 == 12: - _t1367 = self.parse_boolean_value() - boolean_value699 = _t1367 - _t1368 = logic_pb2.Value(boolean_value=boolean_value699) - _t1366 = _t1368 - else: - if prediction687 == 11: - self.consume_literal("missing") - _t1370 = logic_pb2.MissingValue() - _t1371 = logic_pb2.Value(missing_value=_t1370) - _t1369 = _t1371 - else: - if prediction687 == 10: - decimal698 = self.consume_terminal("DECIMAL") - _t1373 = logic_pb2.Value(decimal_value=decimal698) - _t1372 = _t1373 - else: - if prediction687 == 9: - int128697 = self.consume_terminal("INT128") - _t1375 = logic_pb2.Value(int128_value=int128697) - _t1374 = _t1375 - else: - if prediction687 == 8: - uint128696 = self.consume_terminal("UINT128") - _t1377 = logic_pb2.Value(uint128_value=uint128696) - _t1376 = _t1377 - else: - if prediction687 == 7: - uint32695 = self.consume_terminal("UINT32") - _t1379 = logic_pb2.Value(uint32_value=uint32695) - _t1378 = _t1379 - else: - if prediction687 == 6: - float694 = self.consume_terminal("FLOAT") - _t1381 = logic_pb2.Value(float_value=float694) - _t1380 = _t1381 - else: - if prediction687 == 5: - float32693 = self.consume_terminal("FLOAT32") - _t1383 = logic_pb2.Value(float32_value=float32693) - _t1382 = _t1383 - else: - if prediction687 == 4: - int692 = self.consume_terminal("INT") - _t1385 = logic_pb2.Value(int_value=int692) - _t1384 = _t1385 - else: - if prediction687 == 3: - int32691 = self.consume_terminal("INT32") - _t1387 = logic_pb2.Value(int32_value=int32691) - _t1386 = _t1387 - else: - if prediction687 == 2: - string690 = self.consume_terminal("STRING") - _t1389 = logic_pb2.Value(string_value=string690) - _t1388 = _t1389 - else: - if prediction687 == 1: - _t1391 = self.parse_raw_datetime() - raw_datetime689 = _t1391 - _t1392 = logic_pb2.Value(datetime_value=raw_datetime689) - _t1390 = _t1392 - else: - if prediction687 == 0: - _t1394 = self.parse_raw_date() - raw_date688 = _t1394 - _t1395 = logic_pb2.Value(date_value=raw_date688) - _t1393 = _t1395 - else: - raise ParseError("Unexpected token in raw_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1390 = _t1393 - _t1388 = _t1390 - _t1386 = _t1388 - _t1384 = _t1386 - _t1382 = _t1384 - _t1380 = _t1382 - _t1378 = _t1380 - _t1376 = _t1378 - _t1374 = _t1376 - _t1372 = _t1374 - _t1369 = _t1372 - _t1366 = _t1369 - result701 = _t1366 - self.record_span(span_start700, "Value") - return result701 - - def parse_raw_date(self) -> logic_pb2.DateValue: - span_start705 = self.span_start() - self.consume_literal("(") - self.consume_literal("date") - int702 = self.consume_terminal("INT") - int_3703 = self.consume_terminal("INT") - int_4704 = self.consume_terminal("INT") - self.consume_literal(")") - _t1396 = logic_pb2.DateValue(year=int(int702), month=int(int_3703), day=int(int_4704)) - result706 = _t1396 - self.record_span(span_start705, "DateValue") - return result706 - - def parse_raw_datetime(self) -> logic_pb2.DateTimeValue: - span_start714 = self.span_start() - self.consume_literal("(") - self.consume_literal("datetime") - int707 = self.consume_terminal("INT") - int_3708 = self.consume_terminal("INT") - int_4709 = self.consume_terminal("INT") - int_5710 = self.consume_terminal("INT") - int_6711 = self.consume_terminal("INT") - int_7712 = self.consume_terminal("INT") - if self.match_lookahead_terminal("INT", 0): - _t1397 = self.consume_terminal("INT") - else: - _t1397 = None - int_8713 = _t1397 - self.consume_literal(")") - _t1398 = logic_pb2.DateTimeValue(year=int(int707), month=int(int_3708), day=int(int_4709), hour=int(int_5710), minute=int(int_6711), second=int(int_7712), microsecond=int((int_8713 if int_8713 is not None else 0))) - result715 = _t1398 - self.record_span(span_start714, "DateTimeValue") - return result715 - - def parse_boolean_value(self) -> bool: - if self.match_lookahead_literal("true", 0): - _t1399 = 0 - else: - if self.match_lookahead_literal("false", 0): - _t1400 = 1 - else: - _t1400 = -1 - _t1399 = _t1400 - prediction716 = _t1399 - if prediction716 == 1: - self.consume_literal("false") - _t1401 = False - else: - if prediction716 == 0: - self.consume_literal("true") - _t1402 = True - else: - raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1401 = _t1402 - return _t1401 - - def parse_sync(self) -> transactions_pb2.Sync: - span_start721 = self.span_start() - self.consume_literal("(") - self.consume_literal("sync") - xs717 = [] - cond718 = self.match_lookahead_literal(":", 0) - while cond718: - _t1403 = self.parse_fragment_id() - item719 = _t1403 - xs717.append(item719) - cond718 = self.match_lookahead_literal(":", 0) - fragment_ids720 = xs717 - self.consume_literal(")") - _t1404 = transactions_pb2.Sync(fragments=fragment_ids720) - result722 = _t1404 - self.record_span(span_start721, "Sync") - return result722 -======= - span_start710 = self.span_start() + span_start713 = self.span_start() self.consume_literal("(") self.consume_literal("transaction") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("configure", 1)): - _t1409 = self.parse_configure() - _t1408 = _t1409 + _t1415 = self.parse_configure() + _t1414 = _t1415 else: - _t1408 = None - configure704 = _t1408 + _t1414 = None + configure707 = _t1414 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("sync", 1)): - _t1411 = self.parse_sync() - _t1410 = _t1411 - else: - _t1410 = None - sync705 = _t1410 - xs706 = [] - cond707 = self.match_lookahead_literal("(", 0) - while cond707: - _t1412 = self.parse_epoch() - item708 = _t1412 - xs706.append(item708) - cond707 = self.match_lookahead_literal("(", 0) - epochs709 = xs706 - self.consume_literal(")") - _t1413 = self.default_configure() - _t1414 = transactions_pb2.Transaction(epochs=epochs709, configure=(configure704 if configure704 is not None else _t1413), sync=sync705) - result711 = _t1414 - self.record_span(span_start710, "Transaction") - return result711 + _t1417 = self.parse_sync() + _t1416 = _t1417 + 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 + 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 def parse_configure(self) -> transactions_pb2.Configure: - span_start713 = self.span_start() + span_start716 = self.span_start() self.consume_literal("(") self.consume_literal("configure") - _t1415 = self.parse_config_dict() - config_dict712 = _t1415 + _t1421 = self.parse_config_dict() + config_dict715 = _t1421 self.consume_literal(")") - _t1416 = self.construct_configure(config_dict712) - result714 = _t1416 - self.record_span(span_start713, "Configure") - return result714 + _t1422 = self.construct_configure(config_dict715) + result717 = _t1422 + self.record_span(span_start716, "Configure") + return result717 def parse_config_dict(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("{") - xs715 = [] - cond716 = self.match_lookahead_literal(":", 0) - while cond716: - _t1417 = self.parse_config_key_value() - item717 = _t1417 - xs715.append(item717) - cond716 = self.match_lookahead_literal(":", 0) - config_key_values718 = xs715 + 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 self.consume_literal("}") - return config_key_values718 + return config_key_values721 def parse_config_key_value(self) -> tuple[str, logic_pb2.Value]: self.consume_literal(":") - symbol719 = self.consume_terminal("SYMBOL") - _t1418 = self.parse_raw_value() - raw_value720 = _t1418 - return (symbol719, raw_value720,) + symbol722 = self.consume_terminal("SYMBOL") + _t1424 = self.parse_raw_value() + raw_value723 = _t1424 + return (symbol722, raw_value723,) def parse_raw_value(self) -> logic_pb2.Value: - span_start734 = self.span_start() + span_start737 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1419 = 12 + _t1425 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1420 = 11 + _t1426 = 11 else: if self.match_lookahead_literal("false", 0): - _t1421 = 12 + _t1427 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1423 = 1 + _t1429 = 1 else: if self.match_lookahead_literal("date", 1): - _t1424 = 0 + _t1430 = 0 else: - _t1424 = -1 - _t1423 = _t1424 - _t1422 = _t1423 + _t1430 = -1 + _t1429 = _t1430 + _t1428 = _t1429 else: if self.match_lookahead_terminal("UINT32", 0): - _t1425 = 7 + _t1431 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1426 = 8 + _t1432 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1427 = 2 + _t1433 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1428 = 3 + _t1434 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1429 = 9 + _t1435 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1430 = 4 + _t1436 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1431 = 5 + _t1437 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1432 = 6 + _t1438 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1433 = 10 + _t1439 = 10 else: - _t1433 = -1 - _t1432 = _t1433 - _t1431 = _t1432 - _t1430 = _t1431 - _t1429 = _t1430 - _t1428 = _t1429 - _t1427 = _t1428 - _t1426 = _t1427 - _t1425 = _t1426 - _t1422 = _t1425 - _t1421 = _t1422 - _t1420 = _t1421 - _t1419 = _t1420 - prediction721 = _t1419 - if prediction721 == 12: - _t1435 = self.parse_boolean_value() - boolean_value733 = _t1435 - _t1436 = logic_pb2.Value(boolean_value=boolean_value733) - _t1434 = _t1436 - else: - if prediction721 == 11: + _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 + else: + if prediction724 == 11: self.consume_literal("missing") - _t1438 = logic_pb2.MissingValue() - _t1439 = logic_pb2.Value(missing_value=_t1438) - _t1437 = _t1439 + _t1444 = logic_pb2.MissingValue() + _t1445 = logic_pb2.Value(missing_value=_t1444) + _t1443 = _t1445 else: - if prediction721 == 10: - decimal732 = self.consume_terminal("DECIMAL") - _t1441 = logic_pb2.Value(decimal_value=decimal732) - _t1440 = _t1441 + if prediction724 == 10: + decimal735 = self.consume_terminal("DECIMAL") + _t1447 = logic_pb2.Value(decimal_value=decimal735) + _t1446 = _t1447 else: - if prediction721 == 9: - int128731 = self.consume_terminal("INT128") - _t1443 = logic_pb2.Value(int128_value=int128731) - _t1442 = _t1443 + if prediction724 == 9: + int128734 = self.consume_terminal("INT128") + _t1449 = logic_pb2.Value(int128_value=int128734) + _t1448 = _t1449 else: - if prediction721 == 8: - uint128730 = self.consume_terminal("UINT128") - _t1445 = logic_pb2.Value(uint128_value=uint128730) - _t1444 = _t1445 + if prediction724 == 8: + uint128733 = self.consume_terminal("UINT128") + _t1451 = logic_pb2.Value(uint128_value=uint128733) + _t1450 = _t1451 else: - if prediction721 == 7: - uint32729 = self.consume_terminal("UINT32") - _t1447 = logic_pb2.Value(uint32_value=uint32729) - _t1446 = _t1447 + if prediction724 == 7: + uint32732 = self.consume_terminal("UINT32") + _t1453 = logic_pb2.Value(uint32_value=uint32732) + _t1452 = _t1453 else: - if prediction721 == 6: - float728 = self.consume_terminal("FLOAT") - _t1449 = logic_pb2.Value(float_value=float728) - _t1448 = _t1449 + if prediction724 == 6: + float731 = self.consume_terminal("FLOAT") + _t1455 = logic_pb2.Value(float_value=float731) + _t1454 = _t1455 else: - if prediction721 == 5: - float32727 = self.consume_terminal("FLOAT32") - _t1451 = logic_pb2.Value(float32_value=float32727) - _t1450 = _t1451 + if prediction724 == 5: + float32730 = self.consume_terminal("FLOAT32") + _t1457 = logic_pb2.Value(float32_value=float32730) + _t1456 = _t1457 else: - if prediction721 == 4: - int726 = self.consume_terminal("INT") - _t1453 = logic_pb2.Value(int_value=int726) - _t1452 = _t1453 + if prediction724 == 4: + int729 = self.consume_terminal("INT") + _t1459 = logic_pb2.Value(int_value=int729) + _t1458 = _t1459 else: - if prediction721 == 3: - int32725 = self.consume_terminal("INT32") - _t1455 = logic_pb2.Value(int32_value=int32725) - _t1454 = _t1455 + if prediction724 == 3: + int32728 = self.consume_terminal("INT32") + _t1461 = logic_pb2.Value(int32_value=int32728) + _t1460 = _t1461 else: - if prediction721 == 2: - string724 = self.consume_terminal("STRING") - _t1457 = logic_pb2.Value(string_value=string724) - _t1456 = _t1457 + if prediction724 == 2: + string727 = self.consume_terminal("STRING") + _t1463 = logic_pb2.Value(string_value=string727) + _t1462 = _t1463 else: - if prediction721 == 1: - _t1459 = self.parse_raw_datetime() - raw_datetime723 = _t1459 - _t1460 = logic_pb2.Value(datetime_value=raw_datetime723) - _t1458 = _t1460 + if prediction724 == 1: + _t1465 = self.parse_raw_datetime() + raw_datetime726 = _t1465 + _t1466 = logic_pb2.Value(datetime_value=raw_datetime726) + _t1464 = _t1466 else: - if prediction721 == 0: - _t1462 = self.parse_raw_date() - raw_date722 = _t1462 - _t1463 = logic_pb2.Value(date_value=raw_date722) - _t1461 = _t1463 + if prediction724 == 0: + _t1468 = self.parse_raw_date() + raw_date725 = _t1468 + _t1469 = logic_pb2.Value(date_value=raw_date725) + _t1467 = _t1469 else: raise ParseError("Unexpected token in raw_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1458 = _t1461 - _t1456 = _t1458 - _t1454 = _t1456 - _t1452 = _t1454 - _t1450 = _t1452 - _t1448 = _t1450 - _t1446 = _t1448 - _t1444 = _t1446 - _t1442 = _t1444 - _t1440 = _t1442 - _t1437 = _t1440 - _t1434 = _t1437 - result735 = _t1434 - self.record_span(span_start734, "Value") - return result735 + _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 def parse_raw_date(self) -> logic_pb2.DateValue: - span_start739 = self.span_start() + span_start742 = self.span_start() self.consume_literal("(") self.consume_literal("date") - int736 = self.consume_terminal("INT") - int_3737 = self.consume_terminal("INT") - int_4738 = self.consume_terminal("INT") + int739 = self.consume_terminal("INT") + int_3740 = self.consume_terminal("INT") + int_4741 = self.consume_terminal("INT") self.consume_literal(")") - _t1464 = logic_pb2.DateValue(year=int(int736), month=int(int_3737), day=int(int_4738)) - result740 = _t1464 - self.record_span(span_start739, "DateValue") - return result740 + _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 def parse_raw_datetime(self) -> logic_pb2.DateTimeValue: - span_start748 = self.span_start() + span_start751 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - int741 = self.consume_terminal("INT") - int_3742 = self.consume_terminal("INT") - int_4743 = self.consume_terminal("INT") - int_5744 = self.consume_terminal("INT") - int_6745 = self.consume_terminal("INT") - int_7746 = self.consume_terminal("INT") + 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") if self.match_lookahead_terminal("INT", 0): - _t1465 = self.consume_terminal("INT") + _t1471 = self.consume_terminal("INT") else: - _t1465 = None - int_8747 = _t1465 + _t1471 = None + int_8750 = _t1471 self.consume_literal(")") - _t1466 = logic_pb2.DateTimeValue(year=int(int741), month=int(int_3742), day=int(int_4743), hour=int(int_5744), minute=int(int_6745), second=int(int_7746), microsecond=int((int_8747 if int_8747 is not None else 0))) - result749 = _t1466 - self.record_span(span_start748, "DateTimeValue") - return result749 + _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 def parse_boolean_value(self) -> bool: if self.match_lookahead_literal("true", 0): - _t1467 = 0 + _t1473 = 0 else: if self.match_lookahead_literal("false", 0): - _t1468 = 1 + _t1474 = 1 else: - _t1468 = -1 - _t1467 = _t1468 - prediction750 = _t1467 - if prediction750 == 1: + _t1474 = -1 + _t1473 = _t1474 + prediction753 = _t1473 + if prediction753 == 1: self.consume_literal("false") - _t1469 = False + _t1475 = False else: - if prediction750 == 0: + if prediction753 == 0: self.consume_literal("true") - _t1470 = True + _t1476 = True else: raise ParseError("Unexpected token in boolean_value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1469 = _t1470 - return _t1469 + _t1475 = _t1476 + return _t1475 def parse_sync(self) -> transactions_pb2.Sync: - span_start755 = self.span_start() + span_start758 = self.span_start() self.consume_literal("(") self.consume_literal("sync") - xs751 = [] - cond752 = self.match_lookahead_literal(":", 0) - while cond752: - _t1471 = self.parse_fragment_id() - item753 = _t1471 - xs751.append(item753) - cond752 = self.match_lookahead_literal(":", 0) - fragment_ids754 = xs751 - self.consume_literal(")") - _t1472 = transactions_pb2.Sync(fragments=fragment_ids754) - result756 = _t1472 - self.record_span(span_start755, "Sync") - return result756 - - def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start758 = self.span_start() - self.consume_literal(":") - symbol757 = self.consume_terminal("SYMBOL") - result759 = fragments_pb2.FragmentId(id=symbol757.encode()) - self.record_span(span_start758, "FragmentId") + 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 + self.consume_literal(")") + _t1478 = transactions_pb2.Sync(fragments=fragment_ids757) + result759 = _t1478 + self.record_span(span_start758, "Sync") return result759 ->>>>>>> origin/main def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start724 = self.span_start() + span_start761 = self.span_start() self.consume_literal(":") - symbol723 = self.consume_terminal("SYMBOL") - result725 = fragments_pb2.FragmentId(id=symbol723.encode()) - self.record_span(span_start724, "FragmentId") - return result725 + symbol760 = self.consume_terminal("SYMBOL") + result762 = fragments_pb2.FragmentId(id=symbol760.encode()) + self.record_span(span_start761, "FragmentId") + return result762 def parse_epoch(self) -> transactions_pb2.Epoch: -<<<<<<< HEAD - span_start728 = self.span_start() - self.consume_literal("(") - self.consume_literal("epoch") - if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t1406 = self.parse_epoch_writes() - _t1405 = _t1406 - else: - _t1405 = None - epoch_writes726 = _t1405 - if self.match_lookahead_literal("(", 0): - _t1408 = self.parse_epoch_reads() - _t1407 = _t1408 - else: - _t1407 = None - epoch_reads727 = _t1407 - self.consume_literal(")") - _t1409 = transactions_pb2.Epoch(writes=(epoch_writes726 if epoch_writes726 is not None else []), reads=(epoch_reads727 if epoch_reads727 is not None else [])) - result729 = _t1409 - self.record_span(span_start728, "Epoch") - return result729 -======= - span_start762 = self.span_start() + span_start765 = self.span_start() self.consume_literal("(") self.consume_literal("epoch") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("writes", 1)): - _t1474 = self.parse_epoch_writes() - _t1473 = _t1474 + _t1480 = self.parse_epoch_writes() + _t1479 = _t1480 else: - _t1473 = None - epoch_writes760 = _t1473 + _t1479 = None + epoch_writes763 = _t1479 if self.match_lookahead_literal("(", 0): - _t1476 = self.parse_epoch_reads() - _t1475 = _t1476 + _t1482 = self.parse_epoch_reads() + _t1481 = _t1482 else: - _t1475 = None - epoch_reads761 = _t1475 + _t1481 = None + epoch_reads764 = _t1481 self.consume_literal(")") - _t1477 = transactions_pb2.Epoch(writes=(epoch_writes760 if epoch_writes760 is not None else []), reads=(epoch_reads761 if epoch_reads761 is not None else [])) - result763 = _t1477 - self.record_span(span_start762, "Epoch") - return result763 ->>>>>>> origin/main + _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 def parse_epoch_writes(self) -> Sequence[transactions_pb2.Write]: self.consume_literal("(") self.consume_literal("writes") -<<<<<<< HEAD - xs730 = [] - cond731 = self.match_lookahead_literal("(", 0) - while cond731: - _t1410 = self.parse_write() - item732 = _t1410 - xs730.append(item732) - cond731 = self.match_lookahead_literal("(", 0) - writes733 = xs730 - self.consume_literal(")") - return writes733 - - def parse_write(self) -> transactions_pb2.Write: - span_start739 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("undefine", 1): - _t1412 = 1 - else: - if self.match_lookahead_literal("snapshot", 1): - _t1413 = 3 - else: - if self.match_lookahead_literal("define", 1): - _t1414 = 0 - else: - if self.match_lookahead_literal("context", 1): - _t1415 = 2 - else: - _t1415 = -1 - _t1414 = _t1415 - _t1413 = _t1414 - _t1412 = _t1413 - _t1411 = _t1412 - else: - _t1411 = -1 - prediction734 = _t1411 - if prediction734 == 3: - _t1417 = self.parse_snapshot() - snapshot738 = _t1417 - _t1418 = transactions_pb2.Write(snapshot=snapshot738) - _t1416 = _t1418 - else: - if prediction734 == 2: - _t1420 = self.parse_context() - context737 = _t1420 - _t1421 = transactions_pb2.Write(context=context737) - _t1419 = _t1421 - else: - if prediction734 == 1: - _t1423 = self.parse_undefine() - undefine736 = _t1423 - _t1424 = transactions_pb2.Write(undefine=undefine736) - _t1422 = _t1424 - else: - if prediction734 == 0: - _t1426 = self.parse_define() - define735 = _t1426 - _t1427 = transactions_pb2.Write(define=define735) - _t1425 = _t1427 - else: - raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1422 = _t1425 - _t1419 = _t1422 - _t1416 = _t1419 - result740 = _t1416 - self.record_span(span_start739, "Write") - return result740 -======= - xs764 = [] - cond765 = self.match_lookahead_literal("(", 0) - while cond765: - _t1478 = self.parse_write() - item766 = _t1478 - xs764.append(item766) - cond765 = self.match_lookahead_literal("(", 0) - writes767 = xs764 + 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 self.consume_literal(")") - return writes767 + return writes770 def parse_write(self) -> transactions_pb2.Write: - span_start773 = self.span_start() + span_start776 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("undefine", 1): - _t1480 = 1 + _t1486 = 1 else: if self.match_lookahead_literal("snapshot", 1): - _t1481 = 3 + _t1487 = 3 else: if self.match_lookahead_literal("define", 1): - _t1482 = 0 + _t1488 = 0 else: if self.match_lookahead_literal("context", 1): - _t1483 = 2 + _t1489 = 2 else: - _t1483 = -1 - _t1482 = _t1483 - _t1481 = _t1482 - _t1480 = _t1481 - _t1479 = _t1480 - else: - _t1479 = -1 - prediction768 = _t1479 - if prediction768 == 3: - _t1485 = self.parse_snapshot() - snapshot772 = _t1485 - _t1486 = transactions_pb2.Write(snapshot=snapshot772) - _t1484 = _t1486 - else: - if prediction768 == 2: - _t1488 = self.parse_context() - context771 = _t1488 - _t1489 = transactions_pb2.Write(context=context771) - _t1487 = _t1489 + _t1489 = -1 + _t1488 = _t1489 + _t1487 = _t1488 + _t1486 = _t1487 + _t1485 = _t1486 + else: + _t1485 = -1 + prediction771 = _t1485 + if prediction771 == 3: + _t1491 = self.parse_snapshot() + snapshot775 = _t1491 + _t1492 = transactions_pb2.Write(snapshot=snapshot775) + _t1490 = _t1492 + else: + if prediction771 == 2: + _t1494 = self.parse_context() + context774 = _t1494 + _t1495 = transactions_pb2.Write(context=context774) + _t1493 = _t1495 else: - if prediction768 == 1: - _t1491 = self.parse_undefine() - undefine770 = _t1491 - _t1492 = transactions_pb2.Write(undefine=undefine770) - _t1490 = _t1492 + if prediction771 == 1: + _t1497 = self.parse_undefine() + undefine773 = _t1497 + _t1498 = transactions_pb2.Write(undefine=undefine773) + _t1496 = _t1498 else: - if prediction768 == 0: - _t1494 = self.parse_define() - define769 = _t1494 - _t1495 = transactions_pb2.Write(define=define769) - _t1493 = _t1495 + if prediction771 == 0: + _t1500 = self.parse_define() + define772 = _t1500 + _t1501 = transactions_pb2.Write(define=define772) + _t1499 = _t1501 else: raise ParseError("Unexpected token in write" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1490 = _t1493 - _t1487 = _t1490 - _t1484 = _t1487 - result774 = _t1484 - self.record_span(span_start773, "Write") - return result774 - - def parse_define(self) -> transactions_pb2.Define: - span_start776 = self.span_start() - self.consume_literal("(") - self.consume_literal("define") - _t1496 = self.parse_fragment() - fragment775 = _t1496 - self.consume_literal(")") - _t1497 = transactions_pb2.Define(fragment=fragment775) - result777 = _t1497 - self.record_span(span_start776, "Define") + _t1496 = _t1499 + _t1493 = _t1496 + _t1490 = _t1493 + result777 = _t1490 + self.record_span(span_start776, "Write") return result777 ->>>>>>> origin/main def parse_define(self) -> transactions_pb2.Define: - span_start742 = self.span_start() + span_start779 = self.span_start() self.consume_literal("(") self.consume_literal("define") - _t1428 = self.parse_fragment() - fragment741 = _t1428 + _t1502 = self.parse_fragment() + fragment778 = _t1502 self.consume_literal(")") - _t1429 = transactions_pb2.Define(fragment=fragment741) - result743 = _t1429 - self.record_span(span_start742, "Define") - return result743 + _t1503 = transactions_pb2.Define(fragment=fragment778) + result780 = _t1503 + self.record_span(span_start779, "Define") + return result780 def parse_fragment(self) -> fragments_pb2.Fragment: -<<<<<<< HEAD - span_start749 = self.span_start() - self.consume_literal("(") - self.consume_literal("fragment") - _t1430 = self.parse_new_fragment_id() - new_fragment_id744 = _t1430 - xs745 = [] - cond746 = self.match_lookahead_literal("(", 0) - while cond746: - _t1431 = self.parse_declaration() - item747 = _t1431 - xs745.append(item747) - cond746 = self.match_lookahead_literal("(", 0) - declarations748 = xs745 - self.consume_literal(")") - result750 = self.construct_fragment(new_fragment_id744, declarations748) - self.record_span(span_start749, "Fragment") - return result750 -======= - span_start783 = self.span_start() + span_start786 = self.span_start() self.consume_literal("(") self.consume_literal("fragment") - _t1498 = self.parse_new_fragment_id() - new_fragment_id778 = _t1498 - xs779 = [] - cond780 = self.match_lookahead_literal("(", 0) - while cond780: - _t1499 = self.parse_declaration() - item781 = _t1499 - xs779.append(item781) - cond780 = self.match_lookahead_literal("(", 0) - declarations782 = xs779 - self.consume_literal(")") - result784 = self.construct_fragment(new_fragment_id778, declarations782) - self.record_span(span_start783, "Fragment") - return result784 - - def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - span_start786 = self.span_start() - _t1500 = self.parse_fragment_id() - fragment_id785 = _t1500 - self.start_fragment(fragment_id785) - result787 = fragment_id785 - self.record_span(span_start786, "FragmentId") + _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 + self.consume_literal(")") + result787 = self.construct_fragment(new_fragment_id781, declarations785) + self.record_span(span_start786, "Fragment") return result787 ->>>>>>> origin/main def parse_new_fragment_id(self) -> fragments_pb2.FragmentId: - span_start752 = self.span_start() - _t1432 = self.parse_fragment_id() - fragment_id751 = _t1432 - self.start_fragment(fragment_id751) - result753 = fragment_id751 - self.record_span(span_start752, "FragmentId") - return result753 + 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 def parse_declaration(self) -> logic_pb2.Declaration: -<<<<<<< HEAD - span_start759 = self.span_start() + span_start796 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1434 = 3 + _t1508 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t1435 = 2 + _t1509 = 2 else: if self.match_lookahead_literal("edb", 1): - _t1436 = 3 + _t1510 = 3 else: if self.match_lookahead_literal("def", 1): - _t1437 = 0 + _t1511 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1438 = 3 + _t1512 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t1439 = 3 + _t1513 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t1440 = 1 + _t1514 = 1 else: - _t1440 = -1 - _t1439 = _t1440 - _t1438 = _t1439 - _t1437 = _t1438 - _t1436 = _t1437 - _t1435 = _t1436 - _t1434 = _t1435 - _t1433 = _t1434 - else: - _t1433 = -1 - prediction754 = _t1433 - if prediction754 == 3: - _t1442 = self.parse_data() - data758 = _t1442 - _t1443 = logic_pb2.Declaration(data=data758) - _t1441 = _t1443 - else: - if prediction754 == 2: - _t1445 = self.parse_constraint() - constraint757 = _t1445 - _t1446 = logic_pb2.Declaration(constraint=constraint757) - _t1444 = _t1446 + _t1514 = -1 + _t1513 = _t1514 + _t1512 = _t1513 + _t1511 = _t1512 + _t1510 = _t1511 + _t1509 = _t1510 + _t1508 = _t1509 + _t1507 = _t1508 + else: + _t1507 = -1 + prediction791 = _t1507 + if prediction791 == 3: + _t1516 = self.parse_data() + data795 = _t1516 + _t1517 = logic_pb2.Declaration(data=data795) + _t1515 = _t1517 + else: + if prediction791 == 2: + _t1519 = self.parse_constraint() + constraint794 = _t1519 + _t1520 = logic_pb2.Declaration(constraint=constraint794) + _t1518 = _t1520 else: - if prediction754 == 1: - _t1448 = self.parse_algorithm() - algorithm756 = _t1448 - _t1449 = logic_pb2.Declaration(algorithm=algorithm756) - _t1447 = _t1449 + if prediction791 == 1: + _t1522 = self.parse_algorithm() + algorithm793 = _t1522 + _t1523 = logic_pb2.Declaration(algorithm=algorithm793) + _t1521 = _t1523 else: - if prediction754 == 0: - _t1451 = self.parse_def() - def755 = _t1451 - _t1452 = logic_pb2.Declaration() - getattr(_t1452, 'def').CopyFrom(def755) - _t1450 = _t1452 + if prediction791 == 0: + _t1525 = self.parse_def() + def792 = _t1525 + _t1526 = logic_pb2.Declaration() + getattr(_t1526, 'def').CopyFrom(def792) + _t1524 = _t1526 else: raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1447 = _t1450 - _t1444 = _t1447 - _t1441 = _t1444 - result760 = _t1441 - self.record_span(span_start759, "Declaration") - return result760 + _t1521 = _t1524 + _t1518 = _t1521 + _t1515 = _t1518 + result797 = _t1515 + self.record_span(span_start796, "Declaration") + return result797 def parse_def(self) -> logic_pb2.Def: - span_start764 = self.span_start() + span_start801 = self.span_start() self.consume_literal("(") self.consume_literal("def") - _t1453 = self.parse_relation_id() - relation_id761 = _t1453 - _t1454 = self.parse_abstraction() - abstraction762 = _t1454 + _t1527 = self.parse_relation_id() + relation_id798 = _t1527 + _t1528 = self.parse_abstraction() + abstraction799 = _t1528 if self.match_lookahead_literal("(", 0): - _t1456 = self.parse_attrs() - _t1455 = _t1456 + _t1530 = self.parse_attrs() + _t1529 = _t1530 else: - _t1455 = None - attrs763 = _t1455 + _t1529 = None + attrs800 = _t1529 self.consume_literal(")") - _t1457 = logic_pb2.Def(name=relation_id761, body=abstraction762, attrs=(attrs763 if attrs763 is not None else [])) - result765 = _t1457 - self.record_span(span_start764, "Def") - return result765 + _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 def parse_relation_id(self) -> logic_pb2.RelationId: - span_start769 = self.span_start() + span_start806 = self.span_start() if self.match_lookahead_literal(":", 0): - _t1458 = 0 + _t1532 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1459 = 1 + _t1533 = 1 else: - _t1459 = -1 - _t1458 = _t1459 - prediction766 = _t1458 - if prediction766 == 1: - uint128768 = self.consume_terminal("UINT128") - _t1460 = logic_pb2.RelationId(id_low=uint128768.low, id_high=uint128768.high) - else: - if prediction766 == 0: + _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) + else: + if prediction803 == 0: self.consume_literal(":") - symbol767 = self.consume_terminal("SYMBOL") - _t1461 = self.relation_id_from_string(symbol767) + symbol804 = self.consume_terminal("SYMBOL") + _t1535 = self.relation_id_from_string(symbol804) else: raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1460 = _t1461 - result770 = _t1460 - self.record_span(span_start769, "RelationId") - return result770 + _t1534 = _t1535 + result807 = _t1534 + self.record_span(span_start806, "RelationId") + return result807 def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start773 = self.span_start() + span_start810 = self.span_start() self.consume_literal("(") - _t1462 = self.parse_bindings() - bindings771 = _t1462 - _t1463 = self.parse_formula() - formula772 = _t1463 + _t1536 = self.parse_bindings() + bindings808 = _t1536 + _t1537 = self.parse_formula() + formula809 = _t1537 self.consume_literal(")") - _t1464 = logic_pb2.Abstraction(vars=(list(bindings771[0]) + list(bindings771[1] if bindings771[1] is not None else [])), value=formula772) - result774 = _t1464 - self.record_span(span_start773, "Abstraction") - return result774 + _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 def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: self.consume_literal("[") - xs775 = [] - cond776 = self.match_lookahead_terminal("SYMBOL", 0) - while cond776: - _t1465 = self.parse_binding() - item777 = _t1465 - xs775.append(item777) - cond776 = self.match_lookahead_terminal("SYMBOL", 0) - bindings778 = xs775 + 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 if self.match_lookahead_literal("|", 0): - _t1467 = self.parse_value_bindings() - _t1466 = _t1467 + _t1541 = self.parse_value_bindings() + _t1540 = _t1541 else: - _t1466 = None - value_bindings779 = _t1466 + _t1540 = None + value_bindings816 = _t1540 self.consume_literal("]") - return (bindings778, (value_bindings779 if value_bindings779 is not None else []),) + return (bindings815, (value_bindings816 if value_bindings816 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - span_start782 = self.span_start() - symbol780 = self.consume_terminal("SYMBOL") + span_start819 = self.span_start() + symbol817 = self.consume_terminal("SYMBOL") self.consume_literal("::") - _t1468 = self.parse_type() - type781 = _t1468 - _t1469 = logic_pb2.Var(name=symbol780) - _t1470 = logic_pb2.Binding(var=_t1469, type=type781) - result783 = _t1470 - self.record_span(span_start782, "Binding") - return result783 + _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 def parse_type(self) -> logic_pb2.Type: - span_start799 = self.span_start() + span_start836 = self.span_start() if self.match_lookahead_literal("UNKNOWN", 0): - _t1471 = 0 + _t1545 = 0 else: if self.match_lookahead_literal("UINT32", 0): - _t1472 = 13 + _t1546 = 13 else: if self.match_lookahead_literal("UINT128", 0): - _t1473 = 4 + _t1547 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t1474 = 1 + _t1548 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t1475 = 8 + _t1549 = 8 else: if self.match_lookahead_literal("INT32", 0): - _t1476 = 11 + _t1550 = 11 else: if self.match_lookahead_literal("INT128", 0): - _t1477 = 5 + _t1551 = 5 else: if self.match_lookahead_literal("INT", 0): - _t1478 = 2 + _t1552 = 2 else: if self.match_lookahead_literal("FLOAT32", 0): - _t1479 = 12 + _t1553 = 12 else: if self.match_lookahead_literal("FLOAT", 0): - _t1480 = 3 + _t1554 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t1481 = 7 + _t1555 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t1482 = 6 + _t1556 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t1483 = 10 + _t1557 = 10 else: if self.match_lookahead_literal("(", 0): - _t1484 = 9 + _t1558 = 9 else: - _t1484 = -1 - _t1483 = _t1484 - _t1482 = _t1483 - _t1481 = _t1482 - _t1480 = _t1481 - _t1479 = _t1480 - _t1478 = _t1479 - _t1477 = _t1478 - _t1476 = _t1477 - _t1475 = _t1476 - _t1474 = _t1475 - _t1473 = _t1474 - _t1472 = _t1473 - _t1471 = _t1472 - prediction784 = _t1471 - if prediction784 == 13: - _t1486 = self.parse_uint32_type() - uint32_type798 = _t1486 - _t1487 = logic_pb2.Type(uint32_type=uint32_type798) - _t1485 = _t1487 - else: - if prediction784 == 12: - _t1489 = self.parse_float32_type() - float32_type797 = _t1489 - _t1490 = logic_pb2.Type(float32_type=float32_type797) - _t1488 = _t1490 + _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 + else: + if prediction821 == 12: + _t1563 = self.parse_float32_type() + float32_type834 = _t1563 + _t1564 = logic_pb2.Type(float32_type=float32_type834) + _t1562 = _t1564 else: - if prediction784 == 11: - _t1492 = self.parse_int32_type() - int32_type796 = _t1492 - _t1493 = logic_pb2.Type(int32_type=int32_type796) - _t1491 = _t1493 + if prediction821 == 11: + _t1566 = self.parse_int32_type() + int32_type833 = _t1566 + _t1567 = logic_pb2.Type(int32_type=int32_type833) + _t1565 = _t1567 else: - if prediction784 == 10: - _t1495 = self.parse_boolean_type() - boolean_type795 = _t1495 - _t1496 = logic_pb2.Type(boolean_type=boolean_type795) - _t1494 = _t1496 + if prediction821 == 10: + _t1569 = self.parse_boolean_type() + boolean_type832 = _t1569 + _t1570 = logic_pb2.Type(boolean_type=boolean_type832) + _t1568 = _t1570 else: - if prediction784 == 9: - _t1498 = self.parse_decimal_type() - decimal_type794 = _t1498 - _t1499 = logic_pb2.Type(decimal_type=decimal_type794) - _t1497 = _t1499 + if prediction821 == 9: + _t1572 = self.parse_decimal_type() + decimal_type831 = _t1572 + _t1573 = logic_pb2.Type(decimal_type=decimal_type831) + _t1571 = _t1573 else: - if prediction784 == 8: - _t1501 = self.parse_missing_type() - missing_type793 = _t1501 - _t1502 = logic_pb2.Type(missing_type=missing_type793) - _t1500 = _t1502 + if prediction821 == 8: + _t1575 = self.parse_missing_type() + missing_type830 = _t1575 + _t1576 = logic_pb2.Type(missing_type=missing_type830) + _t1574 = _t1576 else: - if prediction784 == 7: - _t1504 = self.parse_datetime_type() - datetime_type792 = _t1504 - _t1505 = logic_pb2.Type(datetime_type=datetime_type792) - _t1503 = _t1505 + if prediction821 == 7: + _t1578 = self.parse_datetime_type() + datetime_type829 = _t1578 + _t1579 = logic_pb2.Type(datetime_type=datetime_type829) + _t1577 = _t1579 else: - if prediction784 == 6: - _t1507 = self.parse_date_type() - date_type791 = _t1507 - _t1508 = logic_pb2.Type(date_type=date_type791) - _t1506 = _t1508 + if prediction821 == 6: + _t1581 = self.parse_date_type() + date_type828 = _t1581 + _t1582 = logic_pb2.Type(date_type=date_type828) + _t1580 = _t1582 else: - if prediction784 == 5: - _t1510 = self.parse_int128_type() - int128_type790 = _t1510 - _t1511 = logic_pb2.Type(int128_type=int128_type790) - _t1509 = _t1511 + if prediction821 == 5: + _t1584 = self.parse_int128_type() + int128_type827 = _t1584 + _t1585 = logic_pb2.Type(int128_type=int128_type827) + _t1583 = _t1585 else: - if prediction784 == 4: - _t1513 = self.parse_uint128_type() - uint128_type789 = _t1513 - _t1514 = logic_pb2.Type(uint128_type=uint128_type789) - _t1512 = _t1514 + if prediction821 == 4: + _t1587 = self.parse_uint128_type() + uint128_type826 = _t1587 + _t1588 = logic_pb2.Type(uint128_type=uint128_type826) + _t1586 = _t1588 else: - if prediction784 == 3: - _t1516 = self.parse_float_type() - float_type788 = _t1516 - _t1517 = logic_pb2.Type(float_type=float_type788) - _t1515 = _t1517 + if prediction821 == 3: + _t1590 = self.parse_float_type() + float_type825 = _t1590 + _t1591 = logic_pb2.Type(float_type=float_type825) + _t1589 = _t1591 else: - if prediction784 == 2: - _t1519 = self.parse_int_type() - int_type787 = _t1519 - _t1520 = logic_pb2.Type(int_type=int_type787) - _t1518 = _t1520 + if prediction821 == 2: + _t1593 = self.parse_int_type() + int_type824 = _t1593 + _t1594 = logic_pb2.Type(int_type=int_type824) + _t1592 = _t1594 else: - if prediction784 == 1: - _t1522 = self.parse_string_type() - string_type786 = _t1522 - _t1523 = logic_pb2.Type(string_type=string_type786) - _t1521 = _t1523 + if prediction821 == 1: + _t1596 = self.parse_string_type() + string_type823 = _t1596 + _t1597 = logic_pb2.Type(string_type=string_type823) + _t1595 = _t1597 else: - if prediction784 == 0: - _t1525 = self.parse_unspecified_type() - unspecified_type785 = _t1525 - _t1526 = logic_pb2.Type(unspecified_type=unspecified_type785) - _t1524 = _t1526 + if prediction821 == 0: + _t1599 = self.parse_unspecified_type() + unspecified_type822 = _t1599 + _t1600 = logic_pb2.Type(unspecified_type=unspecified_type822) + _t1598 = _t1600 else: raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1521 = _t1524 - _t1518 = _t1521 - _t1515 = _t1518 - _t1512 = _t1515 - _t1509 = _t1512 - _t1506 = _t1509 - _t1503 = _t1506 - _t1500 = _t1503 - _t1497 = _t1500 - _t1494 = _t1497 - _t1491 = _t1494 - _t1488 = _t1491 - _t1485 = _t1488 - result800 = _t1485 - self.record_span(span_start799, "Type") - return result800 + _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 def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: - span_start801 = self.span_start() + span_start838 = self.span_start() self.consume_literal("UNKNOWN") - _t1527 = logic_pb2.UnspecifiedType() - result802 = _t1527 - self.record_span(span_start801, "UnspecifiedType") - return result802 + _t1601 = logic_pb2.UnspecifiedType() + result839 = _t1601 + self.record_span(span_start838, "UnspecifiedType") + return result839 def parse_string_type(self) -> logic_pb2.StringType: - span_start803 = self.span_start() + span_start840 = self.span_start() self.consume_literal("STRING") - _t1528 = logic_pb2.StringType() - result804 = _t1528 - self.record_span(span_start803, "StringType") - return result804 + _t1602 = logic_pb2.StringType() + result841 = _t1602 + self.record_span(span_start840, "StringType") + return result841 def parse_int_type(self) -> logic_pb2.IntType: - span_start805 = self.span_start() + span_start842 = self.span_start() self.consume_literal("INT") - _t1529 = logic_pb2.IntType() - result806 = _t1529 - self.record_span(span_start805, "IntType") - return result806 + _t1603 = logic_pb2.IntType() + result843 = _t1603 + self.record_span(span_start842, "IntType") + return result843 def parse_float_type(self) -> logic_pb2.FloatType: - span_start807 = self.span_start() + span_start844 = self.span_start() self.consume_literal("FLOAT") - _t1530 = logic_pb2.FloatType() - result808 = _t1530 - self.record_span(span_start807, "FloatType") - return result808 + _t1604 = logic_pb2.FloatType() + result845 = _t1604 + self.record_span(span_start844, "FloatType") + return result845 def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start809 = self.span_start() + span_start846 = self.span_start() self.consume_literal("UINT128") - _t1531 = logic_pb2.UInt128Type() - result810 = _t1531 - self.record_span(span_start809, "UInt128Type") - return result810 + _t1605 = logic_pb2.UInt128Type() + result847 = _t1605 + self.record_span(span_start846, "UInt128Type") + return result847 def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start811 = self.span_start() + span_start848 = self.span_start() self.consume_literal("INT128") - _t1532 = logic_pb2.Int128Type() - result812 = _t1532 - self.record_span(span_start811, "Int128Type") - return result812 + _t1606 = logic_pb2.Int128Type() + result849 = _t1606 + self.record_span(span_start848, "Int128Type") + return result849 def parse_date_type(self) -> logic_pb2.DateType: - span_start813 = self.span_start() + span_start850 = self.span_start() self.consume_literal("DATE") - _t1533 = logic_pb2.DateType() - result814 = _t1533 - self.record_span(span_start813, "DateType") - return result814 + _t1607 = logic_pb2.DateType() + result851 = _t1607 + self.record_span(span_start850, "DateType") + return result851 def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start815 = self.span_start() + span_start852 = self.span_start() self.consume_literal("DATETIME") - _t1534 = logic_pb2.DateTimeType() - result816 = _t1534 - self.record_span(span_start815, "DateTimeType") - return result816 + _t1608 = logic_pb2.DateTimeType() + result853 = _t1608 + self.record_span(span_start852, "DateTimeType") + return result853 def parse_missing_type(self) -> logic_pb2.MissingType: - span_start817 = self.span_start() + span_start854 = self.span_start() self.consume_literal("MISSING") - _t1535 = logic_pb2.MissingType() - result818 = _t1535 - self.record_span(span_start817, "MissingType") - return result818 + _t1609 = logic_pb2.MissingType() + result855 = _t1609 + self.record_span(span_start854, "MissingType") + return result855 def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start821 = self.span_start() + span_start858 = self.span_start() self.consume_literal("(") self.consume_literal("DECIMAL") - int819 = self.consume_terminal("INT") - int_3820 = self.consume_terminal("INT") + int856 = self.consume_terminal("INT") + int_3857 = self.consume_terminal("INT") self.consume_literal(")") - _t1536 = logic_pb2.DecimalType(precision=int(int819), scale=int(int_3820)) - result822 = _t1536 - self.record_span(span_start821, "DecimalType") - return result822 + _t1610 = logic_pb2.DecimalType(precision=int(int856), scale=int(int_3857)) + result859 = _t1610 + self.record_span(span_start858, "DecimalType") + return result859 def parse_boolean_type(self) -> logic_pb2.BooleanType: - span_start823 = self.span_start() + span_start860 = self.span_start() self.consume_literal("BOOLEAN") - _t1537 = logic_pb2.BooleanType() - result824 = _t1537 - self.record_span(span_start823, "BooleanType") - return result824 + _t1611 = logic_pb2.BooleanType() + result861 = _t1611 + self.record_span(span_start860, "BooleanType") + return result861 def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start825 = self.span_start() + span_start862 = self.span_start() self.consume_literal("INT32") - _t1538 = logic_pb2.Int32Type() - result826 = _t1538 - self.record_span(span_start825, "Int32Type") - return result826 + _t1612 = logic_pb2.Int32Type() + result863 = _t1612 + self.record_span(span_start862, "Int32Type") + return result863 def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start827 = self.span_start() + span_start864 = self.span_start() self.consume_literal("FLOAT32") - _t1539 = logic_pb2.Float32Type() - result828 = _t1539 - self.record_span(span_start827, "Float32Type") - return result828 + _t1613 = logic_pb2.Float32Type() + result865 = _t1613 + self.record_span(span_start864, "Float32Type") + return result865 def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start829 = self.span_start() + span_start866 = self.span_start() self.consume_literal("UINT32") - _t1540 = logic_pb2.UInt32Type() - result830 = _t1540 - self.record_span(span_start829, "UInt32Type") - return result830 + _t1614 = logic_pb2.UInt32Type() + result867 = _t1614 + self.record_span(span_start866, "UInt32Type") + return result867 def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: self.consume_literal("|") - xs831 = [] - cond832 = self.match_lookahead_terminal("SYMBOL", 0) - while cond832: - _t1541 = self.parse_binding() - item833 = _t1541 - xs831.append(item833) - cond832 = self.match_lookahead_terminal("SYMBOL", 0) - bindings834 = xs831 - return bindings834 + 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 def parse_formula(self) -> logic_pb2.Formula: - span_start849 = self.span_start() + span_start886 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t1543 = 0 + _t1617 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t1544 = 11 + _t1618 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t1545 = 3 + _t1619 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t1546 = 10 + _t1620 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t1547 = 9 + _t1621 = 9 else: if self.match_lookahead_literal("or", 1): - _t1548 = 5 + _t1622 = 5 else: if self.match_lookahead_literal("not", 1): - _t1549 = 6 + _t1623 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t1550 = 7 + _t1624 = 7 else: if self.match_lookahead_literal("false", 1): - _t1551 = 1 + _t1625 = 1 else: if self.match_lookahead_literal("exists", 1): - _t1552 = 2 + _t1626 = 2 else: if self.match_lookahead_literal("cast", 1): - _t1553 = 12 + _t1627 = 12 else: if self.match_lookahead_literal("atom", 1): - _t1554 = 8 + _t1628 = 8 else: if self.match_lookahead_literal("and", 1): - _t1555 = 4 + _t1629 = 4 else: if self.match_lookahead_literal(">=", 1): - _t1556 = 10 + _t1630 = 10 else: if self.match_lookahead_literal(">", 1): - _t1557 = 10 + _t1631 = 10 else: if self.match_lookahead_literal("=", 1): - _t1558 = 10 + _t1632 = 10 else: if self.match_lookahead_literal("<=", 1): - _t1559 = 10 + _t1633 = 10 else: if self.match_lookahead_literal("<", 1): - _t1560 = 10 + _t1634 = 10 else: if self.match_lookahead_literal("/", 1): - _t1561 = 10 + _t1635 = 10 else: if self.match_lookahead_literal("-", 1): - _t1562 = 10 + _t1636 = 10 else: if self.match_lookahead_literal("+", 1): - _t1563 = 10 + _t1637 = 10 else: if self.match_lookahead_literal("*", 1): - _t1564 = 10 + _t1638 = 10 else: - _t1564 = -1 - _t1563 = _t1564 - _t1562 = _t1563 - _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 - _t1548 = _t1549 - _t1547 = _t1548 - _t1546 = _t1547 - _t1545 = _t1546 - _t1544 = _t1545 - _t1543 = _t1544 - _t1542 = _t1543 - else: - _t1542 = -1 - prediction835 = _t1542 - if prediction835 == 12: - _t1566 = self.parse_cast() - cast848 = _t1566 - _t1567 = logic_pb2.Formula(cast=cast848) - _t1565 = _t1567 - else: - if prediction835 == 11: - _t1569 = self.parse_rel_atom() - rel_atom847 = _t1569 - _t1570 = logic_pb2.Formula(rel_atom=rel_atom847) - _t1568 = _t1570 + _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 + else: + _t1616 = -1 + prediction872 = _t1616 + if prediction872 == 12: + _t1640 = self.parse_cast() + cast885 = _t1640 + _t1641 = logic_pb2.Formula(cast=cast885) + _t1639 = _t1641 + else: + if prediction872 == 11: + _t1643 = self.parse_rel_atom() + rel_atom884 = _t1643 + _t1644 = logic_pb2.Formula(rel_atom=rel_atom884) + _t1642 = _t1644 else: - if prediction835 == 10: - _t1572 = self.parse_primitive() - primitive846 = _t1572 - _t1573 = logic_pb2.Formula(primitive=primitive846) - _t1571 = _t1573 + if prediction872 == 10: + _t1646 = self.parse_primitive() + primitive883 = _t1646 + _t1647 = logic_pb2.Formula(primitive=primitive883) + _t1645 = _t1647 else: - if prediction835 == 9: - _t1575 = self.parse_pragma() - pragma845 = _t1575 - _t1576 = logic_pb2.Formula(pragma=pragma845) - _t1574 = _t1576 + if prediction872 == 9: + _t1649 = self.parse_pragma() + pragma882 = _t1649 + _t1650 = logic_pb2.Formula(pragma=pragma882) + _t1648 = _t1650 else: - if prediction835 == 8: - _t1578 = self.parse_atom() - atom844 = _t1578 - _t1579 = logic_pb2.Formula(atom=atom844) - _t1577 = _t1579 + if prediction872 == 8: + _t1652 = self.parse_atom() + atom881 = _t1652 + _t1653 = logic_pb2.Formula(atom=atom881) + _t1651 = _t1653 else: - if prediction835 == 7: - _t1581 = self.parse_ffi() - ffi843 = _t1581 - _t1582 = logic_pb2.Formula(ffi=ffi843) - _t1580 = _t1582 + if prediction872 == 7: + _t1655 = self.parse_ffi() + ffi880 = _t1655 + _t1656 = logic_pb2.Formula(ffi=ffi880) + _t1654 = _t1656 else: - if prediction835 == 6: - _t1584 = self.parse_not() - not842 = _t1584 - _t1585 = logic_pb2.Formula() - getattr(_t1585, 'not').CopyFrom(not842) - _t1583 = _t1585 + if prediction872 == 6: + _t1658 = self.parse_not() + not879 = _t1658 + _t1659 = logic_pb2.Formula() + getattr(_t1659, 'not').CopyFrom(not879) + _t1657 = _t1659 else: - if prediction835 == 5: - _t1587 = self.parse_disjunction() - disjunction841 = _t1587 - _t1588 = logic_pb2.Formula(disjunction=disjunction841) - _t1586 = _t1588 + if prediction872 == 5: + _t1661 = self.parse_disjunction() + disjunction878 = _t1661 + _t1662 = logic_pb2.Formula(disjunction=disjunction878) + _t1660 = _t1662 else: - if prediction835 == 4: - _t1590 = self.parse_conjunction() - conjunction840 = _t1590 - _t1591 = logic_pb2.Formula(conjunction=conjunction840) - _t1589 = _t1591 + if prediction872 == 4: + _t1664 = self.parse_conjunction() + conjunction877 = _t1664 + _t1665 = logic_pb2.Formula(conjunction=conjunction877) + _t1663 = _t1665 else: - if prediction835 == 3: - _t1593 = self.parse_reduce() - reduce839 = _t1593 - _t1594 = logic_pb2.Formula(reduce=reduce839) - _t1592 = _t1594 + if prediction872 == 3: + _t1667 = self.parse_reduce() + reduce876 = _t1667 + _t1668 = logic_pb2.Formula(reduce=reduce876) + _t1666 = _t1668 else: - if prediction835 == 2: - _t1596 = self.parse_exists() - exists838 = _t1596 - _t1597 = logic_pb2.Formula(exists=exists838) - _t1595 = _t1597 + if prediction872 == 2: + _t1670 = self.parse_exists() + exists875 = _t1670 + _t1671 = logic_pb2.Formula(exists=exists875) + _t1669 = _t1671 else: - if prediction835 == 1: - _t1599 = self.parse_false() - false837 = _t1599 - _t1600 = logic_pb2.Formula(disjunction=false837) - _t1598 = _t1600 + if prediction872 == 1: + _t1673 = self.parse_false() + false874 = _t1673 + _t1674 = logic_pb2.Formula(disjunction=false874) + _t1672 = _t1674 else: - if prediction835 == 0: - _t1602 = self.parse_true() - true836 = _t1602 - _t1603 = logic_pb2.Formula(conjunction=true836) - _t1601 = _t1603 + if prediction872 == 0: + _t1676 = self.parse_true() + true873 = _t1676 + _t1677 = logic_pb2.Formula(conjunction=true873) + _t1675 = _t1677 else: raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1598 = _t1601 - _t1595 = _t1598 - _t1592 = _t1595 - _t1589 = _t1592 - _t1586 = _t1589 - _t1583 = _t1586 - _t1580 = _t1583 - _t1577 = _t1580 - _t1574 = _t1577 - _t1571 = _t1574 - _t1568 = _t1571 - _t1565 = _t1568 - result850 = _t1565 - self.record_span(span_start849, "Formula") - return result850 + _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 def parse_true(self) -> logic_pb2.Conjunction: - span_start851 = self.span_start() + span_start888 = self.span_start() self.consume_literal("(") self.consume_literal("true") self.consume_literal(")") - _t1604 = logic_pb2.Conjunction(args=[]) - result852 = _t1604 - self.record_span(span_start851, "Conjunction") - return result852 + _t1678 = logic_pb2.Conjunction(args=[]) + result889 = _t1678 + self.record_span(span_start888, "Conjunction") + return result889 def parse_false(self) -> logic_pb2.Disjunction: - span_start853 = self.span_start() + span_start890 = self.span_start() self.consume_literal("(") self.consume_literal("false") self.consume_literal(")") - _t1605 = logic_pb2.Disjunction(args=[]) - result854 = _t1605 - self.record_span(span_start853, "Disjunction") - return result854 + _t1679 = logic_pb2.Disjunction(args=[]) + result891 = _t1679 + self.record_span(span_start890, "Disjunction") + return result891 def parse_exists(self) -> logic_pb2.Exists: - span_start857 = self.span_start() + span_start894 = self.span_start() self.consume_literal("(") self.consume_literal("exists") - _t1606 = self.parse_bindings() - bindings855 = _t1606 - _t1607 = self.parse_formula() - formula856 = _t1607 - self.consume_literal(")") - _t1608 = logic_pb2.Abstraction(vars=(list(bindings855[0]) + list(bindings855[1] if bindings855[1] is not None else [])), value=formula856) - _t1609 = logic_pb2.Exists(body=_t1608) - result858 = _t1609 - self.record_span(span_start857, "Exists") - return result858 + _t1680 = self.parse_bindings() + bindings892 = _t1680 + _t1681 = self.parse_formula() + formula893 = _t1681 + 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 def parse_reduce(self) -> logic_pb2.Reduce: - span_start862 = self.span_start() + span_start899 = self.span_start() self.consume_literal("(") self.consume_literal("reduce") - _t1610 = self.parse_abstraction() - abstraction859 = _t1610 - _t1611 = self.parse_abstraction() - abstraction_3860 = _t1611 - _t1612 = self.parse_terms() - terms861 = _t1612 + _t1684 = self.parse_abstraction() + abstraction896 = _t1684 + _t1685 = self.parse_abstraction() + abstraction_3897 = _t1685 + _t1686 = self.parse_terms() + terms898 = _t1686 + self.consume_literal(")") + _t1687 = logic_pb2.Reduce(op=abstraction896, body=abstraction_3897, terms=terms898) + result900 = _t1687 + self.record_span(span_start899, "Reduce") + return result900 + + 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 self.consume_literal(")") - _t1613 = logic_pb2.Reduce(op=abstraction859, body=abstraction_3860, terms=terms861) - result863 = _t1613 - self.record_span(span_start862, "Reduce") - return result863 -======= - span_start793 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("iceberg_data", 1): - _t1502 = 3 - else: - if self.match_lookahead_literal("functional_dependency", 1): - _t1503 = 2 - else: - if self.match_lookahead_literal("edb", 1): - _t1504 = 3 - else: - if self.match_lookahead_literal("def", 1): - _t1505 = 0 - else: - if self.match_lookahead_literal("csv_data", 1): - _t1506 = 3 - else: - if self.match_lookahead_literal("betree_relation", 1): - _t1507 = 3 - else: - if self.match_lookahead_literal("algorithm", 1): - _t1508 = 1 - else: - _t1508 = -1 - _t1507 = _t1508 - _t1506 = _t1507 - _t1505 = _t1506 - _t1504 = _t1505 - _t1503 = _t1504 - _t1502 = _t1503 - _t1501 = _t1502 - else: - _t1501 = -1 - prediction788 = _t1501 - if prediction788 == 3: - _t1510 = self.parse_data() - data792 = _t1510 - _t1511 = logic_pb2.Declaration(data=data792) - _t1509 = _t1511 - else: - if prediction788 == 2: - _t1513 = self.parse_constraint() - constraint791 = _t1513 - _t1514 = logic_pb2.Declaration(constraint=constraint791) - _t1512 = _t1514 - else: - if prediction788 == 1: - _t1516 = self.parse_algorithm() - algorithm790 = _t1516 - _t1517 = logic_pb2.Declaration(algorithm=algorithm790) - _t1515 = _t1517 - else: - if prediction788 == 0: - _t1519 = self.parse_def() - def789 = _t1519 - _t1520 = logic_pb2.Declaration() - getattr(_t1520, 'def').CopyFrom(def789) - _t1518 = _t1520 - else: - raise ParseError("Unexpected token in declaration" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1515 = _t1518 - _t1512 = _t1515 - _t1509 = _t1512 - result794 = _t1509 - self.record_span(span_start793, "Declaration") - return result794 - - def parse_def(self) -> logic_pb2.Def: - span_start798 = self.span_start() - self.consume_literal("(") - self.consume_literal("def") - _t1521 = self.parse_relation_id() - relation_id795 = _t1521 - _t1522 = self.parse_abstraction() - abstraction796 = _t1522 - if self.match_lookahead_literal("(", 0): - _t1524 = self.parse_attrs() - _t1523 = _t1524 - else: - _t1523 = None - attrs797 = _t1523 - self.consume_literal(")") - _t1525 = logic_pb2.Def(name=relation_id795, body=abstraction796, attrs=(attrs797 if attrs797 is not None else [])) - result799 = _t1525 - self.record_span(span_start798, "Def") - return result799 - - def parse_relation_id(self) -> logic_pb2.RelationId: - span_start803 = self.span_start() - if self.match_lookahead_literal(":", 0): - _t1526 = 0 - else: - if self.match_lookahead_terminal("UINT128", 0): - _t1527 = 1 - else: - _t1527 = -1 - _t1526 = _t1527 - prediction800 = _t1526 - if prediction800 == 1: - uint128802 = self.consume_terminal("UINT128") - _t1528 = logic_pb2.RelationId(id_low=uint128802.low, id_high=uint128802.high) - else: - if prediction800 == 0: - self.consume_literal(":") - symbol801 = self.consume_terminal("SYMBOL") - _t1529 = self.relation_id_from_string(symbol801) - else: - raise ParseError("Unexpected token in relation_id" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1528 = _t1529 - result804 = _t1528 - self.record_span(span_start803, "RelationId") - return result804 - - def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start807 = self.span_start() - self.consume_literal("(") - _t1530 = self.parse_bindings() - bindings805 = _t1530 - _t1531 = self.parse_formula() - formula806 = _t1531 - self.consume_literal(")") - _t1532 = logic_pb2.Abstraction(vars=(list(bindings805[0]) + list(bindings805[1] if bindings805[1] is not None else [])), value=formula806) - result808 = _t1532 - self.record_span(span_start807, "Abstraction") - return result808 - - def parse_bindings(self) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: - self.consume_literal("[") - xs809 = [] - cond810 = self.match_lookahead_terminal("SYMBOL", 0) - while cond810: - _t1533 = self.parse_binding() - item811 = _t1533 - xs809.append(item811) - cond810 = self.match_lookahead_terminal("SYMBOL", 0) - bindings812 = xs809 - if self.match_lookahead_literal("|", 0): - _t1535 = self.parse_value_bindings() - _t1534 = _t1535 - else: - _t1534 = None - value_bindings813 = _t1534 - self.consume_literal("]") - return (bindings812, (value_bindings813 if value_bindings813 is not None else []),) - - def parse_binding(self) -> logic_pb2.Binding: - span_start816 = self.span_start() - symbol814 = self.consume_terminal("SYMBOL") - self.consume_literal("::") - _t1536 = self.parse_type() - type815 = _t1536 - _t1537 = logic_pb2.Var(name=symbol814) - _t1538 = logic_pb2.Binding(var=_t1537, type=type815) - result817 = _t1538 - self.record_span(span_start816, "Binding") - return result817 - - def parse_type(self) -> logic_pb2.Type: - span_start833 = self.span_start() - if self.match_lookahead_literal("UNKNOWN", 0): - _t1539 = 0 - else: - if self.match_lookahead_literal("UINT32", 0): - _t1540 = 13 - else: - if self.match_lookahead_literal("UINT128", 0): - _t1541 = 4 - else: - if self.match_lookahead_literal("STRING", 0): - _t1542 = 1 - else: - if self.match_lookahead_literal("MISSING", 0): - _t1543 = 8 - else: - if self.match_lookahead_literal("INT32", 0): - _t1544 = 11 - else: - if self.match_lookahead_literal("INT128", 0): - _t1545 = 5 - else: - if self.match_lookahead_literal("INT", 0): - _t1546 = 2 - else: - if self.match_lookahead_literal("FLOAT32", 0): - _t1547 = 12 - else: - if self.match_lookahead_literal("FLOAT", 0): - _t1548 = 3 - else: - if self.match_lookahead_literal("DATETIME", 0): - _t1549 = 7 - else: - if self.match_lookahead_literal("DATE", 0): - _t1550 = 6 - else: - if self.match_lookahead_literal("BOOLEAN", 0): - _t1551 = 10 - else: - if self.match_lookahead_literal("(", 0): - _t1552 = 9 - else: - _t1552 = -1 - _t1551 = _t1552 - _t1550 = _t1551 - _t1549 = _t1550 - _t1548 = _t1549 - _t1547 = _t1548 - _t1546 = _t1547 - _t1545 = _t1546 - _t1544 = _t1545 - _t1543 = _t1544 - _t1542 = _t1543 - _t1541 = _t1542 - _t1540 = _t1541 - _t1539 = _t1540 - prediction818 = _t1539 - if prediction818 == 13: - _t1554 = self.parse_uint32_type() - uint32_type832 = _t1554 - _t1555 = logic_pb2.Type(uint32_type=uint32_type832) - _t1553 = _t1555 - else: - if prediction818 == 12: - _t1557 = self.parse_float32_type() - float32_type831 = _t1557 - _t1558 = logic_pb2.Type(float32_type=float32_type831) - _t1556 = _t1558 - else: - if prediction818 == 11: - _t1560 = self.parse_int32_type() - int32_type830 = _t1560 - _t1561 = logic_pb2.Type(int32_type=int32_type830) - _t1559 = _t1561 - else: - if prediction818 == 10: - _t1563 = self.parse_boolean_type() - boolean_type829 = _t1563 - _t1564 = logic_pb2.Type(boolean_type=boolean_type829) - _t1562 = _t1564 - else: - if prediction818 == 9: - _t1566 = self.parse_decimal_type() - decimal_type828 = _t1566 - _t1567 = logic_pb2.Type(decimal_type=decimal_type828) - _t1565 = _t1567 - else: - if prediction818 == 8: - _t1569 = self.parse_missing_type() - missing_type827 = _t1569 - _t1570 = logic_pb2.Type(missing_type=missing_type827) - _t1568 = _t1570 - else: - if prediction818 == 7: - _t1572 = self.parse_datetime_type() - datetime_type826 = _t1572 - _t1573 = logic_pb2.Type(datetime_type=datetime_type826) - _t1571 = _t1573 - else: - if prediction818 == 6: - _t1575 = self.parse_date_type() - date_type825 = _t1575 - _t1576 = logic_pb2.Type(date_type=date_type825) - _t1574 = _t1576 - else: - if prediction818 == 5: - _t1578 = self.parse_int128_type() - int128_type824 = _t1578 - _t1579 = logic_pb2.Type(int128_type=int128_type824) - _t1577 = _t1579 - else: - if prediction818 == 4: - _t1581 = self.parse_uint128_type() - uint128_type823 = _t1581 - _t1582 = logic_pb2.Type(uint128_type=uint128_type823) - _t1580 = _t1582 - else: - if prediction818 == 3: - _t1584 = self.parse_float_type() - float_type822 = _t1584 - _t1585 = logic_pb2.Type(float_type=float_type822) - _t1583 = _t1585 - else: - if prediction818 == 2: - _t1587 = self.parse_int_type() - int_type821 = _t1587 - _t1588 = logic_pb2.Type(int_type=int_type821) - _t1586 = _t1588 - else: - if prediction818 == 1: - _t1590 = self.parse_string_type() - string_type820 = _t1590 - _t1591 = logic_pb2.Type(string_type=string_type820) - _t1589 = _t1591 - else: - if prediction818 == 0: - _t1593 = self.parse_unspecified_type() - unspecified_type819 = _t1593 - _t1594 = logic_pb2.Type(unspecified_type=unspecified_type819) - _t1592 = _t1594 - else: - raise ParseError("Unexpected token in type" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1589 = _t1592 - _t1586 = _t1589 - _t1583 = _t1586 - _t1580 = _t1583 - _t1577 = _t1580 - _t1574 = _t1577 - _t1571 = _t1574 - _t1568 = _t1571 - _t1565 = _t1568 - _t1562 = _t1565 - _t1559 = _t1562 - _t1556 = _t1559 - _t1553 = _t1556 - result834 = _t1553 - self.record_span(span_start833, "Type") - return result834 - - def parse_unspecified_type(self) -> logic_pb2.UnspecifiedType: - span_start835 = self.span_start() - self.consume_literal("UNKNOWN") - _t1595 = logic_pb2.UnspecifiedType() - result836 = _t1595 - self.record_span(span_start835, "UnspecifiedType") - return result836 - - def parse_string_type(self) -> logic_pb2.StringType: - span_start837 = self.span_start() - self.consume_literal("STRING") - _t1596 = logic_pb2.StringType() - result838 = _t1596 - self.record_span(span_start837, "StringType") - return result838 - - def parse_int_type(self) -> logic_pb2.IntType: - span_start839 = self.span_start() - self.consume_literal("INT") - _t1597 = logic_pb2.IntType() - result840 = _t1597 - self.record_span(span_start839, "IntType") - return result840 - - def parse_float_type(self) -> logic_pb2.FloatType: - span_start841 = self.span_start() - self.consume_literal("FLOAT") - _t1598 = logic_pb2.FloatType() - result842 = _t1598 - self.record_span(span_start841, "FloatType") - return result842 - - def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start843 = self.span_start() - self.consume_literal("UINT128") - _t1599 = logic_pb2.UInt128Type() - result844 = _t1599 - self.record_span(span_start843, "UInt128Type") - return result844 - - def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start845 = self.span_start() - self.consume_literal("INT128") - _t1600 = logic_pb2.Int128Type() - result846 = _t1600 - self.record_span(span_start845, "Int128Type") - return result846 - - def parse_date_type(self) -> logic_pb2.DateType: - span_start847 = self.span_start() - self.consume_literal("DATE") - _t1601 = logic_pb2.DateType() - result848 = _t1601 - self.record_span(span_start847, "DateType") - return result848 - - def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start849 = self.span_start() - self.consume_literal("DATETIME") - _t1602 = logic_pb2.DateTimeType() - result850 = _t1602 - self.record_span(span_start849, "DateTimeType") - return result850 - - def parse_missing_type(self) -> logic_pb2.MissingType: - span_start851 = self.span_start() - self.consume_literal("MISSING") - _t1603 = logic_pb2.MissingType() - result852 = _t1603 - self.record_span(span_start851, "MissingType") - return result852 - - def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start855 = self.span_start() - self.consume_literal("(") - self.consume_literal("DECIMAL") - int853 = self.consume_terminal("INT") - int_3854 = self.consume_terminal("INT") - self.consume_literal(")") - _t1604 = logic_pb2.DecimalType(precision=int(int853), scale=int(int_3854)) - result856 = _t1604 - self.record_span(span_start855, "DecimalType") - return result856 - - def parse_boolean_type(self) -> logic_pb2.BooleanType: - span_start857 = self.span_start() - self.consume_literal("BOOLEAN") - _t1605 = logic_pb2.BooleanType() - result858 = _t1605 - self.record_span(span_start857, "BooleanType") - return result858 - - def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start859 = self.span_start() - self.consume_literal("INT32") - _t1606 = logic_pb2.Int32Type() - result860 = _t1606 - self.record_span(span_start859, "Int32Type") - return result860 - - def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start861 = self.span_start() - self.consume_literal("FLOAT32") - _t1607 = logic_pb2.Float32Type() - result862 = _t1607 - self.record_span(span_start861, "Float32Type") - return result862 - - def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start863 = self.span_start() - self.consume_literal("UINT32") - _t1608 = logic_pb2.UInt32Type() - result864 = _t1608 - self.record_span(span_start863, "UInt32Type") - return result864 - - def parse_value_bindings(self) -> Sequence[logic_pb2.Binding]: - self.consume_literal("|") - xs865 = [] - cond866 = self.match_lookahead_terminal("SYMBOL", 0) - while cond866: - _t1609 = self.parse_binding() - item867 = _t1609 - xs865.append(item867) - cond866 = self.match_lookahead_terminal("SYMBOL", 0) - bindings868 = xs865 - return bindings868 - - def parse_formula(self) -> logic_pb2.Formula: - span_start883 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("true", 1): - _t1611 = 0 - else: - if self.match_lookahead_literal("relatom", 1): - _t1612 = 11 - else: - if self.match_lookahead_literal("reduce", 1): - _t1613 = 3 - else: - if self.match_lookahead_literal("primitive", 1): - _t1614 = 10 - else: - if self.match_lookahead_literal("pragma", 1): - _t1615 = 9 - else: - if self.match_lookahead_literal("or", 1): - _t1616 = 5 - else: - if self.match_lookahead_literal("not", 1): - _t1617 = 6 - else: - if self.match_lookahead_literal("ffi", 1): - _t1618 = 7 - else: - if self.match_lookahead_literal("false", 1): - _t1619 = 1 - else: - if self.match_lookahead_literal("exists", 1): - _t1620 = 2 - else: - if self.match_lookahead_literal("cast", 1): - _t1621 = 12 - else: - if self.match_lookahead_literal("atom", 1): - _t1622 = 8 - else: - if self.match_lookahead_literal("and", 1): - _t1623 = 4 - else: - if self.match_lookahead_literal(">=", 1): - _t1624 = 10 - else: - if self.match_lookahead_literal(">", 1): - _t1625 = 10 - else: - if self.match_lookahead_literal("=", 1): - _t1626 = 10 - else: - if self.match_lookahead_literal("<=", 1): - _t1627 = 10 - else: - if self.match_lookahead_literal("<", 1): - _t1628 = 10 - else: - if self.match_lookahead_literal("/", 1): - _t1629 = 10 - else: - if self.match_lookahead_literal("-", 1): - _t1630 = 10 - else: - if self.match_lookahead_literal("+", 1): - _t1631 = 10 - else: - if self.match_lookahead_literal("*", 1): - _t1632 = 10 - else: - _t1632 = -1 - _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 - _t1615 = _t1616 - _t1614 = _t1615 - _t1613 = _t1614 - _t1612 = _t1613 - _t1611 = _t1612 - _t1610 = _t1611 - else: - _t1610 = -1 - prediction869 = _t1610 - if prediction869 == 12: - _t1634 = self.parse_cast() - cast882 = _t1634 - _t1635 = logic_pb2.Formula(cast=cast882) - _t1633 = _t1635 - else: - if prediction869 == 11: - _t1637 = self.parse_rel_atom() - rel_atom881 = _t1637 - _t1638 = logic_pb2.Formula(rel_atom=rel_atom881) - _t1636 = _t1638 - else: - if prediction869 == 10: - _t1640 = self.parse_primitive() - primitive880 = _t1640 - _t1641 = logic_pb2.Formula(primitive=primitive880) - _t1639 = _t1641 - else: - if prediction869 == 9: - _t1643 = self.parse_pragma() - pragma879 = _t1643 - _t1644 = logic_pb2.Formula(pragma=pragma879) - _t1642 = _t1644 - else: - if prediction869 == 8: - _t1646 = self.parse_atom() - atom878 = _t1646 - _t1647 = logic_pb2.Formula(atom=atom878) - _t1645 = _t1647 - else: - if prediction869 == 7: - _t1649 = self.parse_ffi() - ffi877 = _t1649 - _t1650 = logic_pb2.Formula(ffi=ffi877) - _t1648 = _t1650 - else: - if prediction869 == 6: - _t1652 = self.parse_not() - not876 = _t1652 - _t1653 = logic_pb2.Formula() - getattr(_t1653, 'not').CopyFrom(not876) - _t1651 = _t1653 - else: - if prediction869 == 5: - _t1655 = self.parse_disjunction() - disjunction875 = _t1655 - _t1656 = logic_pb2.Formula(disjunction=disjunction875) - _t1654 = _t1656 - else: - if prediction869 == 4: - _t1658 = self.parse_conjunction() - conjunction874 = _t1658 - _t1659 = logic_pb2.Formula(conjunction=conjunction874) - _t1657 = _t1659 - else: - if prediction869 == 3: - _t1661 = self.parse_reduce() - reduce873 = _t1661 - _t1662 = logic_pb2.Formula(reduce=reduce873) - _t1660 = _t1662 - else: - if prediction869 == 2: - _t1664 = self.parse_exists() - exists872 = _t1664 - _t1665 = logic_pb2.Formula(exists=exists872) - _t1663 = _t1665 - else: - if prediction869 == 1: - _t1667 = self.parse_false() - false871 = _t1667 - _t1668 = logic_pb2.Formula(disjunction=false871) - _t1666 = _t1668 - else: - if prediction869 == 0: - _t1670 = self.parse_true() - true870 = _t1670 - _t1671 = logic_pb2.Formula(conjunction=true870) - _t1669 = _t1671 - else: - raise ParseError("Unexpected token in formula" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1666 = _t1669 - _t1663 = _t1666 - _t1660 = _t1663 - _t1657 = _t1660 - _t1654 = _t1657 - _t1651 = _t1654 - _t1648 = _t1651 - _t1645 = _t1648 - _t1642 = _t1645 - _t1639 = _t1642 - _t1636 = _t1639 - _t1633 = _t1636 - result884 = _t1633 - self.record_span(span_start883, "Formula") - return result884 - - def parse_true(self) -> logic_pb2.Conjunction: - span_start885 = self.span_start() - self.consume_literal("(") - self.consume_literal("true") - self.consume_literal(")") - _t1672 = logic_pb2.Conjunction(args=[]) - result886 = _t1672 - self.record_span(span_start885, "Conjunction") - return result886 - - def parse_false(self) -> logic_pb2.Disjunction: - span_start887 = self.span_start() - self.consume_literal("(") - self.consume_literal("false") - self.consume_literal(")") - _t1673 = logic_pb2.Disjunction(args=[]) - result888 = _t1673 - self.record_span(span_start887, "Disjunction") - return result888 - - def parse_exists(self) -> logic_pb2.Exists: - span_start891 = self.span_start() - self.consume_literal("(") - self.consume_literal("exists") - _t1674 = self.parse_bindings() - bindings889 = _t1674 - _t1675 = self.parse_formula() - formula890 = _t1675 - self.consume_literal(")") - _t1676 = logic_pb2.Abstraction(vars=(list(bindings889[0]) + list(bindings889[1] if bindings889[1] is not None else [])), value=formula890) - _t1677 = logic_pb2.Exists(body=_t1676) - result892 = _t1677 - self.record_span(span_start891, "Exists") - return result892 - - def parse_reduce(self) -> logic_pb2.Reduce: - span_start896 = self.span_start() - self.consume_literal("(") - self.consume_literal("reduce") - _t1678 = self.parse_abstraction() - abstraction893 = _t1678 - _t1679 = self.parse_abstraction() - abstraction_3894 = _t1679 - _t1680 = self.parse_terms() - terms895 = _t1680 - self.consume_literal(")") - _t1681 = logic_pb2.Reduce(op=abstraction893, body=abstraction_3894, terms=terms895) - result897 = _t1681 - self.record_span(span_start896, "Reduce") - return result897 ->>>>>>> origin/main - - def parse_terms(self) -> Sequence[logic_pb2.Term]: - self.consume_literal("(") - self.consume_literal("terms") -<<<<<<< HEAD - xs864 = [] - cond865 = (((((((((((((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 cond865: - _t1614 = self.parse_term() - item866 = _t1614 - xs864.append(item866) - cond865 = (((((((((((((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)) - terms867 = xs864 - self.consume_literal(")") - return terms867 - - def parse_term(self) -> logic_pb2.Term: - span_start871 = self.span_start() - if self.match_lookahead_literal("true", 0): - _t1615 = 1 - else: - if self.match_lookahead_literal("missing", 0): - _t1616 = 1 - else: - if self.match_lookahead_literal("false", 0): - _t1617 = 1 - else: - if self.match_lookahead_literal("(", 0): - _t1618 = 1 - else: - if self.match_lookahead_terminal("SYMBOL", 0): - _t1619 = 0 - else: - if self.match_lookahead_terminal("UINT32", 0): - _t1620 = 1 - else: - if self.match_lookahead_terminal("UINT128", 0): - _t1621 = 1 - else: - if self.match_lookahead_terminal("STRING", 0): - _t1622 = 1 - else: - if self.match_lookahead_terminal("INT32", 0): - _t1623 = 1 - else: - if self.match_lookahead_terminal("INT128", 0): - _t1624 = 1 - else: - if self.match_lookahead_terminal("INT", 0): - _t1625 = 1 - else: - if self.match_lookahead_terminal("FLOAT32", 0): - _t1626 = 1 - else: - if self.match_lookahead_terminal("FLOAT", 0): - _t1627 = 1 - else: - if self.match_lookahead_terminal("DECIMAL", 0): - _t1628 = 1 - else: - _t1628 = -1 - _t1627 = _t1628 - _t1626 = _t1627 - _t1625 = _t1626 - _t1624 = _t1625 - _t1623 = _t1624 - _t1622 = _t1623 - _t1621 = _t1622 - _t1620 = _t1621 - _t1619 = _t1620 - _t1618 = _t1619 - _t1617 = _t1618 - _t1616 = _t1617 - _t1615 = _t1616 - prediction868 = _t1615 - if prediction868 == 1: - _t1630 = self.parse_value() - value870 = _t1630 - _t1631 = logic_pb2.Term(constant=value870) - _t1629 = _t1631 - else: - if prediction868 == 0: - _t1633 = self.parse_var() - var869 = _t1633 - _t1634 = logic_pb2.Term(var=var869) - _t1632 = _t1634 - else: - raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1629 = _t1632 - result872 = _t1629 - self.record_span(span_start871, "Term") - return result872 -======= - xs898 = [] - cond899 = (((((((((((((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 cond899: - _t1682 = self.parse_term() - item900 = _t1682 - xs898.append(item900) - cond899 = (((((((((((((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)) - terms901 = xs898 - self.consume_literal(")") - return terms901 - - def parse_term(self) -> logic_pb2.Term: - span_start905 = self.span_start() - if self.match_lookahead_literal("true", 0): - _t1683 = 1 - else: - if self.match_lookahead_literal("missing", 0): - _t1684 = 1 - else: - if self.match_lookahead_literal("false", 0): - _t1685 = 1 - else: - if self.match_lookahead_literal("(", 0): - _t1686 = 1 - else: - if self.match_lookahead_terminal("SYMBOL", 0): - _t1687 = 0 - else: - if self.match_lookahead_terminal("UINT32", 0): - _t1688 = 1 - else: - if self.match_lookahead_terminal("UINT128", 0): - _t1689 = 1 - else: - if self.match_lookahead_terminal("STRING", 0): - _t1690 = 1 - else: - if self.match_lookahead_terminal("INT32", 0): - _t1691 = 1 - else: - if self.match_lookahead_terminal("INT128", 0): - _t1692 = 1 - else: - if self.match_lookahead_terminal("INT", 0): - _t1693 = 1 - else: - if self.match_lookahead_terminal("FLOAT32", 0): - _t1694 = 1 - else: - if self.match_lookahead_terminal("FLOAT", 0): - _t1695 = 1 - else: - if self.match_lookahead_terminal("DECIMAL", 0): - _t1696 = 1 - else: - _t1696 = -1 - _t1695 = _t1696 - _t1694 = _t1695 - _t1693 = _t1694 - _t1692 = _t1693 - _t1691 = _t1692 - _t1690 = _t1691 - _t1689 = _t1690 - _t1688 = _t1689 - _t1687 = _t1688 - _t1686 = _t1687 - _t1685 = _t1686 - _t1684 = _t1685 - _t1683 = _t1684 - prediction902 = _t1683 - if prediction902 == 1: - _t1698 = self.parse_value() - value904 = _t1698 - _t1699 = logic_pb2.Term(constant=value904) - _t1697 = _t1699 - else: - if prediction902 == 0: - _t1701 = self.parse_var() - var903 = _t1701 - _t1702 = logic_pb2.Term(var=var903) - _t1700 = _t1702 - else: - raise ParseError("Unexpected token in term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1697 = _t1700 - result906 = _t1697 - self.record_span(span_start905, "Term") - return result906 - - def parse_var(self) -> logic_pb2.Var: - span_start908 = self.span_start() - symbol907 = self.consume_terminal("SYMBOL") - _t1703 = logic_pb2.Var(name=symbol907) - result909 = _t1703 - self.record_span(span_start908, "Var") - return result909 ->>>>>>> origin/main - - def parse_var(self) -> logic_pb2.Var: - span_start874 = self.span_start() - symbol873 = self.consume_terminal("SYMBOL") - _t1635 = logic_pb2.Var(name=symbol873) - result875 = _t1635 - self.record_span(span_start874, "Var") - return result875 - - def parse_value(self) -> logic_pb2.Value: -<<<<<<< HEAD - span_start889 = self.span_start() - if self.match_lookahead_literal("true", 0): - _t1636 = 12 - else: - if self.match_lookahead_literal("missing", 0): - _t1637 = 11 - else: - if self.match_lookahead_literal("false", 0): - _t1638 = 12 - else: - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("datetime", 1): - _t1640 = 1 - else: - if self.match_lookahead_literal("date", 1): - _t1641 = 0 - else: - _t1641 = -1 - _t1640 = _t1641 - _t1639 = _t1640 - else: - if self.match_lookahead_terminal("UINT32", 0): - _t1642 = 7 - else: - if self.match_lookahead_terminal("UINT128", 0): - _t1643 = 8 - else: - if self.match_lookahead_terminal("STRING", 0): - _t1644 = 2 - else: - if self.match_lookahead_terminal("INT32", 0): - _t1645 = 3 - else: - if self.match_lookahead_terminal("INT128", 0): - _t1646 = 9 - else: - if self.match_lookahead_terminal("INT", 0): - _t1647 = 4 - else: - if self.match_lookahead_terminal("FLOAT32", 0): - _t1648 = 5 - else: - if self.match_lookahead_terminal("FLOAT", 0): - _t1649 = 6 - else: - if self.match_lookahead_terminal("DECIMAL", 0): - _t1650 = 10 - else: - _t1650 = -1 - _t1649 = _t1650 - _t1648 = _t1649 - _t1647 = _t1648 - _t1646 = _t1647 - _t1645 = _t1646 - _t1644 = _t1645 - _t1643 = _t1644 - _t1642 = _t1643 - _t1639 = _t1642 - _t1638 = _t1639 - _t1637 = _t1638 - _t1636 = _t1637 - prediction876 = _t1636 - if prediction876 == 12: - _t1652 = self.parse_boolean_value() - boolean_value888 = _t1652 - _t1653 = logic_pb2.Value(boolean_value=boolean_value888) - _t1651 = _t1653 + return terms904 + + def parse_term(self) -> logic_pb2.Term: + span_start908 = self.span_start() + if self.match_lookahead_literal("true", 0): + _t1689 = 1 else: - if prediction876 == 11: - self.consume_literal("missing") - _t1655 = logic_pb2.MissingValue() - _t1656 = logic_pb2.Value(missing_value=_t1655) - _t1654 = _t1656 + if self.match_lookahead_literal("missing", 0): + _t1690 = 1 else: - if prediction876 == 10: - formatted_decimal887 = self.consume_terminal("DECIMAL") - _t1658 = logic_pb2.Value(decimal_value=formatted_decimal887) - _t1657 = _t1658 + if self.match_lookahead_literal("false", 0): + _t1691 = 1 else: - if prediction876 == 9: - formatted_int128886 = self.consume_terminal("INT128") - _t1660 = logic_pb2.Value(int128_value=formatted_int128886) - _t1659 = _t1660 + if self.match_lookahead_literal("(", 0): + _t1692 = 1 else: - if prediction876 == 8: - formatted_uint128885 = self.consume_terminal("UINT128") - _t1662 = logic_pb2.Value(uint128_value=formatted_uint128885) - _t1661 = _t1662 + if self.match_lookahead_terminal("SYMBOL", 0): + _t1693 = 0 else: - if prediction876 == 7: - formatted_uint32884 = self.consume_terminal("UINT32") - _t1664 = logic_pb2.Value(uint32_value=formatted_uint32884) - _t1663 = _t1664 + if self.match_lookahead_terminal("UINT32", 0): + _t1694 = 1 else: - if prediction876 == 6: - formatted_float883 = self.consume_terminal("FLOAT") - _t1666 = logic_pb2.Value(float_value=formatted_float883) - _t1665 = _t1666 + if self.match_lookahead_terminal("UINT128", 0): + _t1695 = 1 else: - if prediction876 == 5: - formatted_float32882 = self.consume_terminal("FLOAT32") - _t1668 = logic_pb2.Value(float32_value=formatted_float32882) - _t1667 = _t1668 + if self.match_lookahead_terminal("STRING", 0): + _t1696 = 1 else: - if prediction876 == 4: - formatted_int881 = self.consume_terminal("INT") - _t1670 = logic_pb2.Value(int_value=formatted_int881) - _t1669 = _t1670 + if self.match_lookahead_terminal("INT32", 0): + _t1697 = 1 else: - if prediction876 == 3: - formatted_int32880 = self.consume_terminal("INT32") - _t1672 = logic_pb2.Value(int32_value=formatted_int32880) - _t1671 = _t1672 + if self.match_lookahead_terminal("INT128", 0): + _t1698 = 1 else: - if prediction876 == 2: - formatted_string879 = self.consume_terminal("STRING") - _t1674 = logic_pb2.Value(string_value=formatted_string879) - _t1673 = _t1674 + if self.match_lookahead_terminal("INT", 0): + _t1699 = 1 else: - if prediction876 == 1: - _t1676 = self.parse_datetime() - datetime878 = _t1676 - _t1677 = logic_pb2.Value(datetime_value=datetime878) - _t1675 = _t1677 + if self.match_lookahead_terminal("FLOAT32", 0): + _t1700 = 1 else: - if prediction876 == 0: - _t1679 = self.parse_date() - date877 = _t1679 - _t1680 = logic_pb2.Value(date_value=date877) - _t1678 = _t1680 + if self.match_lookahead_terminal("FLOAT", 0): + _t1701 = 1 else: - raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1675 = _t1678 - _t1673 = _t1675 - _t1671 = _t1673 - _t1669 = _t1671 - _t1667 = _t1669 - _t1665 = _t1667 - _t1663 = _t1665 - _t1661 = _t1663 - _t1659 = _t1661 - _t1657 = _t1659 - _t1654 = _t1657 - _t1651 = _t1654 - result890 = _t1651 - self.record_span(span_start889, "Value") - return result890 - - def parse_date(self) -> logic_pb2.DateValue: - span_start894 = self.span_start() - self.consume_literal("(") - self.consume_literal("date") - formatted_int891 = self.consume_terminal("INT") - formatted_int_3892 = self.consume_terminal("INT") - formatted_int_4893 = self.consume_terminal("INT") - self.consume_literal(")") - _t1681 = logic_pb2.DateValue(year=int(formatted_int891), month=int(formatted_int_3892), day=int(formatted_int_4893)) - result895 = _t1681 - self.record_span(span_start894, "DateValue") - return result895 - - def parse_datetime(self) -> logic_pb2.DateTimeValue: - span_start903 = self.span_start() - self.consume_literal("(") - self.consume_literal("datetime") - formatted_int896 = self.consume_terminal("INT") - formatted_int_3897 = self.consume_terminal("INT") - formatted_int_4898 = self.consume_terminal("INT") - formatted_int_5899 = self.consume_terminal("INT") - formatted_int_6900 = self.consume_terminal("INT") - formatted_int_7901 = self.consume_terminal("INT") - if self.match_lookahead_terminal("INT", 0): - _t1682 = self.consume_terminal("INT") - else: - _t1682 = None - formatted_int_8902 = _t1682 - self.consume_literal(")") - _t1683 = logic_pb2.DateTimeValue(year=int(formatted_int896), month=int(formatted_int_3897), day=int(formatted_int_4898), hour=int(formatted_int_5899), minute=int(formatted_int_6900), second=int(formatted_int_7901), microsecond=int((formatted_int_8902 if formatted_int_8902 is not None else 0))) - result904 = _t1683 - self.record_span(span_start903, "DateTimeValue") - return result904 + if self.match_lookahead_terminal("DECIMAL", 0): + _t1702 = 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 + else: + if prediction905 == 0: + _t1707 = self.parse_var() + var906 = _t1707 + _t1708 = logic_pb2.Term(var=var906) + _t1706 = _t1708 + 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 - def parse_conjunction(self) -> logic_pb2.Conjunction: - span_start909 = self.span_start() - self.consume_literal("(") - self.consume_literal("and") - xs905 = [] - cond906 = self.match_lookahead_literal("(", 0) - while cond906: - _t1684 = self.parse_formula() - item907 = _t1684 - xs905.append(item907) - cond906 = self.match_lookahead_literal("(", 0) - formulas908 = xs905 - self.consume_literal(")") - _t1685 = logic_pb2.Conjunction(args=formulas908) - result910 = _t1685 - self.record_span(span_start909, "Conjunction") - return result910 + 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 - def parse_disjunction(self) -> logic_pb2.Disjunction: - span_start915 = self.span_start() - self.consume_literal("(") - self.consume_literal("or") - xs911 = [] - cond912 = self.match_lookahead_literal("(", 0) - while cond912: - _t1686 = self.parse_formula() - item913 = _t1686 - xs911.append(item913) - cond912 = self.match_lookahead_literal("(", 0) - formulas914 = xs911 - self.consume_literal(")") - _t1687 = logic_pb2.Disjunction(args=formulas914) - result916 = _t1687 - self.record_span(span_start915, "Disjunction") - return result916 -======= - span_start923 = self.span_start() + def parse_value(self) -> logic_pb2.Value: + span_start926 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1704 = 12 + _t1710 = 12 else: if self.match_lookahead_literal("missing", 0): - _t1705 = 11 + _t1711 = 11 else: if self.match_lookahead_literal("false", 0): - _t1706 = 12 + _t1712 = 12 else: if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("datetime", 1): - _t1708 = 1 + _t1714 = 1 else: if self.match_lookahead_literal("date", 1): - _t1709 = 0 + _t1715 = 0 else: - _t1709 = -1 - _t1708 = _t1709 - _t1707 = _t1708 + _t1715 = -1 + _t1714 = _t1715 + _t1713 = _t1714 else: if self.match_lookahead_terminal("UINT32", 0): - _t1710 = 7 + _t1716 = 7 else: if self.match_lookahead_terminal("UINT128", 0): - _t1711 = 8 + _t1717 = 8 else: if self.match_lookahead_terminal("STRING", 0): - _t1712 = 2 + _t1718 = 2 else: if self.match_lookahead_terminal("INT32", 0): - _t1713 = 3 + _t1719 = 3 else: if self.match_lookahead_terminal("INT128", 0): - _t1714 = 9 + _t1720 = 9 else: if self.match_lookahead_terminal("INT", 0): - _t1715 = 4 + _t1721 = 4 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1716 = 5 + _t1722 = 5 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1717 = 6 + _t1723 = 6 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1718 = 10 + _t1724 = 10 else: - _t1718 = -1 - _t1717 = _t1718 - _t1716 = _t1717 - _t1715 = _t1716 - _t1714 = _t1715 - _t1713 = _t1714 - _t1712 = _t1713 - _t1711 = _t1712 - _t1710 = _t1711 - _t1707 = _t1710 - _t1706 = _t1707 - _t1705 = _t1706 - _t1704 = _t1705 - prediction910 = _t1704 - if prediction910 == 12: - _t1720 = self.parse_boolean_value() - boolean_value922 = _t1720 - _t1721 = logic_pb2.Value(boolean_value=boolean_value922) - _t1719 = _t1721 - else: - if prediction910 == 11: + _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 + else: + if prediction913 == 11: self.consume_literal("missing") - _t1723 = logic_pb2.MissingValue() - _t1724 = logic_pb2.Value(missing_value=_t1723) - _t1722 = _t1724 + _t1729 = logic_pb2.MissingValue() + _t1730 = logic_pb2.Value(missing_value=_t1729) + _t1728 = _t1730 else: - if prediction910 == 10: - formatted_decimal921 = self.consume_terminal("DECIMAL") - _t1726 = logic_pb2.Value(decimal_value=formatted_decimal921) - _t1725 = _t1726 + if prediction913 == 10: + formatted_decimal924 = self.consume_terminal("DECIMAL") + _t1732 = logic_pb2.Value(decimal_value=formatted_decimal924) + _t1731 = _t1732 else: - if prediction910 == 9: - formatted_int128920 = self.consume_terminal("INT128") - _t1728 = logic_pb2.Value(int128_value=formatted_int128920) - _t1727 = _t1728 + if prediction913 == 9: + formatted_int128923 = self.consume_terminal("INT128") + _t1734 = logic_pb2.Value(int128_value=formatted_int128923) + _t1733 = _t1734 else: - if prediction910 == 8: - formatted_uint128919 = self.consume_terminal("UINT128") - _t1730 = logic_pb2.Value(uint128_value=formatted_uint128919) - _t1729 = _t1730 + if prediction913 == 8: + formatted_uint128922 = self.consume_terminal("UINT128") + _t1736 = logic_pb2.Value(uint128_value=formatted_uint128922) + _t1735 = _t1736 else: - if prediction910 == 7: - formatted_uint32918 = self.consume_terminal("UINT32") - _t1732 = logic_pb2.Value(uint32_value=formatted_uint32918) - _t1731 = _t1732 + if prediction913 == 7: + formatted_uint32921 = self.consume_terminal("UINT32") + _t1738 = logic_pb2.Value(uint32_value=formatted_uint32921) + _t1737 = _t1738 else: - if prediction910 == 6: - formatted_float917 = self.consume_terminal("FLOAT") - _t1734 = logic_pb2.Value(float_value=formatted_float917) - _t1733 = _t1734 + if prediction913 == 6: + formatted_float920 = self.consume_terminal("FLOAT") + _t1740 = logic_pb2.Value(float_value=formatted_float920) + _t1739 = _t1740 else: - if prediction910 == 5: - formatted_float32916 = self.consume_terminal("FLOAT32") - _t1736 = logic_pb2.Value(float32_value=formatted_float32916) - _t1735 = _t1736 + if prediction913 == 5: + formatted_float32919 = self.consume_terminal("FLOAT32") + _t1742 = logic_pb2.Value(float32_value=formatted_float32919) + _t1741 = _t1742 else: - if prediction910 == 4: - formatted_int915 = self.consume_terminal("INT") - _t1738 = logic_pb2.Value(int_value=formatted_int915) - _t1737 = _t1738 + if prediction913 == 4: + formatted_int918 = self.consume_terminal("INT") + _t1744 = logic_pb2.Value(int_value=formatted_int918) + _t1743 = _t1744 else: - if prediction910 == 3: - formatted_int32914 = self.consume_terminal("INT32") - _t1740 = logic_pb2.Value(int32_value=formatted_int32914) - _t1739 = _t1740 + if prediction913 == 3: + formatted_int32917 = self.consume_terminal("INT32") + _t1746 = logic_pb2.Value(int32_value=formatted_int32917) + _t1745 = _t1746 else: - if prediction910 == 2: - formatted_string913 = self.consume_terminal("STRING") - _t1742 = logic_pb2.Value(string_value=formatted_string913) - _t1741 = _t1742 + if prediction913 == 2: + formatted_string916 = self.consume_terminal("STRING") + _t1748 = logic_pb2.Value(string_value=formatted_string916) + _t1747 = _t1748 else: - if prediction910 == 1: - _t1744 = self.parse_datetime() - datetime912 = _t1744 - _t1745 = logic_pb2.Value(datetime_value=datetime912) - _t1743 = _t1745 + if prediction913 == 1: + _t1750 = self.parse_datetime() + datetime915 = _t1750 + _t1751 = logic_pb2.Value(datetime_value=datetime915) + _t1749 = _t1751 else: - if prediction910 == 0: - _t1747 = self.parse_date() - date911 = _t1747 - _t1748 = logic_pb2.Value(date_value=date911) - _t1746 = _t1748 + if prediction913 == 0: + _t1753 = self.parse_date() + date914 = _t1753 + _t1754 = logic_pb2.Value(date_value=date914) + _t1752 = _t1754 else: raise ParseError("Unexpected token in value" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1743 = _t1746 - _t1741 = _t1743 - _t1739 = _t1741 - _t1737 = _t1739 - _t1735 = _t1737 - _t1733 = _t1735 - _t1731 = _t1733 - _t1729 = _t1731 - _t1727 = _t1729 - _t1725 = _t1727 - _t1722 = _t1725 - _t1719 = _t1722 - result924 = _t1719 - self.record_span(span_start923, "Value") - return result924 + _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 def parse_date(self) -> logic_pb2.DateValue: - span_start928 = self.span_start() + span_start931 = self.span_start() self.consume_literal("(") self.consume_literal("date") - formatted_int925 = self.consume_terminal("INT") - formatted_int_3926 = self.consume_terminal("INT") - formatted_int_4927 = self.consume_terminal("INT") + formatted_int928 = self.consume_terminal("INT") + formatted_int_3929 = self.consume_terminal("INT") + formatted_int_4930 = self.consume_terminal("INT") self.consume_literal(")") - _t1749 = logic_pb2.DateValue(year=int(formatted_int925), month=int(formatted_int_3926), day=int(formatted_int_4927)) - result929 = _t1749 - self.record_span(span_start928, "DateValue") - return result929 + _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 def parse_datetime(self) -> logic_pb2.DateTimeValue: - span_start937 = self.span_start() + span_start940 = self.span_start() self.consume_literal("(") self.consume_literal("datetime") - formatted_int930 = self.consume_terminal("INT") - formatted_int_3931 = self.consume_terminal("INT") - formatted_int_4932 = self.consume_terminal("INT") - formatted_int_5933 = self.consume_terminal("INT") - formatted_int_6934 = self.consume_terminal("INT") - formatted_int_7935 = self.consume_terminal("INT") + 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") if self.match_lookahead_terminal("INT", 0): - _t1750 = self.consume_terminal("INT") + _t1756 = self.consume_terminal("INT") else: - _t1750 = None - formatted_int_8936 = _t1750 + _t1756 = None + formatted_int_8939 = _t1756 self.consume_literal(")") - _t1751 = logic_pb2.DateTimeValue(year=int(formatted_int930), month=int(formatted_int_3931), day=int(formatted_int_4932), hour=int(formatted_int_5933), minute=int(formatted_int_6934), second=int(formatted_int_7935), microsecond=int((formatted_int_8936 if formatted_int_8936 is not None else 0))) - result938 = _t1751 - self.record_span(span_start937, "DateTimeValue") - return result938 + _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 def parse_conjunction(self) -> logic_pb2.Conjunction: - span_start943 = self.span_start() + span_start946 = self.span_start() self.consume_literal("(") self.consume_literal("and") - xs939 = [] - cond940 = self.match_lookahead_literal("(", 0) - while cond940: - _t1752 = self.parse_formula() - item941 = _t1752 - xs939.append(item941) - cond940 = self.match_lookahead_literal("(", 0) - formulas942 = xs939 - self.consume_literal(")") - _t1753 = logic_pb2.Conjunction(args=formulas942) - result944 = _t1753 - self.record_span(span_start943, "Conjunction") - return result944 + 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 + self.consume_literal(")") + _t1759 = logic_pb2.Conjunction(args=formulas945) + result947 = _t1759 + self.record_span(span_start946, "Conjunction") + return result947 def parse_disjunction(self) -> logic_pb2.Disjunction: - span_start949 = self.span_start() - self.consume_literal("(") - self.consume_literal("or") - xs945 = [] - cond946 = self.match_lookahead_literal("(", 0) - while cond946: - _t1754 = self.parse_formula() - item947 = _t1754 - xs945.append(item947) - cond946 = self.match_lookahead_literal("(", 0) - formulas948 = xs945 - self.consume_literal(")") - _t1755 = logic_pb2.Disjunction(args=formulas948) - result950 = _t1755 - self.record_span(span_start949, "Disjunction") - return result950 - - def parse_not(self) -> logic_pb2.Not: span_start952 = self.span_start() self.consume_literal("(") - self.consume_literal("not") - _t1756 = self.parse_formula() - formula951 = _t1756 - self.consume_literal(")") - _t1757 = logic_pb2.Not(arg=formula951) - result953 = _t1757 - self.record_span(span_start952, "Not") + 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 + self.consume_literal(")") + _t1761 = logic_pb2.Disjunction(args=formulas951) + result953 = _t1761 + self.record_span(span_start952, "Disjunction") return result953 ->>>>>>> origin/main def parse_not(self) -> logic_pb2.Not: - span_start918 = self.span_start() + span_start955 = self.span_start() self.consume_literal("(") self.consume_literal("not") - _t1688 = self.parse_formula() - formula917 = _t1688 + _t1762 = self.parse_formula() + formula954 = _t1762 self.consume_literal(")") - _t1689 = logic_pb2.Not(arg=formula917) - result919 = _t1689 - self.record_span(span_start918, "Not") - return result919 + _t1763 = logic_pb2.Not(arg=formula954) + result956 = _t1763 + self.record_span(span_start955, "Not") + return result956 def parse_ffi(self) -> logic_pb2.FFI: -<<<<<<< HEAD - span_start923 = self.span_start() - self.consume_literal("(") - self.consume_literal("ffi") - _t1690 = self.parse_name() - name920 = _t1690 - _t1691 = self.parse_ffi_args() - ffi_args921 = _t1691 - _t1692 = self.parse_terms() - terms922 = _t1692 - self.consume_literal(")") - _t1693 = logic_pb2.FFI(name=name920, args=ffi_args921, terms=terms922) - result924 = _t1693 - self.record_span(span_start923, "FFI") - return result924 - - def parse_name(self) -> str: - self.consume_literal(":") - symbol925 = self.consume_terminal("SYMBOL") - return symbol925 -======= - span_start957 = self.span_start() + span_start960 = self.span_start() self.consume_literal("(") self.consume_literal("ffi") - _t1758 = self.parse_name() - name954 = _t1758 - _t1759 = self.parse_ffi_args() - ffi_args955 = _t1759 - _t1760 = self.parse_terms() - terms956 = _t1760 - self.consume_literal(")") - _t1761 = logic_pb2.FFI(name=name954, args=ffi_args955, terms=terms956) - result958 = _t1761 - self.record_span(span_start957, "FFI") - return result958 + _t1764 = self.parse_name() + name957 = _t1764 + _t1765 = self.parse_ffi_args() + ffi_args958 = _t1765 + _t1766 = self.parse_terms() + terms959 = _t1766 + self.consume_literal(")") + _t1767 = logic_pb2.FFI(name=name957, args=ffi_args958, terms=terms959) + result961 = _t1767 + self.record_span(span_start960, "FFI") + return result961 def parse_name(self) -> str: self.consume_literal(":") - symbol959 = self.consume_terminal("SYMBOL") - return symbol959 ->>>>>>> origin/main + symbol962 = self.consume_terminal("SYMBOL") + return symbol962 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") -<<<<<<< HEAD - xs926 = [] - cond927 = self.match_lookahead_literal("(", 0) - while cond927: - _t1694 = self.parse_abstraction() - item928 = _t1694 - xs926.append(item928) - cond927 = self.match_lookahead_literal("(", 0) - abstractions929 = xs926 + 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 self.consume_literal(")") - return abstractions929 + return abstractions966 def parse_atom(self) -> logic_pb2.Atom: - span_start935 = self.span_start() + span_start972 = self.span_start() self.consume_literal("(") self.consume_literal("atom") - _t1695 = self.parse_relation_id() - relation_id930 = _t1695 - xs931 = [] - cond932 = (((((((((((((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 cond932: - _t1696 = self.parse_term() - item933 = _t1696 - xs931.append(item933) - cond932 = (((((((((((((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)) - terms934 = xs931 - self.consume_literal(")") - _t1697 = logic_pb2.Atom(name=relation_id930, terms=terms934) - result936 = _t1697 - self.record_span(span_start935, "Atom") - return result936 + _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 + self.consume_literal(")") + _t1771 = logic_pb2.Atom(name=relation_id967, terms=terms971) + result973 = _t1771 + self.record_span(span_start972, "Atom") + return result973 def parse_pragma(self) -> logic_pb2.Pragma: - span_start942 = self.span_start() - self.consume_literal("(") - self.consume_literal("pragma") - _t1698 = self.parse_name() - name937 = _t1698 - xs938 = [] - cond939 = (((((((((((((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 cond939: - _t1699 = self.parse_term() - item940 = _t1699 - xs938.append(item940) - cond939 = (((((((((((((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)) - terms941 = xs938 - self.consume_literal(")") - _t1700 = logic_pb2.Pragma(name=name937, terms=terms941) - result943 = _t1700 - self.record_span(span_start942, "Pragma") - return result943 - - def parse_primitive(self) -> logic_pb2.Primitive: - span_start959 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("primitive", 1): - _t1702 = 9 - else: - if self.match_lookahead_literal(">=", 1): - _t1703 = 4 - else: - if self.match_lookahead_literal(">", 1): - _t1704 = 3 - else: - if self.match_lookahead_literal("=", 1): - _t1705 = 0 - else: - if self.match_lookahead_literal("<=", 1): - _t1706 = 2 - else: - if self.match_lookahead_literal("<", 1): - _t1707 = 1 - else: - if self.match_lookahead_literal("/", 1): - _t1708 = 8 - else: - if self.match_lookahead_literal("-", 1): - _t1709 = 6 - else: - if self.match_lookahead_literal("+", 1): - _t1710 = 5 - else: - if self.match_lookahead_literal("*", 1): - _t1711 = 7 - else: - _t1711 = -1 - _t1710 = _t1711 - _t1709 = _t1710 - _t1708 = _t1709 - _t1707 = _t1708 - _t1706 = _t1707 - _t1705 = _t1706 - _t1704 = _t1705 - _t1703 = _t1704 - _t1702 = _t1703 - _t1701 = _t1702 - else: - _t1701 = -1 - prediction944 = _t1701 - if prediction944 == 9: - self.consume_literal("(") - self.consume_literal("primitive") - _t1713 = self.parse_name() - name954 = _t1713 - xs955 = [] - cond956 = ((((((((((((((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 cond956: - _t1714 = self.parse_rel_term() - item957 = _t1714 - xs955.append(item957) - cond956 = ((((((((((((((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_terms958 = xs955 - self.consume_literal(")") - _t1715 = logic_pb2.Primitive(name=name954, terms=rel_terms958) - _t1712 = _t1715 - else: - if prediction944 == 8: - _t1717 = self.parse_divide() - divide953 = _t1717 - _t1716 = divide953 - else: - if prediction944 == 7: - _t1719 = self.parse_multiply() - multiply952 = _t1719 - _t1718 = multiply952 - else: - if prediction944 == 6: - _t1721 = self.parse_minus() - minus951 = _t1721 - _t1720 = minus951 - else: - if prediction944 == 5: - _t1723 = self.parse_add() - add950 = _t1723 - _t1722 = add950 - else: - if prediction944 == 4: - _t1725 = self.parse_gt_eq() - gt_eq949 = _t1725 - _t1724 = gt_eq949 - else: - if prediction944 == 3: - _t1727 = self.parse_gt() - gt948 = _t1727 - _t1726 = gt948 - else: - if prediction944 == 2: - _t1729 = self.parse_lt_eq() - lt_eq947 = _t1729 - _t1728 = lt_eq947 - else: - if prediction944 == 1: - _t1731 = self.parse_lt() - lt946 = _t1731 - _t1730 = lt946 - else: - if prediction944 == 0: - _t1733 = self.parse_eq() - eq945 = _t1733 - _t1732 = eq945 - else: - raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1730 = _t1732 - _t1728 = _t1730 - _t1726 = _t1728 - _t1724 = _t1726 - _t1722 = _t1724 - _t1720 = _t1722 - _t1718 = _t1720 - _t1716 = _t1718 - _t1712 = _t1716 - result960 = _t1712 - self.record_span(span_start959, "Primitive") - return result960 - - def parse_eq(self) -> logic_pb2.Primitive: - span_start963 = self.span_start() - self.consume_literal("(") - self.consume_literal("=") - _t1734 = self.parse_term() - term961 = _t1734 - _t1735 = self.parse_term() - term_3962 = _t1735 - self.consume_literal(")") - _t1736 = logic_pb2.RelTerm(term=term961) - _t1737 = logic_pb2.RelTerm(term=term_3962) - _t1738 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1736, _t1737]) - result964 = _t1738 - self.record_span(span_start963, "Primitive") - return result964 - - def parse_lt(self) -> logic_pb2.Primitive: - span_start967 = self.span_start() - self.consume_literal("(") - self.consume_literal("<") - _t1739 = self.parse_term() - term965 = _t1739 - _t1740 = self.parse_term() - term_3966 = _t1740 - self.consume_literal(")") - _t1741 = logic_pb2.RelTerm(term=term965) - _t1742 = logic_pb2.RelTerm(term=term_3966) - _t1743 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1741, _t1742]) - result968 = _t1743 - self.record_span(span_start967, "Primitive") - return result968 - - def parse_lt_eq(self) -> logic_pb2.Primitive: - span_start971 = self.span_start() - self.consume_literal("(") - self.consume_literal("<=") - _t1744 = self.parse_term() - term969 = _t1744 - _t1745 = self.parse_term() - term_3970 = _t1745 - self.consume_literal(")") - _t1746 = logic_pb2.RelTerm(term=term969) - _t1747 = logic_pb2.RelTerm(term=term_3970) - _t1748 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1746, _t1747]) - result972 = _t1748 - self.record_span(span_start971, "Primitive") - return result972 - - def parse_gt(self) -> logic_pb2.Primitive: - span_start975 = self.span_start() - self.consume_literal("(") - self.consume_literal(">") - _t1749 = self.parse_term() - term973 = _t1749 - _t1750 = self.parse_term() - term_3974 = _t1750 - self.consume_literal(")") - _t1751 = logic_pb2.RelTerm(term=term973) - _t1752 = logic_pb2.RelTerm(term=term_3974) - _t1753 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1751, _t1752]) - result976 = _t1753 - self.record_span(span_start975, "Primitive") - return result976 - - def parse_gt_eq(self) -> logic_pb2.Primitive: span_start979 = self.span_start() self.consume_literal("(") - self.consume_literal(">=") - _t1754 = self.parse_term() - term977 = _t1754 - _t1755 = self.parse_term() - term_3978 = _t1755 - self.consume_literal(")") - _t1756 = logic_pb2.RelTerm(term=term977) - _t1757 = logic_pb2.RelTerm(term=term_3978) - _t1758 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1756, _t1757]) - result980 = _t1758 - self.record_span(span_start979, "Primitive") - return result980 - - def parse_add(self) -> logic_pb2.Primitive: - span_start984 = self.span_start() - self.consume_literal("(") - self.consume_literal("+") - _t1759 = self.parse_term() - term981 = _t1759 - _t1760 = self.parse_term() - term_3982 = _t1760 - _t1761 = self.parse_term() - term_4983 = _t1761 - self.consume_literal(")") - _t1762 = logic_pb2.RelTerm(term=term981) - _t1763 = logic_pb2.RelTerm(term=term_3982) - _t1764 = logic_pb2.RelTerm(term=term_4983) - _t1765 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1762, _t1763, _t1764]) - result985 = _t1765 - self.record_span(span_start984, "Primitive") - return result985 - - def parse_minus(self) -> logic_pb2.Primitive: - span_start989 = self.span_start() - self.consume_literal("(") - self.consume_literal("-") - _t1766 = self.parse_term() - term986 = _t1766 - _t1767 = self.parse_term() - term_3987 = _t1767 - _t1768 = self.parse_term() - term_4988 = _t1768 - self.consume_literal(")") - _t1769 = logic_pb2.RelTerm(term=term986) - _t1770 = logic_pb2.RelTerm(term=term_3987) - _t1771 = logic_pb2.RelTerm(term=term_4988) - _t1772 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1769, _t1770, _t1771]) - result990 = _t1772 - self.record_span(span_start989, "Primitive") - return result990 - - def parse_multiply(self) -> logic_pb2.Primitive: - span_start994 = self.span_start() - self.consume_literal("(") - self.consume_literal("*") - _t1773 = self.parse_term() - term991 = _t1773 - _t1774 = self.parse_term() - term_3992 = _t1774 - _t1775 = self.parse_term() - term_4993 = _t1775 - self.consume_literal(")") - _t1776 = logic_pb2.RelTerm(term=term991) - _t1777 = logic_pb2.RelTerm(term=term_3992) - _t1778 = logic_pb2.RelTerm(term=term_4993) - _t1779 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1776, _t1777, _t1778]) - result995 = _t1779 - self.record_span(span_start994, "Primitive") - return result995 - - def parse_divide(self) -> logic_pb2.Primitive: - span_start999 = self.span_start() - self.consume_literal("(") - self.consume_literal("/") - _t1780 = self.parse_term() - term996 = _t1780 - _t1781 = self.parse_term() - term_3997 = _t1781 - _t1782 = self.parse_term() - term_4998 = _t1782 - self.consume_literal(")") - _t1783 = logic_pb2.RelTerm(term=term996) - _t1784 = logic_pb2.RelTerm(term=term_3997) - _t1785 = logic_pb2.RelTerm(term=term_4998) - _t1786 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1783, _t1784, _t1785]) - result1000 = _t1786 - self.record_span(span_start999, "Primitive") - return result1000 - - def parse_rel_term(self) -> logic_pb2.RelTerm: - span_start1004 = self.span_start() - if self.match_lookahead_literal("true", 0): - _t1787 = 1 - else: - if self.match_lookahead_literal("missing", 0): - _t1788 = 1 - else: - if self.match_lookahead_literal("false", 0): - _t1789 = 1 - else: - if self.match_lookahead_literal("(", 0): - _t1790 = 1 - else: - if self.match_lookahead_literal("#", 0): - _t1791 = 0 - else: - if self.match_lookahead_terminal("SYMBOL", 0): - _t1792 = 1 - else: - if self.match_lookahead_terminal("UINT32", 0): - _t1793 = 1 - else: - if self.match_lookahead_terminal("UINT128", 0): - _t1794 = 1 - else: - if self.match_lookahead_terminal("STRING", 0): - _t1795 = 1 - else: - if self.match_lookahead_terminal("INT32", 0): - _t1796 = 1 - else: - if self.match_lookahead_terminal("INT128", 0): - _t1797 = 1 - else: - if self.match_lookahead_terminal("INT", 0): - _t1798 = 1 - else: - if self.match_lookahead_terminal("FLOAT32", 0): - _t1799 = 1 - else: - if self.match_lookahead_terminal("FLOAT", 0): - _t1800 = 1 - else: - if self.match_lookahead_terminal("DECIMAL", 0): - _t1801 = 1 - else: - _t1801 = -1 - _t1800 = _t1801 - _t1799 = _t1800 - _t1798 = _t1799 - _t1797 = _t1798 - _t1796 = _t1797 - _t1795 = _t1796 - _t1794 = _t1795 - _t1793 = _t1794 - _t1792 = _t1793 - _t1791 = _t1792 - _t1790 = _t1791 - _t1789 = _t1790 - _t1788 = _t1789 - _t1787 = _t1788 - prediction1001 = _t1787 - if prediction1001 == 1: - _t1803 = self.parse_term() - term1003 = _t1803 - _t1804 = logic_pb2.RelTerm(term=term1003) - _t1802 = _t1804 - else: - if prediction1001 == 0: - _t1806 = self.parse_specialized_value() - specialized_value1002 = _t1806 - _t1807 = logic_pb2.RelTerm(specialized_value=specialized_value1002) - _t1805 = _t1807 - else: - raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1802 = _t1805 - result1005 = _t1802 - self.record_span(span_start1004, "RelTerm") - return result1005 -======= - xs960 = [] - cond961 = self.match_lookahead_literal("(", 0) - while cond961: - _t1762 = self.parse_abstraction() - item962 = _t1762 - xs960.append(item962) - cond961 = self.match_lookahead_literal("(", 0) - abstractions963 = xs960 - self.consume_literal(")") - return abstractions963 - - def parse_atom(self) -> logic_pb2.Atom: - span_start969 = self.span_start() - self.consume_literal("(") - self.consume_literal("atom") - _t1763 = self.parse_relation_id() - relation_id964 = _t1763 - xs965 = [] - cond966 = (((((((((((((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 cond966: - _t1764 = self.parse_term() - item967 = _t1764 - xs965.append(item967) - cond966 = (((((((((((((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)) - terms968 = xs965 - self.consume_literal(")") - _t1765 = logic_pb2.Atom(name=relation_id964, terms=terms968) - result970 = _t1765 - self.record_span(span_start969, "Atom") - return result970 - - def parse_pragma(self) -> logic_pb2.Pragma: - span_start976 = self.span_start() - self.consume_literal("(") self.consume_literal("pragma") - _t1766 = self.parse_name() - name971 = _t1766 - xs972 = [] - cond973 = (((((((((((((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 cond973: - _t1767 = self.parse_term() - item974 = _t1767 - xs972.append(item974) - cond973 = (((((((((((((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)) - terms975 = xs972 - self.consume_literal(")") - _t1768 = logic_pb2.Pragma(name=name971, terms=terms975) - result977 = _t1768 - self.record_span(span_start976, "Pragma") - return result977 + _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 + self.consume_literal(")") + _t1774 = logic_pb2.Pragma(name=name974, terms=terms978) + result980 = _t1774 + self.record_span(span_start979, "Pragma") + return result980 def parse_primitive(self) -> logic_pb2.Primitive: - span_start993 = self.span_start() + span_start996 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("primitive", 1): - _t1770 = 9 + _t1776 = 9 else: if self.match_lookahead_literal(">=", 1): - _t1771 = 4 + _t1777 = 4 else: if self.match_lookahead_literal(">", 1): - _t1772 = 3 + _t1778 = 3 else: if self.match_lookahead_literal("=", 1): - _t1773 = 0 + _t1779 = 0 else: if self.match_lookahead_literal("<=", 1): - _t1774 = 2 + _t1780 = 2 else: if self.match_lookahead_literal("<", 1): - _t1775 = 1 + _t1781 = 1 else: if self.match_lookahead_literal("/", 1): - _t1776 = 8 + _t1782 = 8 else: if self.match_lookahead_literal("-", 1): - _t1777 = 6 + _t1783 = 6 else: if self.match_lookahead_literal("+", 1): - _t1778 = 5 + _t1784 = 5 else: if self.match_lookahead_literal("*", 1): - _t1779 = 7 + _t1785 = 7 else: - _t1779 = -1 - _t1778 = _t1779 - _t1777 = _t1778 - _t1776 = _t1777 - _t1775 = _t1776 - _t1774 = _t1775 - _t1773 = _t1774 - _t1772 = _t1773 - _t1771 = _t1772 - _t1770 = _t1771 - _t1769 = _t1770 - else: - _t1769 = -1 - prediction978 = _t1769 - if prediction978 == 9: + _t1785 = -1 + _t1784 = _t1785 + _t1783 = _t1784 + _t1782 = _t1783 + _t1781 = _t1782 + _t1780 = _t1781 + _t1779 = _t1780 + _t1778 = _t1779 + _t1777 = _t1778 + _t1776 = _t1777 + _t1775 = _t1776 + else: + _t1775 = -1 + prediction981 = _t1775 + if prediction981 == 9: self.consume_literal("(") self.consume_literal("primitive") - _t1781 = self.parse_name() - name988 = _t1781 - xs989 = [] - cond990 = ((((((((((((((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 cond990: - _t1782 = self.parse_rel_term() - item991 = _t1782 - xs989.append(item991) - cond990 = ((((((((((((((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_terms992 = xs989 + _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 self.consume_literal(")") - _t1783 = logic_pb2.Primitive(name=name988, terms=rel_terms992) - _t1780 = _t1783 + _t1789 = logic_pb2.Primitive(name=name991, terms=rel_terms995) + _t1786 = _t1789 else: - if prediction978 == 8: - _t1785 = self.parse_divide() - divide987 = _t1785 - _t1784 = divide987 + if prediction981 == 8: + _t1791 = self.parse_divide() + divide990 = _t1791 + _t1790 = divide990 else: - if prediction978 == 7: - _t1787 = self.parse_multiply() - multiply986 = _t1787 - _t1786 = multiply986 + if prediction981 == 7: + _t1793 = self.parse_multiply() + multiply989 = _t1793 + _t1792 = multiply989 else: - if prediction978 == 6: - _t1789 = self.parse_minus() - minus985 = _t1789 - _t1788 = minus985 + if prediction981 == 6: + _t1795 = self.parse_minus() + minus988 = _t1795 + _t1794 = minus988 else: - if prediction978 == 5: - _t1791 = self.parse_add() - add984 = _t1791 - _t1790 = add984 + if prediction981 == 5: + _t1797 = self.parse_add() + add987 = _t1797 + _t1796 = add987 else: - if prediction978 == 4: - _t1793 = self.parse_gt_eq() - gt_eq983 = _t1793 - _t1792 = gt_eq983 + if prediction981 == 4: + _t1799 = self.parse_gt_eq() + gt_eq986 = _t1799 + _t1798 = gt_eq986 else: - if prediction978 == 3: - _t1795 = self.parse_gt() - gt982 = _t1795 - _t1794 = gt982 + if prediction981 == 3: + _t1801 = self.parse_gt() + gt985 = _t1801 + _t1800 = gt985 else: - if prediction978 == 2: - _t1797 = self.parse_lt_eq() - lt_eq981 = _t1797 - _t1796 = lt_eq981 + if prediction981 == 2: + _t1803 = self.parse_lt_eq() + lt_eq984 = _t1803 + _t1802 = lt_eq984 else: - if prediction978 == 1: - _t1799 = self.parse_lt() - lt980 = _t1799 - _t1798 = lt980 + if prediction981 == 1: + _t1805 = self.parse_lt() + lt983 = _t1805 + _t1804 = lt983 else: - if prediction978 == 0: - _t1801 = self.parse_eq() - eq979 = _t1801 - _t1800 = eq979 + if prediction981 == 0: + _t1807 = self.parse_eq() + eq982 = _t1807 + _t1806 = eq982 else: raise ParseError("Unexpected token in primitive" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1798 = _t1800 - _t1796 = _t1798 - _t1794 = _t1796 - _t1792 = _t1794 - _t1790 = _t1792 - _t1788 = _t1790 - _t1786 = _t1788 - _t1784 = _t1786 - _t1780 = _t1784 - result994 = _t1780 - self.record_span(span_start993, "Primitive") - return result994 + _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 def parse_eq(self) -> logic_pb2.Primitive: - span_start997 = self.span_start() + span_start1000 = self.span_start() self.consume_literal("(") self.consume_literal("=") - _t1802 = self.parse_term() - term995 = _t1802 - _t1803 = self.parse_term() - term_3996 = _t1803 + _t1808 = self.parse_term() + term998 = _t1808 + _t1809 = self.parse_term() + term_3999 = _t1809 self.consume_literal(")") - _t1804 = logic_pb2.RelTerm(term=term995) - _t1805 = logic_pb2.RelTerm(term=term_3996) - _t1806 = logic_pb2.Primitive(name="rel_primitive_eq", terms=[_t1804, _t1805]) - result998 = _t1806 - self.record_span(span_start997, "Primitive") - return result998 + _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 def parse_lt(self) -> logic_pb2.Primitive: - span_start1001 = self.span_start() + span_start1004 = self.span_start() self.consume_literal("(") self.consume_literal("<") - _t1807 = self.parse_term() - term999 = _t1807 - _t1808 = self.parse_term() - term_31000 = _t1808 - self.consume_literal(")") - _t1809 = logic_pb2.RelTerm(term=term999) - _t1810 = logic_pb2.RelTerm(term=term_31000) - _t1811 = logic_pb2.Primitive(name="rel_primitive_lt_monotype", terms=[_t1809, _t1810]) - result1002 = _t1811 - self.record_span(span_start1001, "Primitive") - return result1002 + _t1813 = self.parse_term() + term1002 = _t1813 + _t1814 = self.parse_term() + term_31003 = _t1814 + 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 def parse_lt_eq(self) -> logic_pb2.Primitive: - span_start1005 = self.span_start() + span_start1008 = self.span_start() self.consume_literal("(") self.consume_literal("<=") - _t1812 = self.parse_term() - term1003 = _t1812 - _t1813 = self.parse_term() - term_31004 = _t1813 + _t1818 = self.parse_term() + term1006 = _t1818 + _t1819 = self.parse_term() + term_31007 = _t1819 self.consume_literal(")") - _t1814 = logic_pb2.RelTerm(term=term1003) - _t1815 = logic_pb2.RelTerm(term=term_31004) - _t1816 = logic_pb2.Primitive(name="rel_primitive_lt_eq_monotype", terms=[_t1814, _t1815]) - result1006 = _t1816 - self.record_span(span_start1005, "Primitive") - return result1006 + _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 def parse_gt(self) -> logic_pb2.Primitive: - span_start1009 = self.span_start() + span_start1012 = self.span_start() self.consume_literal("(") self.consume_literal(">") - _t1817 = self.parse_term() - term1007 = _t1817 - _t1818 = self.parse_term() - term_31008 = _t1818 + _t1823 = self.parse_term() + term1010 = _t1823 + _t1824 = self.parse_term() + term_31011 = _t1824 self.consume_literal(")") - _t1819 = logic_pb2.RelTerm(term=term1007) - _t1820 = logic_pb2.RelTerm(term=term_31008) - _t1821 = logic_pb2.Primitive(name="rel_primitive_gt_monotype", terms=[_t1819, _t1820]) - result1010 = _t1821 - self.record_span(span_start1009, "Primitive") - return result1010 + _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 def parse_gt_eq(self) -> logic_pb2.Primitive: - span_start1013 = self.span_start() + span_start1016 = self.span_start() self.consume_literal("(") self.consume_literal(">=") - _t1822 = self.parse_term() - term1011 = _t1822 - _t1823 = self.parse_term() - term_31012 = _t1823 + _t1828 = self.parse_term() + term1014 = _t1828 + _t1829 = self.parse_term() + term_31015 = _t1829 self.consume_literal(")") - _t1824 = logic_pb2.RelTerm(term=term1011) - _t1825 = logic_pb2.RelTerm(term=term_31012) - _t1826 = logic_pb2.Primitive(name="rel_primitive_gt_eq_monotype", terms=[_t1824, _t1825]) - result1014 = _t1826 - self.record_span(span_start1013, "Primitive") - return result1014 + _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 def parse_add(self) -> logic_pb2.Primitive: - span_start1018 = self.span_start() + span_start1021 = self.span_start() self.consume_literal("(") self.consume_literal("+") - _t1827 = self.parse_term() - term1015 = _t1827 - _t1828 = self.parse_term() - term_31016 = _t1828 - _t1829 = self.parse_term() - term_41017 = _t1829 + _t1833 = self.parse_term() + term1018 = _t1833 + _t1834 = self.parse_term() + term_31019 = _t1834 + _t1835 = self.parse_term() + term_41020 = _t1835 self.consume_literal(")") - _t1830 = logic_pb2.RelTerm(term=term1015) - _t1831 = logic_pb2.RelTerm(term=term_31016) - _t1832 = logic_pb2.RelTerm(term=term_41017) - _t1833 = logic_pb2.Primitive(name="rel_primitive_add_monotype", terms=[_t1830, _t1831, _t1832]) - result1019 = _t1833 - self.record_span(span_start1018, "Primitive") - return result1019 + _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 def parse_minus(self) -> logic_pb2.Primitive: - span_start1023 = self.span_start() + span_start1026 = self.span_start() self.consume_literal("(") self.consume_literal("-") - _t1834 = self.parse_term() - term1020 = _t1834 - _t1835 = self.parse_term() - term_31021 = _t1835 - _t1836 = self.parse_term() - term_41022 = _t1836 + _t1840 = self.parse_term() + term1023 = _t1840 + _t1841 = self.parse_term() + term_31024 = _t1841 + _t1842 = self.parse_term() + term_41025 = _t1842 self.consume_literal(")") - _t1837 = logic_pb2.RelTerm(term=term1020) - _t1838 = logic_pb2.RelTerm(term=term_31021) - _t1839 = logic_pb2.RelTerm(term=term_41022) - _t1840 = logic_pb2.Primitive(name="rel_primitive_subtract_monotype", terms=[_t1837, _t1838, _t1839]) - result1024 = _t1840 - self.record_span(span_start1023, "Primitive") - return result1024 + _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 def parse_multiply(self) -> logic_pb2.Primitive: - span_start1028 = self.span_start() + span_start1031 = self.span_start() self.consume_literal("(") self.consume_literal("*") - _t1841 = self.parse_term() - term1025 = _t1841 - _t1842 = self.parse_term() - term_31026 = _t1842 - _t1843 = self.parse_term() - term_41027 = _t1843 + _t1847 = self.parse_term() + term1028 = _t1847 + _t1848 = self.parse_term() + term_31029 = _t1848 + _t1849 = self.parse_term() + term_41030 = _t1849 self.consume_literal(")") - _t1844 = logic_pb2.RelTerm(term=term1025) - _t1845 = logic_pb2.RelTerm(term=term_31026) - _t1846 = logic_pb2.RelTerm(term=term_41027) - _t1847 = logic_pb2.Primitive(name="rel_primitive_multiply_monotype", terms=[_t1844, _t1845, _t1846]) - result1029 = _t1847 - self.record_span(span_start1028, "Primitive") - return result1029 + _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 def parse_divide(self) -> logic_pb2.Primitive: - span_start1033 = self.span_start() + span_start1036 = self.span_start() self.consume_literal("(") self.consume_literal("/") - _t1848 = self.parse_term() - term1030 = _t1848 - _t1849 = self.parse_term() - term_31031 = _t1849 - _t1850 = self.parse_term() - term_41032 = _t1850 - self.consume_literal(")") - _t1851 = logic_pb2.RelTerm(term=term1030) - _t1852 = logic_pb2.RelTerm(term=term_31031) - _t1853 = logic_pb2.RelTerm(term=term_41032) - _t1854 = logic_pb2.Primitive(name="rel_primitive_divide_monotype", terms=[_t1851, _t1852, _t1853]) - result1034 = _t1854 - self.record_span(span_start1033, "Primitive") - return result1034 + _t1854 = self.parse_term() + term1033 = _t1854 + _t1855 = self.parse_term() + term_31034 = _t1855 + _t1856 = self.parse_term() + term_41035 = _t1856 + 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 def parse_rel_term(self) -> logic_pb2.RelTerm: - span_start1038 = self.span_start() + span_start1041 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1855 = 1 + _t1861 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1856 = 1 + _t1862 = 1 else: if self.match_lookahead_literal("false", 0): - _t1857 = 1 + _t1863 = 1 else: if self.match_lookahead_literal("(", 0): - _t1858 = 1 + _t1864 = 1 else: if self.match_lookahead_literal("#", 0): - _t1859 = 0 + _t1865 = 0 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1860 = 1 + _t1866 = 1 else: if self.match_lookahead_terminal("UINT32", 0): - _t1861 = 1 + _t1867 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1862 = 1 + _t1868 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1863 = 1 + _t1869 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1864 = 1 + _t1870 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1865 = 1 + _t1871 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1866 = 1 + _t1872 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1867 = 1 + _t1873 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1868 = 1 + _t1874 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1869 = 1 + _t1875 = 1 else: - _t1869 = -1 - _t1868 = _t1869 - _t1867 = _t1868 - _t1866 = _t1867 - _t1865 = _t1866 - _t1864 = _t1865 - _t1863 = _t1864 - _t1862 = _t1863 - _t1861 = _t1862 - _t1860 = _t1861 - _t1859 = _t1860 - _t1858 = _t1859 - _t1857 = _t1858 - _t1856 = _t1857 - _t1855 = _t1856 - prediction1035 = _t1855 - if prediction1035 == 1: - _t1871 = self.parse_term() - term1037 = _t1871 - _t1872 = logic_pb2.RelTerm(term=term1037) - _t1870 = _t1872 - else: - if prediction1035 == 0: - _t1874 = self.parse_specialized_value() - specialized_value1036 = _t1874 - _t1875 = logic_pb2.RelTerm(specialized_value=specialized_value1036) - _t1873 = _t1875 + _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 + else: + if prediction1038 == 0: + _t1880 = self.parse_specialized_value() + specialized_value1039 = _t1880 + _t1881 = logic_pb2.RelTerm(specialized_value=specialized_value1039) + _t1879 = _t1881 else: raise ParseError("Unexpected token in rel_term" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1870 = _t1873 - result1039 = _t1870 - self.record_span(span_start1038, "RelTerm") - return result1039 - - def parse_specialized_value(self) -> logic_pb2.Value: - span_start1041 = self.span_start() - self.consume_literal("#") - _t1876 = self.parse_raw_value() - raw_value1040 = _t1876 - result1042 = raw_value1040 - self.record_span(span_start1041, "Value") + _t1876 = _t1879 + result1042 = _t1876 + self.record_span(span_start1041, "RelTerm") return result1042 ->>>>>>> origin/main def parse_specialized_value(self) -> logic_pb2.Value: - span_start1007 = self.span_start() - self.consume_literal("#") - _t1808 = self.parse_raw_value() - raw_value1006 = _t1808 - result1008 = raw_value1006 - self.record_span(span_start1007, "Value") - return result1008 - - def parse_rel_atom(self) -> logic_pb2.RelAtom: -<<<<<<< HEAD - span_start1014 = self.span_start() - self.consume_literal("(") - self.consume_literal("relatom") - _t1809 = self.parse_name() - name1009 = _t1809 - xs1010 = [] - cond1011 = ((((((((((((((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 cond1011: - _t1810 = self.parse_rel_term() - item1012 = _t1810 - xs1010.append(item1012) - cond1011 = ((((((((((((((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_terms1013 = xs1010 - self.consume_literal(")") - _t1811 = logic_pb2.RelAtom(name=name1009, terms=rel_terms1013) - result1015 = _t1811 - self.record_span(span_start1014, "RelAtom") - return result1015 + span_start1044 = 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 - def parse_cast(self) -> logic_pb2.Cast: - span_start1018 = self.span_start() - self.consume_literal("(") - self.consume_literal("cast") - _t1812 = self.parse_term() - term1016 = _t1812 - _t1813 = self.parse_term() - term_31017 = _t1813 - self.consume_literal(")") - _t1814 = logic_pb2.Cast(input=term1016, result=term_31017) - result1019 = _t1814 - self.record_span(span_start1018, "Cast") - return result1019 -======= - span_start1048 = self.span_start() + def parse_rel_atom(self) -> logic_pb2.RelAtom: + span_start1051 = self.span_start() self.consume_literal("(") self.consume_literal("relatom") - _t1877 = self.parse_name() - name1043 = _t1877 - xs1044 = [] - cond1045 = ((((((((((((((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 cond1045: - _t1878 = self.parse_rel_term() - item1046 = _t1878 - xs1044.append(item1046) - cond1045 = ((((((((((((((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_terms1047 = xs1044 - self.consume_literal(")") - _t1879 = logic_pb2.RelAtom(name=name1043, terms=rel_terms1047) - result1049 = _t1879 - self.record_span(span_start1048, "RelAtom") - return result1049 + _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 + self.consume_literal(")") + _t1885 = logic_pb2.RelAtom(name=name1046, terms=rel_terms1050) + result1052 = _t1885 + self.record_span(span_start1051, "RelAtom") + return result1052 def parse_cast(self) -> logic_pb2.Cast: - span_start1052 = self.span_start() + span_start1055 = self.span_start() self.consume_literal("(") self.consume_literal("cast") - _t1880 = self.parse_term() - term1050 = _t1880 - _t1881 = self.parse_term() - term_31051 = _t1881 + _t1886 = self.parse_term() + term1053 = _t1886 + _t1887 = self.parse_term() + term_31054 = _t1887 self.consume_literal(")") - _t1882 = logic_pb2.Cast(input=term1050, result=term_31051) - result1053 = _t1882 - self.record_span(span_start1052, "Cast") - return result1053 ->>>>>>> origin/main + _t1888 = logic_pb2.Cast(input=term1053, result=term_31054) + result1056 = _t1888 + self.record_span(span_start1055, "Cast") + return result1056 def parse_attrs(self) -> Sequence[logic_pb2.Attribute]: self.consume_literal("(") self.consume_literal("attrs") -<<<<<<< HEAD - xs1020 = [] - cond1021 = self.match_lookahead_literal("(", 0) - while cond1021: - _t1815 = self.parse_attribute() - item1022 = _t1815 - xs1020.append(item1022) - cond1021 = self.match_lookahead_literal("(", 0) - attributes1023 = xs1020 - self.consume_literal(")") - return attributes1023 - - def parse_attribute(self) -> logic_pb2.Attribute: - span_start1029 = self.span_start() - self.consume_literal("(") - self.consume_literal("attribute") - _t1816 = self.parse_name() - name1024 = _t1816 - xs1025 = [] - cond1026 = ((((((((((((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 cond1026: - _t1817 = self.parse_raw_value() - item1027 = _t1817 - xs1025.append(item1027) - cond1026 = ((((((((((((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_values1028 = xs1025 - self.consume_literal(")") - _t1818 = logic_pb2.Attribute(name=name1024, args=raw_values1028) - result1030 = _t1818 - self.record_span(span_start1029, "Attribute") - return result1030 - - def parse_algorithm(self) -> logic_pb2.Algorithm: - span_start1037 = self.span_start() - self.consume_literal("(") - self.consume_literal("algorithm") - xs1031 = [] - cond1032 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1032: - _t1819 = self.parse_relation_id() - item1033 = _t1819 - xs1031.append(item1033) - cond1032 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1034 = xs1031 - _t1820 = self.parse_script() - script1035 = _t1820 - if self.match_lookahead_literal("(", 0): - _t1822 = self.parse_attrs() - _t1821 = _t1822 - else: - _t1821 = None - attrs1036 = _t1821 - self.consume_literal(")") - _t1823 = logic_pb2.Algorithm(body=script1035, attrs=(attrs1036 if attrs1036 is not None else [])) - getattr(_t1823, 'global').extend(relation_ids1034) - result1038 = _t1823 - self.record_span(span_start1037, "Algorithm") - return result1038 - - def parse_script(self) -> logic_pb2.Script: - span_start1043 = self.span_start() - self.consume_literal("(") - self.consume_literal("script") - xs1039 = [] - cond1040 = self.match_lookahead_literal("(", 0) - while cond1040: - _t1824 = self.parse_construct() - item1041 = _t1824 - xs1039.append(item1041) - cond1040 = self.match_lookahead_literal("(", 0) - constructs1042 = xs1039 - self.consume_literal(")") - _t1825 = logic_pb2.Script(constructs=constructs1042) - result1044 = _t1825 - self.record_span(span_start1043, "Script") - return result1044 - - def parse_construct(self) -> logic_pb2.Construct: - span_start1048 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("upsert", 1): - _t1827 = 1 - else: - if self.match_lookahead_literal("monus", 1): - _t1828 = 1 - else: - if self.match_lookahead_literal("monoid", 1): - _t1829 = 1 - else: - if self.match_lookahead_literal("loop", 1): - _t1830 = 0 - else: - if self.match_lookahead_literal("break", 1): - _t1831 = 1 - else: - if self.match_lookahead_literal("assign", 1): - _t1832 = 1 - else: - _t1832 = -1 - _t1831 = _t1832 - _t1830 = _t1831 - _t1829 = _t1830 - _t1828 = _t1829 - _t1827 = _t1828 - _t1826 = _t1827 - else: - _t1826 = -1 - prediction1045 = _t1826 - if prediction1045 == 1: - _t1834 = self.parse_instruction() - instruction1047 = _t1834 - _t1835 = logic_pb2.Construct(instruction=instruction1047) - _t1833 = _t1835 - else: - if prediction1045 == 0: - _t1837 = self.parse_loop() - loop1046 = _t1837 - _t1838 = logic_pb2.Construct(loop=loop1046) - _t1836 = _t1838 - else: - raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1833 = _t1836 - result1049 = _t1833 - self.record_span(span_start1048, "Construct") - return result1049 - - def parse_loop(self) -> logic_pb2.Loop: - span_start1053 = self.span_start() - self.consume_literal("(") - self.consume_literal("loop") - _t1839 = self.parse_init() - init1050 = _t1839 - _t1840 = self.parse_script() - script1051 = _t1840 - if self.match_lookahead_literal("(", 0): - _t1842 = self.parse_attrs() - _t1841 = _t1842 - else: - _t1841 = None - attrs1052 = _t1841 - self.consume_literal(")") - _t1843 = logic_pb2.Loop(init=init1050, body=script1051, attrs=(attrs1052 if attrs1052 is not None else [])) - result1054 = _t1843 - self.record_span(span_start1053, "Loop") - return result1054 -======= - xs1054 = [] - cond1055 = self.match_lookahead_literal("(", 0) - while cond1055: - _t1883 = self.parse_attribute() - item1056 = _t1883 - xs1054.append(item1056) - cond1055 = self.match_lookahead_literal("(", 0) - attributes1057 = xs1054 + 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 self.consume_literal(")") - return attributes1057 + return attributes1060 def parse_attribute(self) -> logic_pb2.Attribute: - span_start1063 = self.span_start() + span_start1066 = self.span_start() self.consume_literal("(") self.consume_literal("attribute") - _t1884 = self.parse_name() - name1058 = _t1884 - xs1059 = [] - cond1060 = ((((((((((((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 cond1060: - _t1885 = self.parse_raw_value() - item1061 = _t1885 - xs1059.append(item1061) - cond1060 = ((((((((((((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_values1062 = xs1059 - self.consume_literal(")") - _t1886 = logic_pb2.Attribute(name=name1058, args=raw_values1062) - result1064 = _t1886 - self.record_span(span_start1063, "Attribute") - return result1064 + _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 + self.consume_literal(")") + _t1892 = logic_pb2.Attribute(name=name1061, args=raw_values1065) + result1067 = _t1892 + self.record_span(span_start1066, "Attribute") + return result1067 def parse_algorithm(self) -> logic_pb2.Algorithm: - span_start1071 = self.span_start() + span_start1074 = self.span_start() self.consume_literal("(") self.consume_literal("algorithm") - xs1065 = [] - cond1066 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1066: - _t1887 = self.parse_relation_id() - item1067 = _t1887 - xs1065.append(item1067) - cond1066 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1068 = xs1065 - _t1888 = self.parse_script() - script1069 = _t1888 + 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 if self.match_lookahead_literal("(", 0): - _t1890 = self.parse_attrs() - _t1889 = _t1890 + _t1896 = self.parse_attrs() + _t1895 = _t1896 else: - _t1889 = None - attrs1070 = _t1889 + _t1895 = None + attrs1073 = _t1895 self.consume_literal(")") - _t1891 = logic_pb2.Algorithm(body=script1069, attrs=(attrs1070 if attrs1070 is not None else [])) - getattr(_t1891, 'global').extend(relation_ids1068) - result1072 = _t1891 - self.record_span(span_start1071, "Algorithm") - return result1072 + _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 def parse_script(self) -> logic_pb2.Script: - span_start1077 = self.span_start() + span_start1080 = self.span_start() self.consume_literal("(") self.consume_literal("script") - xs1073 = [] - cond1074 = self.match_lookahead_literal("(", 0) - while cond1074: - _t1892 = self.parse_construct() - item1075 = _t1892 - xs1073.append(item1075) - cond1074 = self.match_lookahead_literal("(", 0) - constructs1076 = xs1073 - self.consume_literal(")") - _t1893 = logic_pb2.Script(constructs=constructs1076) - result1078 = _t1893 - self.record_span(span_start1077, "Script") - return result1078 + 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 + self.consume_literal(")") + _t1899 = logic_pb2.Script(constructs=constructs1079) + result1081 = _t1899 + self.record_span(span_start1080, "Script") + return result1081 def parse_construct(self) -> logic_pb2.Construct: - span_start1082 = self.span_start() + span_start1085 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1895 = 1 + _t1901 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1896 = 1 + _t1902 = 1 else: if self.match_lookahead_literal("monoid", 1): - _t1897 = 1 + _t1903 = 1 else: if self.match_lookahead_literal("loop", 1): - _t1898 = 0 + _t1904 = 0 else: if self.match_lookahead_literal("break", 1): - _t1899 = 1 + _t1905 = 1 else: if self.match_lookahead_literal("assign", 1): - _t1900 = 1 + _t1906 = 1 else: - _t1900 = -1 - _t1899 = _t1900 - _t1898 = _t1899 - _t1897 = _t1898 - _t1896 = _t1897 - _t1895 = _t1896 - _t1894 = _t1895 - else: - _t1894 = -1 - prediction1079 = _t1894 - if prediction1079 == 1: - _t1902 = self.parse_instruction() - instruction1081 = _t1902 - _t1903 = logic_pb2.Construct(instruction=instruction1081) - _t1901 = _t1903 - else: - if prediction1079 == 0: - _t1905 = self.parse_loop() - loop1080 = _t1905 - _t1906 = logic_pb2.Construct(loop=loop1080) - _t1904 = _t1906 + _t1906 = -1 + _t1905 = _t1906 + _t1904 = _t1905 + _t1903 = _t1904 + _t1902 = _t1903 + _t1901 = _t1902 + _t1900 = _t1901 + else: + _t1900 = -1 + prediction1082 = _t1900 + if prediction1082 == 1: + _t1908 = self.parse_instruction() + instruction1084 = _t1908 + _t1909 = logic_pb2.Construct(instruction=instruction1084) + _t1907 = _t1909 + else: + if prediction1082 == 0: + _t1911 = self.parse_loop() + loop1083 = _t1911 + _t1912 = logic_pb2.Construct(loop=loop1083) + _t1910 = _t1912 else: raise ParseError("Unexpected token in construct" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1901 = _t1904 - result1083 = _t1901 - self.record_span(span_start1082, "Construct") - return result1083 + _t1907 = _t1910 + result1086 = _t1907 + self.record_span(span_start1085, "Construct") + return result1086 def parse_loop(self) -> logic_pb2.Loop: - span_start1087 = self.span_start() + span_start1090 = self.span_start() self.consume_literal("(") self.consume_literal("loop") - _t1907 = self.parse_init() - init1084 = _t1907 - _t1908 = self.parse_script() - script1085 = _t1908 + _t1913 = self.parse_init() + init1087 = _t1913 + _t1914 = self.parse_script() + script1088 = _t1914 if self.match_lookahead_literal("(", 0): - _t1910 = self.parse_attrs() - _t1909 = _t1910 + _t1916 = self.parse_attrs() + _t1915 = _t1916 else: - _t1909 = None - attrs1086 = _t1909 + _t1915 = None + attrs1089 = _t1915 self.consume_literal(")") - _t1911 = logic_pb2.Loop(init=init1084, body=script1085, attrs=(attrs1086 if attrs1086 is not None else [])) - result1088 = _t1911 - self.record_span(span_start1087, "Loop") - return result1088 ->>>>>>> origin/main + _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 def parse_init(self) -> Sequence[logic_pb2.Instruction]: self.consume_literal("(") self.consume_literal("init") -<<<<<<< HEAD - xs1055 = [] - cond1056 = self.match_lookahead_literal("(", 0) - while cond1056: - _t1844 = self.parse_instruction() - item1057 = _t1844 - xs1055.append(item1057) - cond1056 = self.match_lookahead_literal("(", 0) - instructions1058 = xs1055 - self.consume_literal(")") - return instructions1058 - - def parse_instruction(self) -> logic_pb2.Instruction: - span_start1065 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("upsert", 1): - _t1846 = 1 - else: - if self.match_lookahead_literal("monus", 1): - _t1847 = 4 - else: - if self.match_lookahead_literal("monoid", 1): - _t1848 = 3 - else: - if self.match_lookahead_literal("break", 1): - _t1849 = 2 - else: - if self.match_lookahead_literal("assign", 1): - _t1850 = 0 - else: - _t1850 = -1 - _t1849 = _t1850 - _t1848 = _t1849 - _t1847 = _t1848 - _t1846 = _t1847 - _t1845 = _t1846 - else: - _t1845 = -1 - prediction1059 = _t1845 - if prediction1059 == 4: - _t1852 = self.parse_monus_def() - monus_def1064 = _t1852 - _t1853 = logic_pb2.Instruction(monus_def=monus_def1064) - _t1851 = _t1853 - else: - if prediction1059 == 3: - _t1855 = self.parse_monoid_def() - monoid_def1063 = _t1855 - _t1856 = logic_pb2.Instruction(monoid_def=monoid_def1063) - _t1854 = _t1856 - else: - if prediction1059 == 2: - _t1858 = self.parse_break() - break1062 = _t1858 - _t1859 = logic_pb2.Instruction() - getattr(_t1859, 'break').CopyFrom(break1062) - _t1857 = _t1859 - else: - if prediction1059 == 1: - _t1861 = self.parse_upsert() - upsert1061 = _t1861 - _t1862 = logic_pb2.Instruction(upsert=upsert1061) - _t1860 = _t1862 - else: - if prediction1059 == 0: - _t1864 = self.parse_assign() - assign1060 = _t1864 - _t1865 = logic_pb2.Instruction(assign=assign1060) - _t1863 = _t1865 - else: - raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1860 = _t1863 - _t1857 = _t1860 - _t1854 = _t1857 - _t1851 = _t1854 - result1066 = _t1851 - self.record_span(span_start1065, "Instruction") - return result1066 - - def parse_assign(self) -> logic_pb2.Assign: - span_start1070 = self.span_start() - self.consume_literal("(") - self.consume_literal("assign") - _t1866 = self.parse_relation_id() - relation_id1067 = _t1866 - _t1867 = self.parse_abstraction() - abstraction1068 = _t1867 - if self.match_lookahead_literal("(", 0): - _t1869 = self.parse_attrs() - _t1868 = _t1869 - else: - _t1868 = None - attrs1069 = _t1868 - self.consume_literal(")") - _t1870 = logic_pb2.Assign(name=relation_id1067, body=abstraction1068, attrs=(attrs1069 if attrs1069 is not None else [])) - result1071 = _t1870 - self.record_span(span_start1070, "Assign") - return result1071 - - def parse_upsert(self) -> logic_pb2.Upsert: - span_start1075 = self.span_start() - self.consume_literal("(") - self.consume_literal("upsert") - _t1871 = self.parse_relation_id() - relation_id1072 = _t1871 - _t1872 = self.parse_abstraction_with_arity() - abstraction_with_arity1073 = _t1872 - if self.match_lookahead_literal("(", 0): - _t1874 = self.parse_attrs() - _t1873 = _t1874 - else: - _t1873 = None - attrs1074 = _t1873 - self.consume_literal(")") - _t1875 = logic_pb2.Upsert(name=relation_id1072, body=abstraction_with_arity1073[0], attrs=(attrs1074 if attrs1074 is not None else []), value_arity=abstraction_with_arity1073[1]) - result1076 = _t1875 - self.record_span(span_start1075, "Upsert") - return result1076 - - def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: - self.consume_literal("(") - _t1876 = self.parse_bindings() - bindings1077 = _t1876 - _t1877 = self.parse_formula() - formula1078 = _t1877 - self.consume_literal(")") - _t1878 = logic_pb2.Abstraction(vars=(list(bindings1077[0]) + list(bindings1077[1] if bindings1077[1] is not None else [])), value=formula1078) - return (_t1878, len(bindings1077[1]),) - - def parse_break(self) -> logic_pb2.Break: - span_start1082 = self.span_start() - self.consume_literal("(") - self.consume_literal("break") - _t1879 = self.parse_relation_id() - relation_id1079 = _t1879 - _t1880 = self.parse_abstraction() - abstraction1080 = _t1880 -======= - xs1089 = [] - cond1090 = self.match_lookahead_literal("(", 0) - while cond1090: - _t1912 = self.parse_instruction() - item1091 = _t1912 - xs1089.append(item1091) - cond1090 = self.match_lookahead_literal("(", 0) - instructions1092 = xs1089 + 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 self.consume_literal(")") - return instructions1092 + return instructions1095 def parse_instruction(self) -> logic_pb2.Instruction: - span_start1099 = self.span_start() + span_start1102 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("upsert", 1): - _t1914 = 1 + _t1920 = 1 else: if self.match_lookahead_literal("monus", 1): - _t1915 = 4 + _t1921 = 4 else: if self.match_lookahead_literal("monoid", 1): - _t1916 = 3 + _t1922 = 3 else: if self.match_lookahead_literal("break", 1): - _t1917 = 2 + _t1923 = 2 else: if self.match_lookahead_literal("assign", 1): - _t1918 = 0 + _t1924 = 0 else: - _t1918 = -1 - _t1917 = _t1918 - _t1916 = _t1917 - _t1915 = _t1916 - _t1914 = _t1915 - _t1913 = _t1914 - else: - _t1913 = -1 - prediction1093 = _t1913 - if prediction1093 == 4: - _t1920 = self.parse_monus_def() - monus_def1098 = _t1920 - _t1921 = logic_pb2.Instruction(monus_def=monus_def1098) - _t1919 = _t1921 - else: - if prediction1093 == 3: - _t1923 = self.parse_monoid_def() - monoid_def1097 = _t1923 - _t1924 = logic_pb2.Instruction(monoid_def=monoid_def1097) - _t1922 = _t1924 + _t1924 = -1 + _t1923 = _t1924 + _t1922 = _t1923 + _t1921 = _t1922 + _t1920 = _t1921 + _t1919 = _t1920 + 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 + else: + if prediction1096 == 3: + _t1929 = self.parse_monoid_def() + monoid_def1100 = _t1929 + _t1930 = logic_pb2.Instruction(monoid_def=monoid_def1100) + _t1928 = _t1930 else: - if prediction1093 == 2: - _t1926 = self.parse_break() - break1096 = _t1926 - _t1927 = logic_pb2.Instruction() - getattr(_t1927, 'break').CopyFrom(break1096) - _t1925 = _t1927 + if prediction1096 == 2: + _t1932 = self.parse_break() + break1099 = _t1932 + _t1933 = logic_pb2.Instruction() + getattr(_t1933, 'break').CopyFrom(break1099) + _t1931 = _t1933 else: - if prediction1093 == 1: - _t1929 = self.parse_upsert() - upsert1095 = _t1929 - _t1930 = logic_pb2.Instruction(upsert=upsert1095) - _t1928 = _t1930 + if prediction1096 == 1: + _t1935 = self.parse_upsert() + upsert1098 = _t1935 + _t1936 = logic_pb2.Instruction(upsert=upsert1098) + _t1934 = _t1936 else: - if prediction1093 == 0: - _t1932 = self.parse_assign() - assign1094 = _t1932 - _t1933 = logic_pb2.Instruction(assign=assign1094) - _t1931 = _t1933 + if prediction1096 == 0: + _t1938 = self.parse_assign() + assign1097 = _t1938 + _t1939 = logic_pb2.Instruction(assign=assign1097) + _t1937 = _t1939 else: raise ParseError("Unexpected token in instruction" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1928 = _t1931 - _t1925 = _t1928 - _t1922 = _t1925 - _t1919 = _t1922 - result1100 = _t1919 - self.record_span(span_start1099, "Instruction") - return result1100 + _t1934 = _t1937 + _t1931 = _t1934 + _t1928 = _t1931 + _t1925 = _t1928 + result1103 = _t1925 + self.record_span(span_start1102, "Instruction") + return result1103 def parse_assign(self) -> logic_pb2.Assign: - span_start1104 = self.span_start() + span_start1107 = self.span_start() self.consume_literal("(") self.consume_literal("assign") - _t1934 = self.parse_relation_id() - relation_id1101 = _t1934 - _t1935 = self.parse_abstraction() - abstraction1102 = _t1935 + _t1940 = self.parse_relation_id() + relation_id1104 = _t1940 + _t1941 = self.parse_abstraction() + abstraction1105 = _t1941 if self.match_lookahead_literal("(", 0): - _t1937 = self.parse_attrs() - _t1936 = _t1937 + _t1943 = self.parse_attrs() + _t1942 = _t1943 else: - _t1936 = None - attrs1103 = _t1936 + _t1942 = None + attrs1106 = _t1942 self.consume_literal(")") - _t1938 = logic_pb2.Assign(name=relation_id1101, body=abstraction1102, attrs=(attrs1103 if attrs1103 is not None else [])) - result1105 = _t1938 - self.record_span(span_start1104, "Assign") - return result1105 + _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 def parse_upsert(self) -> logic_pb2.Upsert: - span_start1109 = self.span_start() + span_start1112 = self.span_start() self.consume_literal("(") self.consume_literal("upsert") - _t1939 = self.parse_relation_id() - relation_id1106 = _t1939 - _t1940 = self.parse_abstraction_with_arity() - abstraction_with_arity1107 = _t1940 + _t1945 = self.parse_relation_id() + relation_id1109 = _t1945 + _t1946 = self.parse_abstraction_with_arity() + abstraction_with_arity1110 = _t1946 if self.match_lookahead_literal("(", 0): - _t1942 = self.parse_attrs() - _t1941 = _t1942 + _t1948 = self.parse_attrs() + _t1947 = _t1948 else: - _t1941 = None - attrs1108 = _t1941 + _t1947 = None + attrs1111 = _t1947 self.consume_literal(")") - _t1943 = logic_pb2.Upsert(name=relation_id1106, body=abstraction_with_arity1107[0], attrs=(attrs1108 if attrs1108 is not None else []), value_arity=abstraction_with_arity1107[1]) - result1110 = _t1943 - self.record_span(span_start1109, "Upsert") - return result1110 + _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 def parse_abstraction_with_arity(self) -> tuple[logic_pb2.Abstraction, int]: self.consume_literal("(") - _t1944 = self.parse_bindings() - bindings1111 = _t1944 - _t1945 = self.parse_formula() - formula1112 = _t1945 + _t1950 = self.parse_bindings() + bindings1114 = _t1950 + _t1951 = self.parse_formula() + formula1115 = _t1951 self.consume_literal(")") - _t1946 = logic_pb2.Abstraction(vars=(list(bindings1111[0]) + list(bindings1111[1] if bindings1111[1] is not None else [])), value=formula1112) - return (_t1946, len(bindings1111[1]),) + _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]),) def parse_break(self) -> logic_pb2.Break: - span_start1116 = self.span_start() + span_start1119 = self.span_start() self.consume_literal("(") self.consume_literal("break") - _t1947 = self.parse_relation_id() - relation_id1113 = _t1947 - _t1948 = self.parse_abstraction() - abstraction1114 = _t1948 - if self.match_lookahead_literal("(", 0): - _t1950 = self.parse_attrs() - _t1949 = _t1950 - else: - _t1949 = None - attrs1115 = _t1949 - self.consume_literal(")") - _t1951 = logic_pb2.Break(name=relation_id1113, body=abstraction1114, attrs=(attrs1115 if attrs1115 is not None else [])) - result1117 = _t1951 - self.record_span(span_start1116, "Break") - return result1117 - - def parse_monoid_def(self) -> logic_pb2.MonoidDef: - span_start1122 = self.span_start() - self.consume_literal("(") - self.consume_literal("monoid") - _t1952 = self.parse_monoid() - monoid1118 = _t1952 _t1953 = self.parse_relation_id() - relation_id1119 = _t1953 - _t1954 = self.parse_abstraction_with_arity() - abstraction_with_arity1120 = _t1954 ->>>>>>> origin/main + relation_id1116 = _t1953 + _t1954 = self.parse_abstraction() + abstraction1117 = _t1954 if self.match_lookahead_literal("(", 0): _t1956 = self.parse_attrs() _t1955 = _t1956 else: -<<<<<<< HEAD - _t1881 = None - attrs1081 = _t1881 + _t1955 = None + attrs1118 = _t1955 self.consume_literal(")") - _t1883 = logic_pb2.Break(name=relation_id1079, body=abstraction1080, attrs=(attrs1081 if attrs1081 is not None else [])) - result1083 = _t1883 - self.record_span(span_start1082, "Break") - return result1083 + _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 def parse_monoid_def(self) -> logic_pb2.MonoidDef: - span_start1088 = self.span_start() + span_start1125 = self.span_start() self.consume_literal("(") self.consume_literal("monoid") - _t1884 = self.parse_monoid() - monoid1084 = _t1884 - _t1885 = self.parse_relation_id() - relation_id1085 = _t1885 - _t1886 = self.parse_abstraction_with_arity() - abstraction_with_arity1086 = _t1886 + _t1958 = self.parse_monoid() + monoid1121 = _t1958 + _t1959 = self.parse_relation_id() + relation_id1122 = _t1959 + _t1960 = self.parse_abstraction_with_arity() + abstraction_with_arity1123 = _t1960 if self.match_lookahead_literal("(", 0): - _t1888 = self.parse_attrs() - _t1887 = _t1888 + _t1962 = self.parse_attrs() + _t1961 = _t1962 else: - _t1887 = None - attrs1087 = _t1887 - self.consume_literal(")") - _t1889 = logic_pb2.MonoidDef(monoid=monoid1084, name=relation_id1085, body=abstraction_with_arity1086[0], attrs=(attrs1087 if attrs1087 is not None else []), value_arity=abstraction_with_arity1086[1]) - result1089 = _t1889 - self.record_span(span_start1088, "MonoidDef") - return result1089 - - def parse_monoid(self) -> logic_pb2.Monoid: - span_start1095 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("sum", 1): - _t1891 = 3 - else: - if self.match_lookahead_literal("or", 1): - _t1892 = 0 - else: - if self.match_lookahead_literal("min", 1): - _t1893 = 1 - else: - if self.match_lookahead_literal("max", 1): - _t1894 = 2 - else: - _t1894 = -1 - _t1893 = _t1894 - _t1892 = _t1893 - _t1891 = _t1892 - _t1890 = _t1891 - else: - _t1890 = -1 - prediction1090 = _t1890 - if prediction1090 == 3: - _t1896 = self.parse_sum_monoid() - sum_monoid1094 = _t1896 - _t1897 = logic_pb2.Monoid(sum_monoid=sum_monoid1094) - _t1895 = _t1897 - else: - if prediction1090 == 2: - _t1899 = self.parse_max_monoid() - max_monoid1093 = _t1899 - _t1900 = logic_pb2.Monoid(max_monoid=max_monoid1093) - _t1898 = _t1900 - else: - if prediction1090 == 1: - _t1902 = self.parse_min_monoid() - min_monoid1092 = _t1902 - _t1903 = logic_pb2.Monoid(min_monoid=min_monoid1092) - _t1901 = _t1903 - else: - if prediction1090 == 0: - _t1905 = self.parse_or_monoid() - or_monoid1091 = _t1905 - _t1906 = logic_pb2.Monoid(or_monoid=or_monoid1091) - _t1904 = _t1906 - else: - raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1901 = _t1904 - _t1898 = _t1901 - _t1895 = _t1898 - result1096 = _t1895 - self.record_span(span_start1095, "Monoid") - return result1096 - - def parse_or_monoid(self) -> logic_pb2.OrMonoid: - span_start1097 = self.span_start() - self.consume_literal("(") - self.consume_literal("or") - self.consume_literal(")") - _t1907 = logic_pb2.OrMonoid() - result1098 = _t1907 - self.record_span(span_start1097, "OrMonoid") - return result1098 - - def parse_min_monoid(self) -> logic_pb2.MinMonoid: - span_start1100 = self.span_start() - self.consume_literal("(") - self.consume_literal("min") - _t1908 = self.parse_type() - type1099 = _t1908 - self.consume_literal(")") - _t1909 = logic_pb2.MinMonoid(type=type1099) - result1101 = _t1909 - self.record_span(span_start1100, "MinMonoid") - return result1101 - - def parse_max_monoid(self) -> logic_pb2.MaxMonoid: - span_start1103 = self.span_start() - self.consume_literal("(") - self.consume_literal("max") - _t1910 = self.parse_type() - type1102 = _t1910 + _t1961 = None + attrs1124 = _t1961 self.consume_literal(")") - _t1911 = logic_pb2.MaxMonoid(type=type1102) - result1104 = _t1911 - self.record_span(span_start1103, "MaxMonoid") - return result1104 -======= - _t1955 = None - attrs1121 = _t1955 - self.consume_literal(")") - _t1957 = logic_pb2.MonoidDef(monoid=monoid1118, name=relation_id1119, body=abstraction_with_arity1120[0], attrs=(attrs1121 if attrs1121 is not None else []), value_arity=abstraction_with_arity1120[1]) - result1123 = _t1957 - self.record_span(span_start1122, "MonoidDef") - return result1123 + _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 def parse_monoid(self) -> logic_pb2.Monoid: - span_start1129 = self.span_start() + span_start1132 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("sum", 1): - _t1959 = 3 + _t1965 = 3 else: if self.match_lookahead_literal("or", 1): - _t1960 = 0 + _t1966 = 0 else: if self.match_lookahead_literal("min", 1): - _t1961 = 1 + _t1967 = 1 else: if self.match_lookahead_literal("max", 1): - _t1962 = 2 + _t1968 = 2 else: - _t1962 = -1 - _t1961 = _t1962 - _t1960 = _t1961 - _t1959 = _t1960 - _t1958 = _t1959 - else: - _t1958 = -1 - prediction1124 = _t1958 - if prediction1124 == 3: - _t1964 = self.parse_sum_monoid() - sum_monoid1128 = _t1964 - _t1965 = logic_pb2.Monoid(sum_monoid=sum_monoid1128) - _t1963 = _t1965 + _t1968 = -1 + _t1967 = _t1968 + _t1966 = _t1967 + _t1965 = _t1966 + _t1964 = _t1965 else: - if prediction1124 == 2: - _t1967 = self.parse_max_monoid() - max_monoid1127 = _t1967 - _t1968 = logic_pb2.Monoid(max_monoid=max_monoid1127) - _t1966 = _t1968 + _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 + else: + if prediction1127 == 2: + _t1973 = self.parse_max_monoid() + max_monoid1130 = _t1973 + _t1974 = logic_pb2.Monoid(max_monoid=max_monoid1130) + _t1972 = _t1974 else: - if prediction1124 == 1: - _t1970 = self.parse_min_monoid() - min_monoid1126 = _t1970 - _t1971 = logic_pb2.Monoid(min_monoid=min_monoid1126) - _t1969 = _t1971 + if prediction1127 == 1: + _t1976 = self.parse_min_monoid() + min_monoid1129 = _t1976 + _t1977 = logic_pb2.Monoid(min_monoid=min_monoid1129) + _t1975 = _t1977 else: - if prediction1124 == 0: - _t1973 = self.parse_or_monoid() - or_monoid1125 = _t1973 - _t1974 = logic_pb2.Monoid(or_monoid=or_monoid1125) - _t1972 = _t1974 + if prediction1127 == 0: + _t1979 = self.parse_or_monoid() + or_monoid1128 = _t1979 + _t1980 = logic_pb2.Monoid(or_monoid=or_monoid1128) + _t1978 = _t1980 else: raise ParseError("Unexpected token in monoid" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1969 = _t1972 - _t1966 = _t1969 - _t1963 = _t1966 - result1130 = _t1963 - self.record_span(span_start1129, "Monoid") - return result1130 + _t1975 = _t1978 + _t1972 = _t1975 + _t1969 = _t1972 + result1133 = _t1969 + self.record_span(span_start1132, "Monoid") + return result1133 def parse_or_monoid(self) -> logic_pb2.OrMonoid: - span_start1131 = self.span_start() - self.consume_literal("(") - self.consume_literal("or") - self.consume_literal(")") - _t1975 = logic_pb2.OrMonoid() - result1132 = _t1975 - self.record_span(span_start1131, "OrMonoid") - return result1132 - - def parse_min_monoid(self) -> logic_pb2.MinMonoid: span_start1134 = self.span_start() self.consume_literal("(") - self.consume_literal("min") - _t1976 = self.parse_type() - type1133 = _t1976 + self.consume_literal("or") self.consume_literal(")") - _t1977 = logic_pb2.MinMonoid(type=type1133) - result1135 = _t1977 - self.record_span(span_start1134, "MinMonoid") + _t1981 = logic_pb2.OrMonoid() + result1135 = _t1981 + self.record_span(span_start1134, "OrMonoid") return result1135 - def parse_max_monoid(self) -> logic_pb2.MaxMonoid: + def parse_min_monoid(self) -> logic_pb2.MinMonoid: span_start1137 = self.span_start() self.consume_literal("(") - self.consume_literal("max") - _t1978 = self.parse_type() - type1136 = _t1978 + self.consume_literal("min") + _t1982 = self.parse_type() + type1136 = _t1982 self.consume_literal(")") - _t1979 = logic_pb2.MaxMonoid(type=type1136) - result1138 = _t1979 - self.record_span(span_start1137, "MaxMonoid") + _t1983 = logic_pb2.MinMonoid(type=type1136) + result1138 = _t1983 + self.record_span(span_start1137, "MinMonoid") return result1138 - def parse_sum_monoid(self) -> logic_pb2.SumMonoid: + def parse_max_monoid(self) -> logic_pb2.MaxMonoid: span_start1140 = self.span_start() self.consume_literal("(") - self.consume_literal("sum") - _t1980 = self.parse_type() - type1139 = _t1980 + self.consume_literal("max") + _t1984 = self.parse_type() + type1139 = _t1984 self.consume_literal(")") - _t1981 = logic_pb2.SumMonoid(type=type1139) - result1141 = _t1981 - self.record_span(span_start1140, "SumMonoid") + _t1985 = logic_pb2.MaxMonoid(type=type1139) + result1141 = _t1985 + self.record_span(span_start1140, "MaxMonoid") return result1141 ->>>>>>> origin/main def parse_sum_monoid(self) -> logic_pb2.SumMonoid: - span_start1106 = self.span_start() + span_start1143 = self.span_start() self.consume_literal("(") self.consume_literal("sum") - _t1912 = self.parse_type() - type1105 = _t1912 + _t1986 = self.parse_type() + type1142 = _t1986 self.consume_literal(")") - _t1913 = logic_pb2.SumMonoid(type=type1105) - result1107 = _t1913 - self.record_span(span_start1106, "SumMonoid") - return result1107 + _t1987 = logic_pb2.SumMonoid(type=type1142) + result1144 = _t1987 + self.record_span(span_start1143, "SumMonoid") + return result1144 def parse_monus_def(self) -> logic_pb2.MonusDef: -<<<<<<< HEAD - span_start1112 = self.span_start() - self.consume_literal("(") - self.consume_literal("monus") - _t1914 = self.parse_monoid() - monoid1108 = _t1914 - _t1915 = self.parse_relation_id() - relation_id1109 = _t1915 - _t1916 = self.parse_abstraction_with_arity() - abstraction_with_arity1110 = _t1916 - if self.match_lookahead_literal("(", 0): - _t1918 = self.parse_attrs() - _t1917 = _t1918 - else: - _t1917 = None - attrs1111 = _t1917 - self.consume_literal(")") - _t1919 = logic_pb2.MonusDef(monoid=monoid1108, name=relation_id1109, body=abstraction_with_arity1110[0], attrs=(attrs1111 if attrs1111 is not None else []), value_arity=abstraction_with_arity1110[1]) - result1113 = _t1919 - self.record_span(span_start1112, "MonusDef") - return result1113 - - def parse_constraint(self) -> logic_pb2.Constraint: - span_start1118 = self.span_start() - self.consume_literal("(") - self.consume_literal("functional_dependency") - _t1920 = self.parse_relation_id() - relation_id1114 = _t1920 - _t1921 = self.parse_abstraction() - abstraction1115 = _t1921 - _t1922 = self.parse_functional_dependency_keys() - functional_dependency_keys1116 = _t1922 - _t1923 = self.parse_functional_dependency_values() - functional_dependency_values1117 = _t1923 - self.consume_literal(")") - _t1924 = logic_pb2.FunctionalDependency(guard=abstraction1115, keys=functional_dependency_keys1116, values=functional_dependency_values1117) - _t1925 = logic_pb2.Constraint(name=relation_id1114, functional_dependency=_t1924) - result1119 = _t1925 - self.record_span(span_start1118, "Constraint") - return result1119 -======= - span_start1146 = self.span_start() + span_start1149 = self.span_start() self.consume_literal("(") self.consume_literal("monus") - _t1982 = self.parse_monoid() - monoid1142 = _t1982 - _t1983 = self.parse_relation_id() - relation_id1143 = _t1983 - _t1984 = self.parse_abstraction_with_arity() - abstraction_with_arity1144 = _t1984 + _t1988 = self.parse_monoid() + monoid1145 = _t1988 + _t1989 = self.parse_relation_id() + relation_id1146 = _t1989 + _t1990 = self.parse_abstraction_with_arity() + abstraction_with_arity1147 = _t1990 if self.match_lookahead_literal("(", 0): - _t1986 = self.parse_attrs() - _t1985 = _t1986 + _t1992 = self.parse_attrs() + _t1991 = _t1992 else: - _t1985 = None - attrs1145 = _t1985 + _t1991 = None + attrs1148 = _t1991 self.consume_literal(")") - _t1987 = logic_pb2.MonusDef(monoid=monoid1142, name=relation_id1143, body=abstraction_with_arity1144[0], attrs=(attrs1145 if attrs1145 is not None else []), value_arity=abstraction_with_arity1144[1]) - result1147 = _t1987 - self.record_span(span_start1146, "MonusDef") - return result1147 + _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 def parse_constraint(self) -> logic_pb2.Constraint: - span_start1152 = self.span_start() + span_start1155 = self.span_start() self.consume_literal("(") self.consume_literal("functional_dependency") - _t1988 = self.parse_relation_id() - relation_id1148 = _t1988 - _t1989 = self.parse_abstraction() - abstraction1149 = _t1989 - _t1990 = self.parse_functional_dependency_keys() - functional_dependency_keys1150 = _t1990 - _t1991 = self.parse_functional_dependency_values() - functional_dependency_values1151 = _t1991 - self.consume_literal(")") - _t1992 = logic_pb2.FunctionalDependency(guard=abstraction1149, keys=functional_dependency_keys1150, values=functional_dependency_values1151) - _t1993 = logic_pb2.Constraint(name=relation_id1148, functional_dependency=_t1992) - result1153 = _t1993 - self.record_span(span_start1152, "Constraint") - return result1153 ->>>>>>> origin/main + _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 + 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 def parse_functional_dependency_keys(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("keys") -<<<<<<< HEAD - xs1120 = [] - cond1121 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1121: - _t1926 = self.parse_var() - item1122 = _t1926 - xs1120.append(item1122) - cond1121 = self.match_lookahead_terminal("SYMBOL", 0) - vars1123 = xs1120 - self.consume_literal(")") - return vars1123 -======= - xs1154 = [] - cond1155 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1155: - _t1994 = self.parse_var() - item1156 = _t1994 - xs1154.append(item1156) - cond1155 = self.match_lookahead_terminal("SYMBOL", 0) - vars1157 = xs1154 + 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 self.consume_literal(")") - return vars1157 ->>>>>>> origin/main + return vars1160 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") -<<<<<<< HEAD - xs1124 = [] - cond1125 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1125: - _t1927 = self.parse_var() - item1126 = _t1927 - xs1124.append(item1126) - cond1125 = self.match_lookahead_terminal("SYMBOL", 0) - vars1127 = xs1124 - self.consume_literal(")") - return vars1127 - - def parse_data(self) -> logic_pb2.Data: - span_start1133 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("iceberg_data", 1): - _t1929 = 3 - else: - if self.match_lookahead_literal("edb", 1): - _t1930 = 0 - else: - if self.match_lookahead_literal("csv_data", 1): - _t1931 = 2 - else: - if self.match_lookahead_literal("betree_relation", 1): - _t1932 = 1 - else: - _t1932 = -1 - _t1931 = _t1932 - _t1930 = _t1931 - _t1929 = _t1930 - _t1928 = _t1929 - else: - _t1928 = -1 - prediction1128 = _t1928 - if prediction1128 == 3: - _t1934 = self.parse_iceberg_data() - iceberg_data1132 = _t1934 - _t1935 = logic_pb2.Data(iceberg_data=iceberg_data1132) - _t1933 = _t1935 - else: - if prediction1128 == 2: - _t1937 = self.parse_csv_data() - csv_data1131 = _t1937 - _t1938 = logic_pb2.Data(csv_data=csv_data1131) - _t1936 = _t1938 - else: - if prediction1128 == 1: - _t1940 = self.parse_betree_relation() - betree_relation1130 = _t1940 - _t1941 = logic_pb2.Data(betree_relation=betree_relation1130) - _t1939 = _t1941 - else: - if prediction1128 == 0: - _t1943 = self.parse_edb() - edb1129 = _t1943 - _t1944 = logic_pb2.Data(edb=edb1129) - _t1942 = _t1944 - else: - raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1939 = _t1942 - _t1936 = _t1939 - _t1933 = _t1936 - result1134 = _t1933 - self.record_span(span_start1133, "Data") - return result1134 - - def parse_edb(self) -> logic_pb2.EDB: - span_start1138 = self.span_start() - self.consume_literal("(") - self.consume_literal("edb") - _t1945 = self.parse_relation_id() - relation_id1135 = _t1945 - _t1946 = self.parse_edb_path() - edb_path1136 = _t1946 - _t1947 = self.parse_edb_types() - edb_types1137 = _t1947 - self.consume_literal(")") - _t1948 = logic_pb2.EDB(target_id=relation_id1135, path=edb_path1136, types=edb_types1137) - result1139 = _t1948 - self.record_span(span_start1138, "EDB") - return result1139 - - def parse_edb_path(self) -> Sequence[str]: - self.consume_literal("[") - xs1140 = [] - cond1141 = self.match_lookahead_terminal("STRING", 0) - while cond1141: - item1142 = self.consume_terminal("STRING") - xs1140.append(item1142) - cond1141 = self.match_lookahead_terminal("STRING", 0) - strings1143 = xs1140 - self.consume_literal("]") - return strings1143 - - def parse_edb_types(self) -> Sequence[logic_pb2.Type]: - self.consume_literal("[") - xs1144 = [] - cond1145 = (((((((((((((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 cond1145: - _t1949 = self.parse_type() - item1146 = _t1949 - xs1144.append(item1146) - cond1145 = (((((((((((((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)) - types1147 = xs1144 - self.consume_literal("]") - return types1147 - - def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: - span_start1150 = self.span_start() - self.consume_literal("(") - self.consume_literal("betree_relation") - _t1950 = self.parse_relation_id() - relation_id1148 = _t1950 - _t1951 = self.parse_betree_info() - betree_info1149 = _t1951 - self.consume_literal(")") - _t1952 = logic_pb2.BeTreeRelation(name=relation_id1148, relation_info=betree_info1149) - result1151 = _t1952 - self.record_span(span_start1150, "BeTreeRelation") - return result1151 - - def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1155 = self.span_start() - self.consume_literal("(") - self.consume_literal("betree_info") - _t1953 = self.parse_betree_info_key_types() - betree_info_key_types1152 = _t1953 - _t1954 = self.parse_betree_info_value_types() - betree_info_value_types1153 = _t1954 - _t1955 = self.parse_config_dict() - config_dict1154 = _t1955 - self.consume_literal(")") - _t1956 = self.construct_betree_info(betree_info_key_types1152, betree_info_value_types1153, config_dict1154) - result1156 = _t1956 - self.record_span(span_start1155, "BeTreeInfo") - return result1156 -======= - xs1158 = [] - cond1159 = self.match_lookahead_terminal("SYMBOL", 0) - while cond1159: - _t1995 = self.parse_var() - item1160 = _t1995 - xs1158.append(item1160) - cond1159 = self.match_lookahead_terminal("SYMBOL", 0) - vars1161 = xs1158 + 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 self.consume_literal(")") - return vars1161 + return vars1164 def parse_data(self) -> logic_pb2.Data: - span_start1167 = self.span_start() + span_start1170 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1997 = 3 + _t2003 = 3 else: if self.match_lookahead_literal("edb", 1): - _t1998 = 0 + _t2004 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1999 = 2 + _t2005 = 2 else: if self.match_lookahead_literal("betree_relation", 1): - _t2000 = 1 + _t2006 = 1 else: - _t2000 = -1 - _t1999 = _t2000 - _t1998 = _t1999 - _t1997 = _t1998 - _t1996 = _t1997 - else: - _t1996 = -1 - prediction1162 = _t1996 - if prediction1162 == 3: - _t2002 = self.parse_iceberg_data() - iceberg_data1166 = _t2002 - _t2003 = logic_pb2.Data(iceberg_data=iceberg_data1166) - _t2001 = _t2003 - else: - if prediction1162 == 2: - _t2005 = self.parse_csv_data() - csv_data1165 = _t2005 - _t2006 = logic_pb2.Data(csv_data=csv_data1165) - _t2004 = _t2006 + _t2006 = -1 + _t2005 = _t2006 + _t2004 = _t2005 + _t2003 = _t2004 + _t2002 = _t2003 + 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 + else: + if prediction1165 == 2: + _t2011 = self.parse_csv_data() + csv_data1168 = _t2011 + _t2012 = logic_pb2.Data(csv_data=csv_data1168) + _t2010 = _t2012 else: - if prediction1162 == 1: - _t2008 = self.parse_betree_relation() - betree_relation1164 = _t2008 - _t2009 = logic_pb2.Data(betree_relation=betree_relation1164) - _t2007 = _t2009 + if prediction1165 == 1: + _t2014 = self.parse_betree_relation() + betree_relation1167 = _t2014 + _t2015 = logic_pb2.Data(betree_relation=betree_relation1167) + _t2013 = _t2015 else: - if prediction1162 == 0: - _t2011 = self.parse_edb() - edb1163 = _t2011 - _t2012 = logic_pb2.Data(edb=edb1163) - _t2010 = _t2012 + if prediction1165 == 0: + _t2017 = self.parse_edb() + edb1166 = _t2017 + _t2018 = logic_pb2.Data(edb=edb1166) + _t2016 = _t2018 else: raise ParseError("Unexpected token in data" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2007 = _t2010 - _t2004 = _t2007 - _t2001 = _t2004 - result1168 = _t2001 - self.record_span(span_start1167, "Data") - return result1168 + _t2013 = _t2016 + _t2010 = _t2013 + _t2007 = _t2010 + result1171 = _t2007 + self.record_span(span_start1170, "Data") + return result1171 def parse_edb(self) -> logic_pb2.EDB: - span_start1172 = self.span_start() + span_start1175 = self.span_start() self.consume_literal("(") self.consume_literal("edb") - _t2013 = self.parse_relation_id() - relation_id1169 = _t2013 - _t2014 = self.parse_edb_path() - edb_path1170 = _t2014 - _t2015 = self.parse_edb_types() - edb_types1171 = _t2015 - self.consume_literal(")") - _t2016 = logic_pb2.EDB(target_id=relation_id1169, path=edb_path1170, types=edb_types1171) - result1173 = _t2016 - self.record_span(span_start1172, "EDB") - return result1173 + _t2019 = self.parse_relation_id() + relation_id1172 = _t2019 + _t2020 = self.parse_edb_path() + edb_path1173 = _t2020 + _t2021 = self.parse_edb_types() + edb_types1174 = _t2021 + 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 def parse_edb_path(self) -> Sequence[str]: self.consume_literal("[") - xs1174 = [] - cond1175 = self.match_lookahead_terminal("STRING", 0) - while cond1175: - item1176 = self.consume_terminal("STRING") - xs1174.append(item1176) - cond1175 = self.match_lookahead_terminal("STRING", 0) - strings1177 = xs1174 + 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 self.consume_literal("]") - return strings1177 + return strings1180 def parse_edb_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("[") - xs1178 = [] - cond1179 = (((((((((((((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 cond1179: - _t2017 = self.parse_type() - item1180 = _t2017 - xs1178.append(item1180) - cond1179 = (((((((((((((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)) - types1181 = xs1178 + 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 self.consume_literal("]") - return types1181 + return types1184 def parse_betree_relation(self) -> logic_pb2.BeTreeRelation: - span_start1184 = self.span_start() - self.consume_literal("(") - self.consume_literal("betree_relation") - _t2018 = self.parse_relation_id() - relation_id1182 = _t2018 - _t2019 = self.parse_betree_info() - betree_info1183 = _t2019 - self.consume_literal(")") - _t2020 = logic_pb2.BeTreeRelation(name=relation_id1182, relation_info=betree_info1183) - result1185 = _t2020 - self.record_span(span_start1184, "BeTreeRelation") - return result1185 - - def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1189 = self.span_start() - self.consume_literal("(") - self.consume_literal("betree_info") - _t2021 = self.parse_betree_info_key_types() - betree_info_key_types1186 = _t2021 - _t2022 = self.parse_betree_info_value_types() - betree_info_value_types1187 = _t2022 - _t2023 = self.parse_config_dict() - config_dict1188 = _t2023 - self.consume_literal(")") - _t2024 = self.construct_betree_info(betree_info_key_types1186, betree_info_value_types1187, config_dict1188) - result1190 = _t2024 - self.record_span(span_start1189, "BeTreeInfo") - return result1190 ->>>>>>> origin/main - - def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: - self.consume_literal("(") - self.consume_literal("key_types") -<<<<<<< HEAD - xs1157 = [] - cond1158 = (((((((((((((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 cond1158: - _t1957 = self.parse_type() - item1159 = _t1957 - xs1157.append(item1159) - cond1158 = (((((((((((((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)) - types1160 = xs1157 - self.consume_literal(")") - return types1160 -======= - xs1191 = [] - cond1192 = (((((((((((((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 cond1192: - _t2025 = self.parse_type() - item1193 = _t2025 - xs1191.append(item1193) - cond1192 = (((((((((((((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)) - types1194 = xs1191 - self.consume_literal(")") - return types1194 ->>>>>>> origin/main - - def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: - self.consume_literal("(") - self.consume_literal("value_types") -<<<<<<< HEAD - xs1161 = [] - cond1162 = (((((((((((((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 cond1162: - _t1958 = self.parse_type() - item1163 = _t1958 - xs1161.append(item1163) - cond1162 = (((((((((((((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)) - types1164 = xs1161 + span_start1187 = 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 self.consume_literal(")") - return types1164 + _t2026 = logic_pb2.BeTreeRelation(name=relation_id1185, relation_info=betree_info1186) + result1188 = _t2026 + self.record_span(span_start1187, "BeTreeRelation") + return result1188 - def parse_csv_data(self) -> logic_pb2.CSVData: - span_start1169 = self.span_start() + def parse_betree_info(self) -> logic_pb2.BeTreeInfo: + span_start1192 = self.span_start() self.consume_literal("(") - self.consume_literal("csv_data") - _t1959 = self.parse_csvlocator() - csvlocator1165 = _t1959 - _t1960 = self.parse_csv_config() - csv_config1166 = _t1960 - _t1961 = self.parse_gnf_columns() - gnf_columns1167 = _t1961 - _t1962 = self.parse_csv_asof() - csv_asof1168 = _t1962 - self.consume_literal(")") - _t1963 = logic_pb2.CSVData(locator=csvlocator1165, config=csv_config1166, columns=gnf_columns1167, asof=csv_asof1168) - result1170 = _t1963 - self.record_span(span_start1169, "CSVData") - return result1170 + 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 + 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 - def parse_csvlocator(self) -> logic_pb2.CSVLocator: - span_start1173 = self.span_start() + def parse_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") - self.consume_literal("csv_locator") - if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t1965 = self.parse_csv_locator_paths() - _t1964 = _t1965 - else: - _t1964 = None - csv_locator_paths1171 = _t1964 - if self.match_lookahead_literal("(", 0): - _t1967 = self.parse_csv_locator_inline_data() - _t1966 = _t1967 - else: - _t1966 = None - csv_locator_inline_data1172 = _t1966 + 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 self.consume_literal(")") - _t1968 = logic_pb2.CSVLocator(paths=(csv_locator_paths1171 if csv_locator_paths1171 is not None else []), inline_data=(csv_locator_inline_data1172 if csv_locator_inline_data1172 is not None else "").encode()) - result1174 = _t1968 - self.record_span(span_start1173, "CSVLocator") - return result1174 -======= - 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: - _t2026 = self.parse_type() - item1197 = _t2026 - 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 + return types1197 + + 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 self.consume_literal(")") - return types1198 + return types1201 def parse_csv_data(self) -> logic_pb2.CSVData: - span_start1204 = self.span_start() + span_start1207 = self.span_start() self.consume_literal("(") self.consume_literal("csv_data") - _t2027 = self.parse_csvlocator() - csvlocator1199 = _t2027 - _t2028 = self.parse_csv_config() - csv_config1200 = _t2028 + _t2033 = self.parse_csvlocator() + csvlocator1202 = _t2033 + _t2034 = self.parse_csv_config() + csv_config1203 = _t2034 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("columns", 1)): - _t2030 = self.parse_gnf_columns() - _t2029 = _t2030 + _t2036 = self.parse_gnf_columns() + _t2035 = _t2036 else: - _t2029 = None - gnf_columns1201 = _t2029 + _t2035 = None + gnf_columns1204 = _t2035 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("relations", 1)): - _t2032 = self.parse_target_relations() - _t2031 = _t2032 + _t2038 = self.parse_target_relations() + _t2037 = _t2038 else: - _t2031 = None - target_relations1202 = _t2031 - _t2033 = self.parse_csv_asof() - csv_asof1203 = _t2033 + _t2037 = None + target_relations1205 = _t2037 + _t2039 = self.parse_csv_asof() + csv_asof1206 = _t2039 self.consume_literal(")") - _t2034 = self.construct_csv_data(csvlocator1199, csv_config1200, gnf_columns1201, target_relations1202, csv_asof1203) - result1205 = _t2034 - self.record_span(span_start1204, "CSVData") - return result1205 + _t2040 = self.construct_csv_data(csvlocator1202, csv_config1203, gnf_columns1204, target_relations1205, csv_asof1206) + result1208 = _t2040 + self.record_span(span_start1207, "CSVData") + return result1208 def parse_csvlocator(self) -> logic_pb2.CSVLocator: - span_start1208 = self.span_start() + span_start1211 = self.span_start() self.consume_literal("(") self.consume_literal("csv_locator") if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("paths", 1)): - _t2036 = self.parse_csv_locator_paths() - _t2035 = _t2036 + _t2042 = self.parse_csv_locator_paths() + _t2041 = _t2042 else: - _t2035 = None - csv_locator_paths1206 = _t2035 + _t2041 = None + csv_locator_paths1209 = _t2041 if self.match_lookahead_literal("(", 0): - _t2038 = self.parse_csv_locator_inline_data() - _t2037 = _t2038 + _t2044 = self.parse_csv_locator_inline_data() + _t2043 = _t2044 else: - _t2037 = None - csv_locator_inline_data1207 = _t2037 + _t2043 = None + csv_locator_inline_data1210 = _t2043 self.consume_literal(")") - _t2039 = logic_pb2.CSVLocator(paths=(csv_locator_paths1206 if csv_locator_paths1206 is not None else []), inline_data=(csv_locator_inline_data1207 if csv_locator_inline_data1207 is not None else "").encode()) - result1209 = _t2039 - self.record_span(span_start1208, "CSVLocator") - return result1209 ->>>>>>> origin/main + _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 def parse_csv_locator_paths(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("paths") -<<<<<<< HEAD - xs1175 = [] - cond1176 = self.match_lookahead_terminal("STRING", 0) - while cond1176: - item1177 = self.consume_terminal("STRING") - xs1175.append(item1177) - cond1176 = self.match_lookahead_terminal("STRING", 0) - strings1178 = xs1175 + 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 self.consume_literal(")") - return strings1178 -======= - xs1210 = [] - cond1211 = self.match_lookahead_terminal("STRING", 0) - while cond1211: - item1212 = self.consume_terminal("STRING") - xs1210.append(item1212) - cond1211 = self.match_lookahead_terminal("STRING", 0) - strings1213 = xs1210 - self.consume_literal(")") - return strings1213 ->>>>>>> origin/main + return strings1216 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") -<<<<<<< HEAD - formatted_string1179 = self.consume_terminal("STRING") - self.consume_literal(")") - return formatted_string1179 - - def parse_csv_config(self) -> logic_pb2.CSVConfig: - span_start1182 = self.span_start() - self.consume_literal("(") - self.consume_literal("csv_config") - _t1969 = self.parse_config_dict() - config_dict1180 = _t1969 - if self.match_lookahead_literal("(", 0): - _t1971 = self.parse__storage_integration() - _t1970 = _t1971 - else: - _t1970 = None - _storage_integration1181 = _t1970 + formatted_string1217 = self.consume_terminal("STRING") self.consume_literal(")") - _t1972 = self.construct_csv_config(config_dict1180, _storage_integration1181) - result1183 = _t1972 - self.record_span(span_start1182, "CSVConfig") - return result1183 -======= - formatted_string1214 = self.consume_terminal("STRING") - self.consume_literal(")") - return formatted_string1214 + return formatted_string1217 def parse_csv_config(self) -> logic_pb2.CSVConfig: - span_start1217 = self.span_start() + span_start1220 = self.span_start() self.consume_literal("(") self.consume_literal("csv_config") - _t2040 = self.parse_config_dict() - config_dict1215 = _t2040 + _t2046 = self.parse_config_dict() + config_dict1218 = _t2046 if self.match_lookahead_literal("(", 0): - _t2042 = self.parse__storage_integration() - _t2041 = _t2042 + _t2048 = self.parse__storage_integration() + _t2047 = _t2048 else: - _t2041 = None - _storage_integration1216 = _t2041 + _t2047 = None + _storage_integration1219 = _t2047 self.consume_literal(")") - _t2043 = self.construct_csv_config(config_dict1215, _storage_integration1216) - result1218 = _t2043 - self.record_span(span_start1217, "CSVConfig") - return result1218 ->>>>>>> origin/main + _t2049 = self.construct_csv_config(config_dict1218, _storage_integration1219) + result1221 = _t2049 + self.record_span(span_start1220, "CSVConfig") + return result1221 def parse__storage_integration(self) -> Sequence[tuple[str, logic_pb2.Value]]: self.consume_literal("(") self.consume_literal("storage_integration") -<<<<<<< HEAD - _t1973 = self.parse_config_dict() - config_dict1184 = _t1973 - self.consume_literal(")") - return config_dict1184 -======= - _t2044 = self.parse_config_dict() - config_dict1219 = _t2044 + _t2050 = self.parse_config_dict() + config_dict1222 = _t2050 self.consume_literal(")") - return config_dict1219 ->>>>>>> origin/main + return config_dict1222 def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") -<<<<<<< HEAD - xs1185 = [] - cond1186 = self.match_lookahead_literal("(", 0) - while cond1186: - _t1974 = self.parse_gnf_column() - item1187 = _t1974 - xs1185.append(item1187) - cond1186 = self.match_lookahead_literal("(", 0) - gnf_columns1188 = xs1185 - self.consume_literal(")") - return gnf_columns1188 - - def parse_gnf_column(self) -> logic_pb2.GNFColumn: - span_start1195 = self.span_start() - self.consume_literal("(") - self.consume_literal("column") - _t1975 = self.parse_gnf_column_path() - gnf_column_path1189 = _t1975 - if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t1977 = self.parse_relation_id() - _t1976 = _t1977 - else: - _t1976 = None - relation_id1190 = _t1976 - self.consume_literal("[") - xs1191 = [] - cond1192 = (((((((((((((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 cond1192: - _t1978 = self.parse_type() - item1193 = _t1978 - xs1191.append(item1193) - cond1192 = (((((((((((((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)) - types1194 = xs1191 - self.consume_literal("]") - self.consume_literal(")") - _t1979 = logic_pb2.GNFColumn(column_path=gnf_column_path1189, target_id=relation_id1190, types=types1194) - result1196 = _t1979 - self.record_span(span_start1195, "GNFColumn") - return result1196 - - def parse_gnf_column_path(self) -> Sequence[str]: - if self.match_lookahead_literal("[", 0): - _t1980 = 1 - else: - if self.match_lookahead_terminal("STRING", 0): - _t1981 = 0 - else: - _t1981 = -1 - _t1980 = _t1981 - prediction1197 = _t1980 - if prediction1197 == 1: - self.consume_literal("[") - xs1199 = [] - cond1200 = self.match_lookahead_terminal("STRING", 0) - while cond1200: - item1201 = self.consume_terminal("STRING") - xs1199.append(item1201) - cond1200 = self.match_lookahead_terminal("STRING", 0) - strings1202 = xs1199 - self.consume_literal("]") - _t1982 = strings1202 - else: - if prediction1197 == 0: - string1198 = self.consume_terminal("STRING") - _t1983 = [string1198] - else: - raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t1982 = _t1983 - return _t1982 -======= - xs1220 = [] - cond1221 = self.match_lookahead_literal("(", 0) - while cond1221: - _t2045 = self.parse_gnf_column() - item1222 = _t2045 - xs1220.append(item1222) - cond1221 = self.match_lookahead_literal("(", 0) - gnf_columns1223 = xs1220 + 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 self.consume_literal(")") - return gnf_columns1223 + return gnf_columns1226 def parse_gnf_column(self) -> logic_pb2.GNFColumn: - span_start1230 = self.span_start() + span_start1233 = self.span_start() self.consume_literal("(") self.consume_literal("column") - _t2046 = self.parse_gnf_column_path() - gnf_column_path1224 = _t2046 + _t2052 = self.parse_gnf_column_path() + gnf_column_path1227 = _t2052 if (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)): - _t2048 = self.parse_relation_id() - _t2047 = _t2048 + _t2054 = self.parse_relation_id() + _t2053 = _t2054 else: - _t2047 = None - relation_id1225 = _t2047 + _t2053 = None + relation_id1228 = _t2053 self.consume_literal("[") - xs1226 = [] - cond1227 = (((((((((((((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 cond1227: - _t2049 = self.parse_type() - item1228 = _t2049 - xs1226.append(item1228) - cond1227 = (((((((((((((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)) - types1229 = xs1226 + 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 self.consume_literal("]") self.consume_literal(")") - _t2050 = logic_pb2.GNFColumn(column_path=gnf_column_path1224, target_id=relation_id1225, types=types1229) - result1231 = _t2050 - self.record_span(span_start1230, "GNFColumn") - return result1231 + _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 def parse_gnf_column_path(self) -> Sequence[str]: if self.match_lookahead_literal("[", 0): - _t2051 = 1 + _t2057 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t2052 = 0 + _t2058 = 0 else: - _t2052 = -1 - _t2051 = _t2052 - prediction1232 = _t2051 - if prediction1232 == 1: + _t2058 = -1 + _t2057 = _t2058 + prediction1235 = _t2057 + if prediction1235 == 1: self.consume_literal("[") - xs1234 = [] - cond1235 = self.match_lookahead_terminal("STRING", 0) - while cond1235: - item1236 = self.consume_terminal("STRING") - xs1234.append(item1236) - cond1235 = self.match_lookahead_terminal("STRING", 0) - strings1237 = xs1234 + 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 self.consume_literal("]") - _t2053 = strings1237 + _t2059 = strings1240 else: - if prediction1232 == 0: - string1233 = self.consume_terminal("STRING") - _t2054 = [string1233] + if prediction1235 == 0: + string1236 = self.consume_terminal("STRING") + _t2060 = [string1236] else: raise ParseError("Unexpected token in gnf_column_path" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2053 = _t2054 - return _t2053 + _t2059 = _t2060 + return _t2059 def parse_target_relations(self) -> logic_pb2.TargetRelations: - span_start1240 = self.span_start() + span_start1243 = self.span_start() self.consume_literal("(") self.consume_literal("relations") - _t2055 = self.parse_relation_keys() - relation_keys1238 = _t2055 - _t2056 = self.parse_relation_body() - relation_body1239 = _t2056 + _t2061 = self.parse_relation_keys() + relation_keys1241 = _t2061 + _t2062 = self.parse_relation_body() + relation_body1242 = _t2062 self.consume_literal(")") - _t2057 = self.construct_relations(relation_keys1238, relation_body1239) - result1241 = _t2057 - self.record_span(span_start1240, "TargetRelations") - return result1241 + _t2063 = self.construct_relations(relation_keys1241, relation_body1242) + result1244 = _t2063 + self.record_span(span_start1243, "TargetRelations") + return result1244 def parse_relation_keys(self) -> Sequence[logic_pb2.NamedColumn]: self.consume_literal("(") self.consume_literal("keys") - xs1242 = [] - cond1243 = self.match_lookahead_literal("(", 0) - while cond1243: - _t2058 = self.parse_named_column() - item1244 = _t2058 - xs1242.append(item1244) - cond1243 = self.match_lookahead_literal("(", 0) - named_columns1245 = xs1242 + 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_columns1245 + return named_columns1248 def parse_named_column(self) -> logic_pb2.NamedColumn: - span_start1248 = self.span_start() + span_start1251 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1246 = self.consume_terminal("STRING") - _t2059 = self.parse_type() - type1247 = _t2059 + string1249 = self.consume_terminal("STRING") + _t2065 = self.parse_type() + type1250 = _t2065 self.consume_literal(")") - _t2060 = logic_pb2.NamedColumn(name=string1246, type=type1247) - result1249 = _t2060 - self.record_span(span_start1248, "NamedColumn") - return result1249 + _t2066 = logic_pb2.NamedColumn(name=string1249, type=type1250) + result1252 = _t2066 + self.record_span(span_start1251, "NamedColumn") + return result1252 def parse_relation_body(self) -> logic_pb2.TargetRelations: - span_start1254 = self.span_start() + span_start1257 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("relation", 1): - _t2062 = 0 + _t2068 = 0 else: if self.match_lookahead_literal("inserts", 1): - _t2063 = 1 + _t2069 = 1 else: - _t2063 = 0 - _t2062 = _t2063 - _t2061 = _t2062 - else: - _t2061 = 0 - prediction1250 = _t2061 - if prediction1250 == 1: - _t2065 = self.parse_cdc_inserts() - cdc_inserts1252 = _t2065 - _t2066 = self.parse_cdc_deletes() - cdc_deletes1253 = _t2066 - _t2067 = self.construct_cdc_relations(cdc_inserts1252, cdc_deletes1253) - _t2064 = _t2067 - else: - if prediction1250 == 0: - _t2069 = self.parse_non_cdc_relations() - non_cdc_relations1251 = _t2069 - _t2070 = self.construct_non_cdc_relations(non_cdc_relations1251) - _t2068 = _t2070 + _t2069 = 0 + _t2068 = _t2069 + _t2067 = _t2068 + 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 + 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 else: raise ParseError("Unexpected token in relation_body" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2064 = _t2068 - result1255 = _t2064 - self.record_span(span_start1254, "TargetRelations") - return result1255 + _t2070 = _t2074 + result1258 = _t2070 + self.record_span(span_start1257, "TargetRelations") + return result1258 def parse_non_cdc_relations(self) -> Sequence[logic_pb2.TargetRelation]: - xs1256 = [] - cond1257 = self.match_lookahead_literal("(", 0) - while cond1257: - _t2071 = self.parse_target_relation() - item1258 = _t2071 - xs1256.append(item1258) - cond1257 = self.match_lookahead_literal("(", 0) - return xs1256 + 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_start1264 = self.span_start() + span_start1267 = self.span_start() self.consume_literal("(") self.consume_literal("relation") - _t2072 = self.parse_relation_id() - relation_id1259 = _t2072 - xs1260 = [] - cond1261 = self.match_lookahead_literal("(", 0) - while cond1261: - _t2073 = self.parse_named_column() - item1262 = _t2073 - xs1260.append(item1262) - cond1261 = self.match_lookahead_literal("(", 0) - named_columns1263 = xs1260 - self.consume_literal(")") - _t2074 = logic_pb2.TargetRelation(target_id=relation_id1259, values=named_columns1263) - result1265 = _t2074 - self.record_span(span_start1264, "TargetRelation") - return result1265 + _t2078 = self.parse_relation_id() + relation_id1262 = _t2078 + xs1263 = [] + cond1264 = self.match_lookahead_literal("(", 0) + while cond1264: + _t2079 = self.parse_named_column() + item1265 = _t2079 + 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 def parse_cdc_inserts(self) -> Sequence[logic_pb2.TargetRelation]: self.consume_literal("(") self.consume_literal("inserts") - xs1266 = [] - cond1267 = self.match_lookahead_literal("(", 0) - while cond1267: - _t2075 = self.parse_target_relation() - item1268 = _t2075 - xs1266.append(item1268) - cond1267 = self.match_lookahead_literal("(", 0) - target_relations1269 = xs1266 + 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(")") - return target_relations1269 + return target_relations1272 def parse_cdc_deletes(self) -> Sequence[logic_pb2.TargetRelation]: self.consume_literal("(") self.consume_literal("deletes") - xs1270 = [] - cond1271 = self.match_lookahead_literal("(", 0) - while cond1271: - _t2076 = self.parse_target_relation() - item1272 = _t2076 - xs1270.append(item1272) - cond1271 = self.match_lookahead_literal("(", 0) - target_relations1273 = xs1270 + xs1273 = [] + cond1274 = self.match_lookahead_literal("(", 0) + while cond1274: + _t2082 = self.parse_target_relation() + item1275 = _t2082 + xs1273.append(item1275) + cond1274 = self.match_lookahead_literal("(", 0) + target_relations1276 = xs1273 self.consume_literal(")") - return target_relations1273 ->>>>>>> origin/main + return target_relations1276 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") -<<<<<<< HEAD - string1203 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1203 - - def parse_iceberg_data(self) -> logic_pb2.IcebergData: - span_start1210 = self.span_start() - self.consume_literal("(") - self.consume_literal("iceberg_data") - _t1984 = self.parse_iceberg_locator() - iceberg_locator1204 = _t1984 - _t1985 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1205 = _t1985 - _t1986 = self.parse_gnf_columns() - gnf_columns1206 = _t1986 - if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("from_snapshot", 1)): - _t1988 = self.parse_iceberg_from_snapshot() - _t1987 = _t1988 - else: - _t1987 = None - iceberg_from_snapshot1207 = _t1987 - if self.match_lookahead_literal("(", 0): - _t1990 = self.parse_iceberg_to_snapshot() - _t1989 = _t1990 - else: - _t1989 = None - iceberg_to_snapshot1208 = _t1989 - _t1991 = self.parse_boolean_value() - boolean_value1209 = _t1991 - self.consume_literal(")") - _t1992 = self.construct_iceberg_data(iceberg_locator1204, iceberg_catalog_config1205, gnf_columns1206, iceberg_from_snapshot1207, iceberg_to_snapshot1208, boolean_value1209) - result1211 = _t1992 - self.record_span(span_start1210, "IcebergData") - return result1211 - - def parse_iceberg_locator(self) -> logic_pb2.IcebergLocator: - span_start1215 = self.span_start() - self.consume_literal("(") - self.consume_literal("iceberg_locator") - _t1993 = self.parse_iceberg_locator_table_name() - iceberg_locator_table_name1212 = _t1993 - _t1994 = self.parse_iceberg_locator_namespace() - iceberg_locator_namespace1213 = _t1994 - _t1995 = self.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1214 = _t1995 - self.consume_literal(")") - _t1996 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1212, namespace=iceberg_locator_namespace1213, warehouse=iceberg_locator_warehouse1214) - result1216 = _t1996 - self.record_span(span_start1215, "IcebergLocator") - return result1216 -======= - string1274 = self.consume_terminal("STRING") + string1277 = self.consume_terminal("STRING") self.consume_literal(")") - return string1274 + return string1277 def parse_iceberg_data(self) -> logic_pb2.IcebergData: - span_start1281 = self.span_start() + span_start1284 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_data") - _t2077 = self.parse_iceberg_locator() - iceberg_locator1275 = _t2077 - _t2078 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1276 = _t2078 - _t2079 = self.parse_gnf_columns() - gnf_columns1277 = _t2079 + _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 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("from_snapshot", 1)): - _t2081 = self.parse_iceberg_from_snapshot() - _t2080 = _t2081 + _t2087 = self.parse_iceberg_from_snapshot() + _t2086 = _t2087 else: - _t2080 = None - iceberg_from_snapshot1278 = _t2080 + _t2086 = None + iceberg_from_snapshot1281 = _t2086 if self.match_lookahead_literal("(", 0): - _t2083 = self.parse_iceberg_to_snapshot() - _t2082 = _t2083 + _t2089 = self.parse_iceberg_to_snapshot() + _t2088 = _t2089 else: - _t2082 = None - iceberg_to_snapshot1279 = _t2082 - _t2084 = self.parse_boolean_value() - boolean_value1280 = _t2084 + _t2088 = None + iceberg_to_snapshot1282 = _t2088 + _t2090 = self.parse_boolean_value() + boolean_value1283 = _t2090 self.consume_literal(")") - _t2085 = self.construct_iceberg_data(iceberg_locator1275, iceberg_catalog_config1276, gnf_columns1277, iceberg_from_snapshot1278, iceberg_to_snapshot1279, boolean_value1280) - result1282 = _t2085 - self.record_span(span_start1281, "IcebergData") - return result1282 + _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 def parse_iceberg_locator(self) -> logic_pb2.IcebergLocator: - span_start1286 = self.span_start() + span_start1289 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_locator") - _t2086 = self.parse_iceberg_locator_table_name() - iceberg_locator_table_name1283 = _t2086 - _t2087 = self.parse_iceberg_locator_namespace() - iceberg_locator_namespace1284 = _t2087 - _t2088 = self.parse_iceberg_locator_warehouse() - iceberg_locator_warehouse1285 = _t2088 - self.consume_literal(")") - _t2089 = logic_pb2.IcebergLocator(table_name=iceberg_locator_table_name1283, namespace=iceberg_locator_namespace1284, warehouse=iceberg_locator_warehouse1285) - result1287 = _t2089 - self.record_span(span_start1286, "IcebergLocator") - return result1287 ->>>>>>> origin/main + _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 + 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 def parse_iceberg_locator_table_name(self) -> str: self.consume_literal("(") self.consume_literal("table_name") -<<<<<<< HEAD - string1217 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1217 -======= - string1288 = self.consume_terminal("STRING") + string1291 = self.consume_terminal("STRING") self.consume_literal(")") - return string1288 ->>>>>>> origin/main + return string1291 def parse_iceberg_locator_namespace(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("namespace") -<<<<<<< HEAD - xs1218 = [] - cond1219 = self.match_lookahead_terminal("STRING", 0) - while cond1219: - item1220 = self.consume_terminal("STRING") - xs1218.append(item1220) - cond1219 = self.match_lookahead_terminal("STRING", 0) - strings1221 = xs1218 + 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 self.consume_literal(")") - return strings1221 -======= - xs1289 = [] - cond1290 = self.match_lookahead_terminal("STRING", 0) - while cond1290: - item1291 = self.consume_terminal("STRING") - xs1289.append(item1291) - cond1290 = self.match_lookahead_terminal("STRING", 0) - strings1292 = xs1289 - self.consume_literal(")") - return strings1292 ->>>>>>> origin/main + return strings1295 def parse_iceberg_locator_warehouse(self) -> str: self.consume_literal("(") self.consume_literal("warehouse") -<<<<<<< HEAD - string1222 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1222 - - def parse_iceberg_catalog_config(self) -> logic_pb2.IcebergCatalogConfig: - span_start1227 = self.span_start() - self.consume_literal("(") - self.consume_literal("iceberg_catalog_config") - _t1997 = self.parse_iceberg_catalog_uri() - iceberg_catalog_uri1223 = _t1997 - if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("scope", 1)): - _t1999 = self.parse_iceberg_catalog_config_scope() - _t1998 = _t1999 - else: - _t1998 = None - iceberg_catalog_config_scope1224 = _t1998 - _t2000 = self.parse_iceberg_properties() - iceberg_properties1225 = _t2000 - _t2001 = self.parse_iceberg_auth_properties() - iceberg_auth_properties1226 = _t2001 + string1296 = self.consume_terminal("STRING") self.consume_literal(")") - _t2002 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1223, iceberg_catalog_config_scope1224, iceberg_properties1225, iceberg_auth_properties1226) - result1228 = _t2002 - self.record_span(span_start1227, "IcebergCatalogConfig") - return result1228 -======= - string1293 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1293 + return string1296 def parse_iceberg_catalog_config(self) -> logic_pb2.IcebergCatalogConfig: - span_start1298 = self.span_start() + span_start1301 = self.span_start() self.consume_literal("(") self.consume_literal("iceberg_catalog_config") - _t2090 = self.parse_iceberg_catalog_uri() - iceberg_catalog_uri1294 = _t2090 + _t2096 = self.parse_iceberg_catalog_uri() + iceberg_catalog_uri1297 = _t2096 if (self.match_lookahead_literal("(", 0) and self.match_lookahead_literal("scope", 1)): - _t2092 = self.parse_iceberg_catalog_config_scope() - _t2091 = _t2092 + _t2098 = self.parse_iceberg_catalog_config_scope() + _t2097 = _t2098 else: - _t2091 = None - iceberg_catalog_config_scope1295 = _t2091 - _t2093 = self.parse_iceberg_properties() - iceberg_properties1296 = _t2093 - _t2094 = self.parse_iceberg_auth_properties() - iceberg_auth_properties1297 = _t2094 + _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 self.consume_literal(")") - _t2095 = self.construct_iceberg_catalog_config(iceberg_catalog_uri1294, iceberg_catalog_config_scope1295, iceberg_properties1296, iceberg_auth_properties1297) - result1299 = _t2095 - self.record_span(span_start1298, "IcebergCatalogConfig") - return result1299 ->>>>>>> origin/main + _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 def parse_iceberg_catalog_uri(self) -> str: self.consume_literal("(") self.consume_literal("catalog_uri") -<<<<<<< HEAD - string1229 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1229 -======= - string1300 = self.consume_terminal("STRING") + string1303 = self.consume_terminal("STRING") self.consume_literal(")") - return string1300 ->>>>>>> origin/main + return string1303 def parse_iceberg_catalog_config_scope(self) -> str: self.consume_literal("(") self.consume_literal("scope") -<<<<<<< HEAD - string1230 = self.consume_terminal("STRING") + string1304 = self.consume_terminal("STRING") self.consume_literal(")") - return string1230 -======= - string1301 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1301 ->>>>>>> origin/main + return string1304 def parse_iceberg_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("properties") -<<<<<<< HEAD - xs1231 = [] - cond1232 = self.match_lookahead_literal("(", 0) - while cond1232: - _t2003 = self.parse_iceberg_property_entry() - item1233 = _t2003 - xs1231.append(item1233) - cond1232 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1234 = xs1231 - self.consume_literal(")") - return iceberg_property_entrys1234 -======= - xs1302 = [] - cond1303 = self.match_lookahead_literal("(", 0) - while cond1303: - _t2096 = self.parse_iceberg_property_entry() - item1304 = _t2096 - xs1302.append(item1304) - cond1303 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1305 = xs1302 + 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 self.consume_literal(")") - return iceberg_property_entrys1305 ->>>>>>> origin/main + return iceberg_property_entrys1308 def parse_iceberg_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") -<<<<<<< HEAD - string1235 = self.consume_terminal("STRING") - string_31236 = self.consume_terminal("STRING") + string1309 = self.consume_terminal("STRING") + string_31310 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1235, string_31236,) -======= - string1306 = self.consume_terminal("STRING") - string_31307 = self.consume_terminal("STRING") - self.consume_literal(")") - return (string1306, string_31307,) ->>>>>>> origin/main + return (string1309, string_31310,) def parse_iceberg_auth_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("auth_properties") -<<<<<<< HEAD - xs1237 = [] - cond1238 = self.match_lookahead_literal("(", 0) - while cond1238: - _t2004 = self.parse_iceberg_masked_property_entry() - item1239 = _t2004 - xs1237.append(item1239) - cond1238 = self.match_lookahead_literal("(", 0) - iceberg_masked_property_entrys1240 = xs1237 - self.consume_literal(")") - return iceberg_masked_property_entrys1240 -======= - xs1308 = [] - cond1309 = self.match_lookahead_literal("(", 0) - while cond1309: - _t2097 = self.parse_iceberg_masked_property_entry() - item1310 = _t2097 - xs1308.append(item1310) - cond1309 = self.match_lookahead_literal("(", 0) - iceberg_masked_property_entrys1311 = xs1308 + 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 self.consume_literal(")") - return iceberg_masked_property_entrys1311 ->>>>>>> origin/main + return iceberg_masked_property_entrys1314 def parse_iceberg_masked_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") -<<<<<<< HEAD - string1241 = self.consume_terminal("STRING") - string_31242 = self.consume_terminal("STRING") - self.consume_literal(")") - return (string1241, string_31242,) -======= - string1312 = self.consume_terminal("STRING") - string_31313 = self.consume_terminal("STRING") + string1315 = self.consume_terminal("STRING") + string_31316 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1312, string_31313,) ->>>>>>> origin/main + return (string1315, string_31316,) def parse_iceberg_from_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("from_snapshot") -<<<<<<< HEAD - string1243 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1243 -======= - string1314 = self.consume_terminal("STRING") + string1317 = self.consume_terminal("STRING") self.consume_literal(")") - return string1314 ->>>>>>> origin/main + return string1317 def parse_iceberg_to_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("to_snapshot") -<<<<<<< HEAD - string1244 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1244 - - def parse_undefine(self) -> transactions_pb2.Undefine: - span_start1246 = self.span_start() - self.consume_literal("(") - self.consume_literal("undefine") - _t2005 = self.parse_fragment_id() - fragment_id1245 = _t2005 - self.consume_literal(")") - _t2006 = transactions_pb2.Undefine(fragment_id=fragment_id1245) - result1247 = _t2006 - self.record_span(span_start1246, "Undefine") - return result1247 - - def parse_context(self) -> transactions_pb2.Context: - span_start1252 = self.span_start() - self.consume_literal("(") - self.consume_literal("context") - xs1248 = [] - cond1249 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1249: - _t2007 = self.parse_relation_id() - item1250 = _t2007 - xs1248.append(item1250) - cond1249 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1251 = xs1248 - self.consume_literal(")") - _t2008 = transactions_pb2.Context(relations=relation_ids1251) - result1253 = _t2008 - self.record_span(span_start1252, "Context") - return result1253 - - def parse_snapshot(self) -> transactions_pb2.Snapshot: - span_start1259 = self.span_start() - self.consume_literal("(") - self.consume_literal("snapshot") - _t2009 = self.parse_edb_path() - edb_path1254 = _t2009 - xs1255 = [] - cond1256 = self.match_lookahead_literal("[", 0) - while cond1256: - _t2010 = self.parse_snapshot_mapping() - item1257 = _t2010 - xs1255.append(item1257) - cond1256 = self.match_lookahead_literal("[", 0) - snapshot_mappings1258 = xs1255 - self.consume_literal(")") - _t2011 = transactions_pb2.Snapshot(prefix=edb_path1254, mappings=snapshot_mappings1258) - result1260 = _t2011 - self.record_span(span_start1259, "Snapshot") - return result1260 - - def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: - span_start1263 = self.span_start() - _t2012 = self.parse_edb_path() - edb_path1261 = _t2012 - _t2013 = self.parse_relation_id() - relation_id1262 = _t2013 - _t2014 = transactions_pb2.SnapshotMapping(destination_path=edb_path1261, source_relation=relation_id1262) - result1264 = _t2014 - self.record_span(span_start1263, "SnapshotMapping") - return result1264 -======= - string1315 = self.consume_terminal("STRING") + string1318 = self.consume_terminal("STRING") self.consume_literal(")") - return string1315 + return string1318 def parse_undefine(self) -> transactions_pb2.Undefine: - span_start1317 = self.span_start() + span_start1320 = self.span_start() self.consume_literal("(") self.consume_literal("undefine") - _t2098 = self.parse_fragment_id() - fragment_id1316 = _t2098 + _t2104 = self.parse_fragment_id() + fragment_id1319 = _t2104 self.consume_literal(")") - _t2099 = transactions_pb2.Undefine(fragment_id=fragment_id1316) - result1318 = _t2099 - self.record_span(span_start1317, "Undefine") - return result1318 + _t2105 = transactions_pb2.Undefine(fragment_id=fragment_id1319) + result1321 = _t2105 + self.record_span(span_start1320, "Undefine") + return result1321 def parse_context(self) -> transactions_pb2.Context: - span_start1323 = self.span_start() + span_start1326 = self.span_start() self.consume_literal("(") self.consume_literal("context") - xs1319 = [] - cond1320 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - while cond1320: - _t2100 = self.parse_relation_id() - item1321 = _t2100 - xs1319.append(item1321) - cond1320 = (self.match_lookahead_literal(":", 0) or self.match_lookahead_terminal("UINT128", 0)) - relation_ids1322 = xs1319 + 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 self.consume_literal(")") - _t2101 = transactions_pb2.Context(relations=relation_ids1322) - result1324 = _t2101 - self.record_span(span_start1323, "Context") - return result1324 + _t2107 = transactions_pb2.Context(relations=relation_ids1325) + result1327 = _t2107 + self.record_span(span_start1326, "Context") + return result1327 def parse_snapshot(self) -> transactions_pb2.Snapshot: - span_start1330 = self.span_start() + span_start1333 = self.span_start() self.consume_literal("(") self.consume_literal("snapshot") - _t2102 = self.parse_edb_path() - edb_path1325 = _t2102 - xs1326 = [] - cond1327 = self.match_lookahead_literal("[", 0) - while cond1327: - _t2103 = self.parse_snapshot_mapping() - item1328 = _t2103 - xs1326.append(item1328) - cond1327 = self.match_lookahead_literal("[", 0) - snapshot_mappings1329 = xs1326 - self.consume_literal(")") - _t2104 = transactions_pb2.Snapshot(prefix=edb_path1325, mappings=snapshot_mappings1329) - result1331 = _t2104 - self.record_span(span_start1330, "Snapshot") - return result1331 + _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 + self.consume_literal(")") + _t2110 = transactions_pb2.Snapshot(prefix=edb_path1328, mappings=snapshot_mappings1332) + result1334 = _t2110 + self.record_span(span_start1333, "Snapshot") + return result1334 def parse_snapshot_mapping(self) -> transactions_pb2.SnapshotMapping: - span_start1334 = self.span_start() - _t2105 = self.parse_edb_path() - edb_path1332 = _t2105 - _t2106 = self.parse_relation_id() - relation_id1333 = _t2106 - _t2107 = transactions_pb2.SnapshotMapping(destination_path=edb_path1332, source_relation=relation_id1333) - result1335 = _t2107 - self.record_span(span_start1334, "SnapshotMapping") - return result1335 ->>>>>>> origin/main + 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 def parse_epoch_reads(self) -> Sequence[transactions_pb2.Read]: self.consume_literal("(") self.consume_literal("reads") -<<<<<<< HEAD - xs1265 = [] - cond1266 = self.match_lookahead_literal("(", 0) - while cond1266: - _t2015 = self.parse_read() - item1267 = _t2015 - xs1265.append(item1267) - cond1266 = self.match_lookahead_literal("(", 0) - reads1268 = xs1265 - self.consume_literal(")") - return reads1268 - - def parse_read(self) -> transactions_pb2.Read: - span_start1275 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("what_if", 1): - _t2017 = 2 - else: - if self.match_lookahead_literal("output", 1): - _t2018 = 1 - else: - if self.match_lookahead_literal("export_iceberg", 1): - _t2019 = 4 - else: - if self.match_lookahead_literal("export", 1): - _t2020 = 4 - else: - if self.match_lookahead_literal("demand", 1): - _t2021 = 0 - else: - if self.match_lookahead_literal("abort", 1): - _t2022 = 3 - else: - _t2022 = -1 - _t2021 = _t2022 - _t2020 = _t2021 - _t2019 = _t2020 - _t2018 = _t2019 - _t2017 = _t2018 - _t2016 = _t2017 - else: - _t2016 = -1 - prediction1269 = _t2016 - if prediction1269 == 4: - _t2024 = self.parse_export() - export1274 = _t2024 - _t2025 = transactions_pb2.Read(export=export1274) - _t2023 = _t2025 - else: - if prediction1269 == 3: - _t2027 = self.parse_abort() - abort1273 = _t2027 - _t2028 = transactions_pb2.Read(abort=abort1273) - _t2026 = _t2028 - else: - if prediction1269 == 2: - _t2030 = self.parse_what_if() - what_if1272 = _t2030 - _t2031 = transactions_pb2.Read(what_if=what_if1272) - _t2029 = _t2031 - else: - if prediction1269 == 1: - _t2033 = self.parse_output() - output1271 = _t2033 - _t2034 = transactions_pb2.Read(output=output1271) - _t2032 = _t2034 - else: - if prediction1269 == 0: - _t2036 = self.parse_demand() - demand1270 = _t2036 - _t2037 = transactions_pb2.Read(demand=demand1270) - _t2035 = _t2037 - else: - raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2032 = _t2035 - _t2029 = _t2032 - _t2026 = _t2029 - _t2023 = _t2026 - result1276 = _t2023 - self.record_span(span_start1275, "Read") - return result1276 -======= - xs1336 = [] - cond1337 = self.match_lookahead_literal("(", 0) - while cond1337: - _t2108 = self.parse_read() - item1338 = _t2108 - xs1336.append(item1338) - cond1337 = self.match_lookahead_literal("(", 0) - reads1339 = xs1336 + 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 self.consume_literal(")") - return reads1339 + return reads1342 def parse_read(self) -> transactions_pb2.Read: - span_start1346 = self.span_start() + span_start1349 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("what_if", 1): - _t2110 = 2 + _t2116 = 2 else: if self.match_lookahead_literal("output", 1): - _t2111 = 1 + _t2117 = 1 else: if self.match_lookahead_literal("export_iceberg", 1): - _t2112 = 4 + _t2118 = 4 else: if self.match_lookahead_literal("export", 1): - _t2113 = 4 + _t2119 = 4 else: if self.match_lookahead_literal("demand", 1): - _t2114 = 0 + _t2120 = 0 else: if self.match_lookahead_literal("abort", 1): - _t2115 = 3 + _t2121 = 3 else: - _t2115 = -1 - _t2114 = _t2115 - _t2113 = _t2114 - _t2112 = _t2113 - _t2111 = _t2112 - _t2110 = _t2111 - _t2109 = _t2110 - else: - _t2109 = -1 - prediction1340 = _t2109 - if prediction1340 == 4: - _t2117 = self.parse_export() - export1345 = _t2117 - _t2118 = transactions_pb2.Read(export=export1345) - _t2116 = _t2118 - else: - if prediction1340 == 3: - _t2120 = self.parse_abort() - abort1344 = _t2120 - _t2121 = transactions_pb2.Read(abort=abort1344) - _t2119 = _t2121 + _t2121 = -1 + _t2120 = _t2121 + _t2119 = _t2120 + _t2118 = _t2119 + _t2117 = _t2118 + _t2116 = _t2117 + _t2115 = _t2116 + else: + _t2115 = -1 + prediction1343 = _t2115 + if prediction1343 == 4: + _t2123 = self.parse_export() + export1348 = _t2123 + _t2124 = transactions_pb2.Read(export=export1348) + _t2122 = _t2124 + else: + if prediction1343 == 3: + _t2126 = self.parse_abort() + abort1347 = _t2126 + _t2127 = transactions_pb2.Read(abort=abort1347) + _t2125 = _t2127 else: - if prediction1340 == 2: - _t2123 = self.parse_what_if() - what_if1343 = _t2123 - _t2124 = transactions_pb2.Read(what_if=what_if1343) - _t2122 = _t2124 + if prediction1343 == 2: + _t2129 = self.parse_what_if() + what_if1346 = _t2129 + _t2130 = transactions_pb2.Read(what_if=what_if1346) + _t2128 = _t2130 else: - if prediction1340 == 1: - _t2126 = self.parse_output() - output1342 = _t2126 - _t2127 = transactions_pb2.Read(output=output1342) - _t2125 = _t2127 + if prediction1343 == 1: + _t2132 = self.parse_output() + output1345 = _t2132 + _t2133 = transactions_pb2.Read(output=output1345) + _t2131 = _t2133 else: - if prediction1340 == 0: - _t2129 = self.parse_demand() - demand1341 = _t2129 - _t2130 = transactions_pb2.Read(demand=demand1341) - _t2128 = _t2130 + if prediction1343 == 0: + _t2135 = self.parse_demand() + demand1344 = _t2135 + _t2136 = transactions_pb2.Read(demand=demand1344) + _t2134 = _t2136 else: raise ParseError("Unexpected token in read" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2125 = _t2128 - _t2122 = _t2125 - _t2119 = _t2122 - _t2116 = _t2119 - result1347 = _t2116 - self.record_span(span_start1346, "Read") - return result1347 - - def parse_demand(self) -> transactions_pb2.Demand: - span_start1349 = self.span_start() - self.consume_literal("(") - self.consume_literal("demand") - _t2131 = self.parse_relation_id() - relation_id1348 = _t2131 - self.consume_literal(")") - _t2132 = transactions_pb2.Demand(relation_id=relation_id1348) - result1350 = _t2132 - self.record_span(span_start1349, "Demand") + _t2131 = _t2134 + _t2128 = _t2131 + _t2125 = _t2128 + _t2122 = _t2125 + result1350 = _t2122 + self.record_span(span_start1349, "Read") return result1350 ->>>>>>> origin/main def parse_demand(self) -> transactions_pb2.Demand: - span_start1278 = self.span_start() + span_start1352 = self.span_start() self.consume_literal("(") self.consume_literal("demand") - _t2038 = self.parse_relation_id() - relation_id1277 = _t2038 + _t2137 = self.parse_relation_id() + relation_id1351 = _t2137 self.consume_literal(")") - _t2039 = transactions_pb2.Demand(relation_id=relation_id1277) - result1279 = _t2039 - self.record_span(span_start1278, "Demand") - return result1279 + _t2138 = transactions_pb2.Demand(relation_id=relation_id1351) + result1353 = _t2138 + self.record_span(span_start1352, "Demand") + return result1353 def parse_output(self) -> transactions_pb2.Output: -<<<<<<< HEAD - span_start1282 = self.span_start() + span_start1356 = self.span_start() self.consume_literal("(") self.consume_literal("output") - _t2040 = self.parse_name() - name1280 = _t2040 - _t2041 = self.parse_relation_id() - relation_id1281 = _t2041 + _t2139 = self.parse_name() + name1354 = _t2139 + _t2140 = self.parse_relation_id() + relation_id1355 = _t2140 self.consume_literal(")") - _t2042 = transactions_pb2.Output(name=name1280, relation_id=relation_id1281) - result1283 = _t2042 - self.record_span(span_start1282, "Output") - return result1283 + _t2141 = transactions_pb2.Output(name=name1354, relation_id=relation_id1355) + result1357 = _t2141 + self.record_span(span_start1356, "Output") + return result1357 def parse_what_if(self) -> transactions_pb2.WhatIf: - span_start1286 = self.span_start() + span_start1360 = self.span_start() self.consume_literal("(") self.consume_literal("what_if") - _t2043 = self.parse_name() - name1284 = _t2043 - _t2044 = self.parse_epoch() - epoch1285 = _t2044 + _t2142 = self.parse_name() + name1358 = _t2142 + _t2143 = self.parse_epoch() + epoch1359 = _t2143 self.consume_literal(")") - _t2045 = transactions_pb2.WhatIf(branch=name1284, epoch=epoch1285) - result1287 = _t2045 - self.record_span(span_start1286, "WhatIf") - return result1287 + _t2144 = transactions_pb2.WhatIf(branch=name1358, epoch=epoch1359) + result1361 = _t2144 + self.record_span(span_start1360, "WhatIf") + return result1361 def parse_abort(self) -> transactions_pb2.Abort: - span_start1290 = self.span_start() + span_start1364 = self.span_start() self.consume_literal("(") self.consume_literal("abort") if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t2047 = self.parse_name() - _t2046 = _t2047 + _t2146 = self.parse_name() + _t2145 = _t2146 else: - _t2046 = None - name1288 = _t2046 - _t2048 = self.parse_relation_id() - relation_id1289 = _t2048 + _t2145 = None + name1362 = _t2145 + _t2147 = self.parse_relation_id() + relation_id1363 = _t2147 self.consume_literal(")") - _t2049 = transactions_pb2.Abort(name=(name1288 if name1288 is not None else "abort"), relation_id=relation_id1289) - result1291 = _t2049 - self.record_span(span_start1290, "Abort") - return result1291 + _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 def parse_export(self) -> transactions_pb2.Export: - span_start1295 = self.span_start() + span_start1369 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_iceberg", 1): - _t2051 = 1 + _t2150 = 1 else: if self.match_lookahead_literal("export", 1): - _t2052 = 0 + _t2151 = 0 else: - _t2052 = -1 - _t2051 = _t2052 - _t2050 = _t2051 + _t2151 = -1 + _t2150 = _t2151 + _t2149 = _t2150 else: - _t2050 = -1 - prediction1292 = _t2050 - if prediction1292 == 1: + _t2149 = -1 + prediction1366 = _t2149 + if prediction1366 == 1: self.consume_literal("(") self.consume_literal("export_iceberg") - _t2054 = self.parse_export_iceberg_config() - export_iceberg_config1294 = _t2054 + _t2153 = self.parse_export_iceberg_config() + export_iceberg_config1368 = _t2153 self.consume_literal(")") - _t2055 = transactions_pb2.Export(iceberg_config=export_iceberg_config1294) - _t2053 = _t2055 + _t2154 = transactions_pb2.Export(iceberg_config=export_iceberg_config1368) + _t2152 = _t2154 else: - if prediction1292 == 0: + if prediction1366 == 0: self.consume_literal("(") self.consume_literal("export") - _t2057 = self.parse_export_csv_config() - export_csv_config1293 = _t2057 + _t2156 = self.parse_export_csv_config() + export_csv_config1367 = _t2156 self.consume_literal(")") - _t2058 = transactions_pb2.Export(csv_config=export_csv_config1293) - _t2056 = _t2058 + _t2157 = transactions_pb2.Export(csv_config=export_csv_config1367) + _t2155 = _t2157 else: raise ParseError("Unexpected token in export" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2053 = _t2056 - result1296 = _t2053 - self.record_span(span_start1295, "Export") - return result1296 + _t2152 = _t2155 + result1370 = _t2152 + self.record_span(span_start1369, "Export") + return result1370 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1304 = self.span_start() + span_start1378 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2060 = 0 + _t2159 = 0 else: if self.match_lookahead_literal("export_csv_config", 1): - _t2061 = 1 + _t2160 = 1 else: - _t2061 = -1 - _t2060 = _t2061 - _t2059 = _t2060 + _t2160 = -1 + _t2159 = _t2160 + _t2158 = _t2159 else: - _t2059 = -1 - prediction1297 = _t2059 - if prediction1297 == 1: + _t2158 = -1 + prediction1371 = _t2158 + if prediction1371 == 1: self.consume_literal("(") self.consume_literal("export_csv_config") - _t2063 = self.parse_export_csv_path() - export_csv_path1301 = _t2063 - _t2064 = self.parse_export_csv_columns_list() - export_csv_columns_list1302 = _t2064 - _t2065 = self.parse_config_dict() - config_dict1303 = _t2065 + _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 self.consume_literal(")") - _t2066 = self.construct_export_csv_config(export_csv_path1301, export_csv_columns_list1302, config_dict1303) - _t2062 = _t2066 + _t2165 = self.construct_export_csv_config(export_csv_path1375, export_csv_columns_list1376, config_dict1377) + _t2161 = _t2165 else: - if prediction1297 == 0: + if prediction1371 == 0: self.consume_literal("(") self.consume_literal("export_csv_config_v2") - _t2068 = self.parse_export_csv_output_location() - export_csv_output_location1298 = _t2068 - _t2069 = self.parse_export_csv_source() - export_csv_source1299 = _t2069 - _t2070 = self.parse_csv_config() - csv_config1300 = _t2070 + _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 self.consume_literal(")") - _t2071 = self.construct_export_csv_config_with_location(export_csv_output_location1298, export_csv_source1299, csv_config1300) - _t2067 = _t2071 + _t2170 = self.construct_export_csv_config_with_location(export_csv_output_location1372, export_csv_source1373, csv_config1374) + _t2166 = _t2170 else: raise ParseError("Unexpected token in export_csv_config" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2062 = _t2067 - result1305 = _t2062 - self.record_span(span_start1304, "ExportCSVConfig") - return result1305 + _t2161 = _t2166 + result1379 = _t2161 + self.record_span(span_start1378, "ExportCSVConfig") + return result1379 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): - _t2073 = 1 + _t2172 = 1 else: if self.match_lookahead_literal("path", 1): - _t2074 = 0 + _t2173 = 0 else: - _t2074 = -1 - _t2073 = _t2074 - _t2072 = _t2073 + _t2173 = -1 + _t2172 = _t2173 + _t2171 = _t2172 else: - _t2072 = -1 - prediction1306 = _t2072 - if prediction1306 == 1: + _t2171 = -1 + prediction1380 = _t2171 + if prediction1380 == 1: self.consume_literal("(") self.consume_literal("transaction_output_name") - _t2076 = self.parse_name() - name1308 = _t2076 + _t2175 = self.parse_name() + name1382 = _t2175 self.consume_literal(")") - _t2075 = ("", name1308,) + _t2174 = ("", name1382,) else: - if prediction1306 == 0: + if prediction1380 == 0: self.consume_literal("(") self.consume_literal("path") - string1307 = self.consume_terminal("STRING") + string1381 = self.consume_terminal("STRING") self.consume_literal(")") - _t2077 = (string1307, "",) + _t2176 = (string1381, "",) else: raise ParseError("Unexpected token in export_csv_output_location" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2075 = _t2077 - return _t2075 + _t2174 = _t2176 + return _t2174 def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1315 = self.span_start() + span_start1389 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("table_def", 1): - _t2079 = 1 + _t2178 = 1 else: if self.match_lookahead_literal("gnf_columns", 1): - _t2080 = 0 + _t2179 = 0 else: - _t2080 = -1 - _t2079 = _t2080 - _t2078 = _t2079 + _t2179 = -1 + _t2178 = _t2179 + _t2177 = _t2178 else: - _t2078 = -1 - prediction1309 = _t2078 - if prediction1309 == 1: + _t2177 = -1 + prediction1383 = _t2177 + if prediction1383 == 1: self.consume_literal("(") self.consume_literal("table_def") - _t2082 = self.parse_relation_id() - relation_id1314 = _t2082 + _t2181 = self.parse_relation_id() + relation_id1388 = _t2181 self.consume_literal(")") - _t2083 = transactions_pb2.ExportCSVSource(table_def=relation_id1314) - _t2081 = _t2083 + _t2182 = transactions_pb2.ExportCSVSource(table_def=relation_id1388) + _t2180 = _t2182 else: - if prediction1309 == 0: + if prediction1383 == 0: self.consume_literal("(") self.consume_literal("gnf_columns") - xs1310 = [] - cond1311 = self.match_lookahead_literal("(", 0) - while cond1311: - _t2085 = self.parse_export_csv_column() - item1312 = _t2085 - xs1310.append(item1312) - cond1311 = self.match_lookahead_literal("(", 0) - export_csv_columns1313 = xs1310 + 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 self.consume_literal(")") - _t2086 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1313) - _t2087 = transactions_pb2.ExportCSVSource(gnf_columns=_t2086) - _t2084 = _t2087 + _t2185 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1387) + _t2186 = transactions_pb2.ExportCSVSource(gnf_columns=_t2185) + _t2183 = _t2186 else: raise ParseError("Unexpected token in export_csv_source" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2081 = _t2084 - result1316 = _t2081 - self.record_span(span_start1315, "ExportCSVSource") - return result1316 + _t2180 = _t2183 + result1390 = _t2180 + self.record_span(span_start1389, "ExportCSVSource") + return result1390 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1319 = self.span_start() + span_start1393 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1317 = self.consume_terminal("STRING") - _t2088 = self.parse_relation_id() - relation_id1318 = _t2088 - self.consume_literal(")") - _t2089 = transactions_pb2.ExportCSVColumn(column_name=string1317, column_data=relation_id1318) - result1320 = _t2089 - self.record_span(span_start1319, "ExportCSVColumn") - return result1320 -======= - span_start1353 = self.span_start() - self.consume_literal("(") - self.consume_literal("output") - _t2133 = self.parse_name() - name1351 = _t2133 - _t2134 = self.parse_relation_id() - relation_id1352 = _t2134 - self.consume_literal(")") - _t2135 = transactions_pb2.Output(name=name1351, relation_id=relation_id1352) - result1354 = _t2135 - self.record_span(span_start1353, "Output") - return result1354 - - def parse_what_if(self) -> transactions_pb2.WhatIf: - span_start1357 = self.span_start() - self.consume_literal("(") - self.consume_literal("what_if") - _t2136 = self.parse_name() - name1355 = _t2136 - _t2137 = self.parse_epoch() - epoch1356 = _t2137 - self.consume_literal(")") - _t2138 = transactions_pb2.WhatIf(branch=name1355, epoch=epoch1356) - result1358 = _t2138 - self.record_span(span_start1357, "WhatIf") - return result1358 - - def parse_abort(self) -> transactions_pb2.Abort: - span_start1361 = self.span_start() - self.consume_literal("(") - self.consume_literal("abort") - if (self.match_lookahead_literal(":", 0) and self.match_lookahead_terminal("SYMBOL", 1)): - _t2140 = self.parse_name() - _t2139 = _t2140 - else: - _t2139 = None - name1359 = _t2139 - _t2141 = self.parse_relation_id() - relation_id1360 = _t2141 + string1391 = self.consume_terminal("STRING") + _t2187 = self.parse_relation_id() + relation_id1392 = _t2187 self.consume_literal(")") - _t2142 = transactions_pb2.Abort(name=(name1359 if name1359 is not None else "abort"), relation_id=relation_id1360) - result1362 = _t2142 - self.record_span(span_start1361, "Abort") - return result1362 - - def parse_export(self) -> transactions_pb2.Export: - span_start1366 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("export_iceberg", 1): - _t2144 = 1 - else: - if self.match_lookahead_literal("export", 1): - _t2145 = 0 - else: - _t2145 = -1 - _t2144 = _t2145 - _t2143 = _t2144 - else: - _t2143 = -1 - prediction1363 = _t2143 - if prediction1363 == 1: - self.consume_literal("(") - self.consume_literal("export_iceberg") - _t2147 = self.parse_export_iceberg_config() - export_iceberg_config1365 = _t2147 - self.consume_literal(")") - _t2148 = transactions_pb2.Export(iceberg_config=export_iceberg_config1365) - _t2146 = _t2148 - else: - if prediction1363 == 0: - self.consume_literal("(") - self.consume_literal("export") - _t2150 = self.parse_export_csv_config() - export_csv_config1364 = _t2150 - self.consume_literal(")") - _t2151 = transactions_pb2.Export(csv_config=export_csv_config1364) - _t2149 = _t2151 - else: - raise ParseError("Unexpected token in export" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2146 = _t2149 - result1367 = _t2146 - self.record_span(span_start1366, "Export") - return result1367 - - def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1375 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2153 = 0 - else: - if self.match_lookahead_literal("export_csv_config", 1): - _t2154 = 1 - else: - _t2154 = -1 - _t2153 = _t2154 - _t2152 = _t2153 - else: - _t2152 = -1 - prediction1368 = _t2152 - if prediction1368 == 1: - self.consume_literal("(") - self.consume_literal("export_csv_config") - _t2156 = self.parse_export_csv_path() - export_csv_path1372 = _t2156 - _t2157 = self.parse_export_csv_columns_list() - export_csv_columns_list1373 = _t2157 - _t2158 = self.parse_config_dict() - config_dict1374 = _t2158 - self.consume_literal(")") - _t2159 = self.construct_export_csv_config(export_csv_path1372, export_csv_columns_list1373, config_dict1374) - _t2155 = _t2159 - else: - if prediction1368 == 0: - self.consume_literal("(") - self.consume_literal("export_csv_config_v2") - _t2161 = self.parse_export_csv_path() - export_csv_path1369 = _t2161 - _t2162 = self.parse_export_csv_source() - export_csv_source1370 = _t2162 - _t2163 = self.parse_csv_config() - csv_config1371 = _t2163 - self.consume_literal(")") - _t2164 = self.construct_export_csv_config_with_source(export_csv_path1369, export_csv_source1370, csv_config1371) - _t2160 = _t2164 - else: - raise ParseError("Unexpected token in export_csv_config" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2155 = _t2160 - result1376 = _t2155 - self.record_span(span_start1375, "ExportCSVConfig") - return result1376 ->>>>>>> origin/main + _t2188 = transactions_pb2.ExportCSVColumn(column_name=string1391, column_data=relation_id1392) + result1394 = _t2188 + self.record_span(span_start1393, "ExportCSVColumn") + return result1394 def parse_export_csv_path(self) -> str: self.consume_literal("(") self.consume_literal("path") -<<<<<<< HEAD - string1321 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1321 -======= - string1377 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1377 - - def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1384 = self.span_start() - if self.match_lookahead_literal("(", 0): - if self.match_lookahead_literal("table_def", 1): - _t2166 = 1 - else: - if self.match_lookahead_literal("gnf_columns", 1): - _t2167 = 0 - else: - _t2167 = -1 - _t2166 = _t2167 - _t2165 = _t2166 - else: - _t2165 = -1 - prediction1378 = _t2165 - if prediction1378 == 1: - self.consume_literal("(") - self.consume_literal("table_def") - _t2169 = self.parse_relation_id() - relation_id1383 = _t2169 - self.consume_literal(")") - _t2170 = transactions_pb2.ExportCSVSource(table_def=relation_id1383) - _t2168 = _t2170 - else: - if prediction1378 == 0: - self.consume_literal("(") - self.consume_literal("gnf_columns") - xs1379 = [] - cond1380 = self.match_lookahead_literal("(", 0) - while cond1380: - _t2172 = self.parse_export_csv_column() - item1381 = _t2172 - xs1379.append(item1381) - cond1380 = self.match_lookahead_literal("(", 0) - export_csv_columns1382 = xs1379 - self.consume_literal(")") - _t2173 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1382) - _t2174 = transactions_pb2.ExportCSVSource(gnf_columns=_t2173) - _t2171 = _t2174 - else: - raise ParseError("Unexpected token in export_csv_source" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") - _t2168 = _t2171 - result1385 = _t2168 - self.record_span(span_start1384, "ExportCSVSource") - return result1385 - - def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1388 = self.span_start() - self.consume_literal("(") - self.consume_literal("column") - string1386 = self.consume_terminal("STRING") - _t2175 = self.parse_relation_id() - relation_id1387 = _t2175 + string1395 = self.consume_terminal("STRING") self.consume_literal(")") - _t2176 = transactions_pb2.ExportCSVColumn(column_name=string1386, column_data=relation_id1387) - result1389 = _t2176 - self.record_span(span_start1388, "ExportCSVColumn") - return result1389 ->>>>>>> origin/main + return string1395 def parse_export_csv_columns_list(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") -<<<<<<< HEAD - xs1322 = [] - cond1323 = self.match_lookahead_literal("(", 0) - while cond1323: - _t2090 = self.parse_export_csv_column() - item1324 = _t2090 - xs1322.append(item1324) - cond1323 = self.match_lookahead_literal("(", 0) - export_csv_columns1325 = xs1322 + 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 self.consume_literal(")") - return export_csv_columns1325 + return export_csv_columns1399 def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1331 = self.span_start() + span_start1405 = self.span_start() self.consume_literal("(") self.consume_literal("export_iceberg_config") - _t2091 = self.parse_iceberg_locator() - iceberg_locator1326 = _t2091 - _t2092 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1327 = _t2092 - _t2093 = self.parse_export_iceberg_table_def() - export_iceberg_table_def1328 = _t2093 - _t2094 = self.parse_iceberg_table_properties() - iceberg_table_properties1329 = _t2094 + _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 if self.match_lookahead_literal("{", 0): - _t2096 = self.parse_config_dict() - _t2095 = _t2096 + _t2195 = self.parse_config_dict() + _t2194 = _t2195 else: - _t2095 = None - config_dict1330 = _t2095 - self.consume_literal(")") - _t2097 = self.construct_export_iceberg_config_full(iceberg_locator1326, iceberg_catalog_config1327, export_iceberg_table_def1328, iceberg_table_properties1329, config_dict1330) - result1332 = _t2097 - self.record_span(span_start1331, "ExportIcebergConfig") - return result1332 - - def parse_export_iceberg_table_def(self) -> logic_pb2.RelationId: - span_start1334 = self.span_start() - self.consume_literal("(") - self.consume_literal("table_def") - _t2098 = self.parse_relation_id() - relation_id1333 = _t2098 - self.consume_literal(")") - result1335 = relation_id1333 - self.record_span(span_start1334, "RelationId") - return result1335 -======= - xs1390 = [] - cond1391 = self.match_lookahead_literal("(", 0) - while cond1391: - _t2177 = self.parse_export_csv_column() - item1392 = _t2177 - xs1390.append(item1392) - cond1391 = self.match_lookahead_literal("(", 0) - export_csv_columns1393 = xs1390 - self.consume_literal(")") - return export_csv_columns1393 - - def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1399 = self.span_start() - self.consume_literal("(") - self.consume_literal("export_iceberg_config") - _t2178 = self.parse_iceberg_locator() - iceberg_locator1394 = _t2178 - _t2179 = self.parse_iceberg_catalog_config() - iceberg_catalog_config1395 = _t2179 - _t2180 = self.parse_export_iceberg_table_def() - export_iceberg_table_def1396 = _t2180 - _t2181 = self.parse_iceberg_table_properties() - iceberg_table_properties1397 = _t2181 - if self.match_lookahead_literal("{", 0): - _t2183 = self.parse_config_dict() - _t2182 = _t2183 - else: - _t2182 = None - config_dict1398 = _t2182 + _t2194 = None + config_dict1404 = _t2194 self.consume_literal(")") - _t2184 = self.construct_export_iceberg_config_full(iceberg_locator1394, iceberg_catalog_config1395, export_iceberg_table_def1396, iceberg_table_properties1397, config_dict1398) - result1400 = _t2184 - self.record_span(span_start1399, "ExportIcebergConfig") - return result1400 + _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 def parse_export_iceberg_table_def(self) -> logic_pb2.RelationId: - span_start1402 = self.span_start() + span_start1408 = self.span_start() self.consume_literal("(") self.consume_literal("table_def") - _t2185 = self.parse_relation_id() - relation_id1401 = _t2185 + _t2197 = self.parse_relation_id() + relation_id1407 = _t2197 self.consume_literal(")") - result1403 = relation_id1401 - self.record_span(span_start1402, "RelationId") - return result1403 ->>>>>>> origin/main + result1409 = relation_id1407 + self.record_span(span_start1408, "RelationId") + return result1409 def parse_iceberg_table_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("table_properties") -<<<<<<< HEAD - xs1336 = [] - cond1337 = self.match_lookahead_literal("(", 0) - while cond1337: - _t2099 = self.parse_iceberg_property_entry() - item1338 = _t2099 - xs1336.append(item1338) - cond1337 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1339 = xs1336 - self.consume_literal(")") - return iceberg_property_entrys1339 -======= - xs1404 = [] - cond1405 = self.match_lookahead_literal("(", 0) - while cond1405: - _t2186 = self.parse_iceberg_property_entry() - item1406 = _t2186 - xs1404.append(item1406) - cond1405 = self.match_lookahead_literal("(", 0) - iceberg_property_entrys1407 = xs1404 - self.consume_literal(")") - return iceberg_property_entrys1407 ->>>>>>> origin/main + 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 + self.consume_literal(")") + return iceberg_property_entrys1413 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 0ce09494..a0863d46 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -216,39 +216,11 @@ def write_debug_info(self) -> None: # --- Helper functions --- -<<<<<<< HEAD - 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: - _t1755 = logic_pb2.Value(int32_value=v) - return _t1755 - - def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1756 = logic_pb2.Value(int_value=v) - return _t1756 - - def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1757 = logic_pb2.Value(float_value=v) - return _t1757 - - def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1758 = logic_pb2.Value(string_value=v) - return _t1758 - - def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1759 = logic_pb2.Value(boolean_value=v) - return _t1759 - - def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1760 = logic_pb2.Value(uint128_value=v) - return _t1760 -======= def deconstruct_csv_data_columns_optional(self, msg: logic_pb2.CSVData) -> Sequence[logic_pb2.GNFColumn] | None: if msg.HasField("relations"): return None else: - _t1832 = None + _t1845 = None return msg.columns def deconstruct_csv_data_relations_optional(self, msg: logic_pb2.CSVData) -> logic_pb2.TargetRelations | None: @@ -256,285 +228,166 @@ def deconstruct_csv_data_relations_optional(self, msg: logic_pb2.CSVData) -> log assert msg.relations is not None return msg.relations else: - _t1833 = None + _t1846 = 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: - _t1834 = logic_pb2.Value(int32_value=v) - return _t1834 + _t1847 = logic_pb2.Value(int32_value=v) + return _t1847 def _make_value_int64(self, v: int) -> logic_pb2.Value: - _t1835 = logic_pb2.Value(int_value=v) - return _t1835 + _t1848 = logic_pb2.Value(int_value=v) + return _t1848 def _make_value_float64(self, v: float) -> logic_pb2.Value: - _t1836 = logic_pb2.Value(float_value=v) - return _t1836 + _t1849 = logic_pb2.Value(float_value=v) + return _t1849 def _make_value_string(self, v: str) -> logic_pb2.Value: - _t1837 = logic_pb2.Value(string_value=v) - return _t1837 + _t1850 = logic_pb2.Value(string_value=v) + return _t1850 def _make_value_boolean(self, v: bool) -> logic_pb2.Value: - _t1838 = logic_pb2.Value(boolean_value=v) - return _t1838 + _t1851 = logic_pb2.Value(boolean_value=v) + return _t1851 def _make_value_uint128(self, v: logic_pb2.UInt128Value) -> logic_pb2.Value: - _t1839 = logic_pb2.Value(uint128_value=v) - return _t1839 ->>>>>>> origin/main + _t1852 = logic_pb2.Value(uint128_value=v) + return _t1852 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: -<<<<<<< HEAD - _t1761 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1761,)) - else: - if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1762 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1762,)) - else: - if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1763 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1763,)) - _t1764 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1764,)) -======= - _t1840 = self._make_value_string("auto") - result.append(("ivm.maintenance_level", _t1840,)) + _t1853 = self._make_value_string("auto") + result.append(("ivm.maintenance_level", _t1853,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_ALL: - _t1841 = self._make_value_string("all") - result.append(("ivm.maintenance_level", _t1841,)) + _t1854 = self._make_value_string("all") + result.append(("ivm.maintenance_level", _t1854,)) else: if msg.ivm_config.level == transactions_pb2.MaintenanceLevel.MAINTENANCE_LEVEL_OFF: - _t1842 = self._make_value_string("off") - result.append(("ivm.maintenance_level", _t1842,)) - _t1843 = self._make_value_int64(msg.semantics_version) - result.append(("semantics_version", _t1843,)) ->>>>>>> origin/main + _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,)) return sorted(result) def deconstruct_csv_config(self, msg: logic_pb2.CSVConfig) -> list[tuple[str, logic_pb2.Value]]: result = [] -<<<<<<< HEAD - _t1765 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1765,)) - _t1766 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1766,)) - if msg.new_line != "": - _t1767 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1767,)) - _t1768 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1768,)) - _t1769 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1769,)) - _t1770 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1770,)) - if msg.comment != "": - _t1771 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1771,)) - for missing_string in msg.missing_strings: - _t1772 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1772,)) - _t1773 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1773,)) - _t1774 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1774,)) - _t1775 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1775,)) - if msg.partition_size_mb != 0: - _t1776 = self._make_value_int64(msg.partition_size_mb) - result.append(("csv_partition_size_mb", _t1776,)) -======= - _t1844 = self._make_value_int32(msg.header_row) - result.append(("csv_header_row", _t1844,)) - _t1845 = self._make_value_int64(msg.skip) - result.append(("csv_skip", _t1845,)) + _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,)) if msg.new_line != "": - _t1846 = self._make_value_string(msg.new_line) - result.append(("csv_new_line", _t1846,)) - _t1847 = self._make_value_string(msg.delimiter) - result.append(("csv_delimiter", _t1847,)) - _t1848 = self._make_value_string(msg.quotechar) - result.append(("csv_quotechar", _t1848,)) - _t1849 = self._make_value_string(msg.escapechar) - result.append(("csv_escapechar", _t1849,)) + _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,)) if msg.comment != "": - _t1850 = self._make_value_string(msg.comment) - result.append(("csv_comment", _t1850,)) + _t1863 = self._make_value_string(msg.comment) + result.append(("csv_comment", _t1863,)) for missing_string in msg.missing_strings: - _t1851 = self._make_value_string(missing_string) - result.append(("csv_missing_strings", _t1851,)) - _t1852 = self._make_value_string(msg.decimal_separator) - result.append(("csv_decimal_separator", _t1852,)) - _t1853 = self._make_value_string(msg.encoding) - result.append(("csv_encoding", _t1853,)) - _t1854 = self._make_value_string(msg.compression) - result.append(("csv_compression", _t1854,)) + _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,)) if msg.partition_size_mb != 0: - _t1855 = self._make_value_int64(msg.partition_size_mb) - result.append(("csv_partition_size_mb", _t1855,)) ->>>>>>> origin/main + _t1868 = self._make_value_int64(msg.partition_size_mb) + result.append(("csv_partition_size_mb", _t1868,)) 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: -<<<<<<< HEAD - _t1777 = None -======= - _t1856 = None ->>>>>>> origin/main + _t1869 = None assert msg.storage_integration is not None si = msg.storage_integration result = [] if si.provider != "": -<<<<<<< HEAD - _t1778 = self._make_value_string(si.provider) - result.append(("provider", _t1778,)) - if si.azure_sas_token != "": - _t1779 = self._make_value_string("***") - result.append(("azure_sas_token", _t1779,)) - if si.s3_region != "": - _t1780 = self._make_value_string(si.s3_region) - result.append(("s3_region", _t1780,)) - if si.s3_access_key_id != "": - _t1781 = self._make_value_string("***") - result.append(("s3_access_key_id", _t1781,)) - if si.s3_secret_access_key != "": - _t1782 = self._make_value_string("***") - result.append(("s3_secret_access_key", _t1782,)) -======= - _t1857 = self._make_value_string(si.provider) - result.append(("provider", _t1857,)) + _t1870 = self._make_value_string(si.provider) + result.append(("provider", _t1870,)) if si.azure_sas_token != "": - _t1858 = self._make_value_string("***") - result.append(("azure_sas_token", _t1858,)) + _t1871 = self._make_value_string("***") + result.append(("azure_sas_token", _t1871,)) if si.s3_region != "": - _t1859 = self._make_value_string(si.s3_region) - result.append(("s3_region", _t1859,)) + _t1872 = self._make_value_string(si.s3_region) + result.append(("s3_region", _t1872,)) if si.s3_access_key_id != "": - _t1860 = self._make_value_string("***") - result.append(("s3_access_key_id", _t1860,)) + _t1873 = self._make_value_string("***") + result.append(("s3_access_key_id", _t1873,)) if si.s3_secret_access_key != "": - _t1861 = self._make_value_string("***") - result.append(("s3_secret_access_key", _t1861,)) ->>>>>>> origin/main + _t1874 = self._make_value_string("***") + result.append(("s3_secret_access_key", _t1874,)) return sorted(result) def deconstruct_betree_info_config(self, msg: logic_pb2.BeTreeInfo) -> list[tuple[str, logic_pb2.Value]]: result = [] -<<<<<<< HEAD - _t1783 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1783,)) - _t1784 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1784,)) - _t1785 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1785,)) - _t1786 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1786,)) - 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 - _t1787 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1787,)) - 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 - _t1788 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1788,)) - _t1789 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1789,)) - _t1790 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1790,)) -======= - _t1862 = self._make_value_float64(msg.storage_config.epsilon) - result.append(("betree_config_epsilon", _t1862,)) - _t1863 = self._make_value_int64(msg.storage_config.max_pivots) - result.append(("betree_config_max_pivots", _t1863,)) - _t1864 = self._make_value_int64(msg.storage_config.max_deltas) - result.append(("betree_config_max_deltas", _t1864,)) - _t1865 = self._make_value_int64(msg.storage_config.max_leaf) - result.append(("betree_config_max_leaf", _t1865,)) + _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,)) 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 - _t1866 = self._make_value_uint128(msg.relation_locator.root_pageid) - result.append(("betree_locator_root_pageid", _t1866,)) + _t1879 = self._make_value_uint128(msg.relation_locator.root_pageid) + result.append(("betree_locator_root_pageid", _t1879,)) 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 - _t1867 = self._make_value_string(msg.relation_locator.inline_data.decode('utf-8')) - result.append(("betree_locator_inline_data", _t1867,)) - _t1868 = self._make_value_int64(msg.relation_locator.element_count) - result.append(("betree_locator_element_count", _t1868,)) - _t1869 = self._make_value_int64(msg.relation_locator.tree_height) - result.append(("betree_locator_tree_height", _t1869,)) ->>>>>>> origin/main + _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,)) 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 -<<<<<<< HEAD - _t1791 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1791,)) - if msg.compression is not None: - assert msg.compression is not None - _t1792 = self._make_value_string(msg.compression) - result.append(("compression", _t1792,)) - if msg.syntax_header_row is not None: - assert msg.syntax_header_row is not None - _t1793 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1793,)) - if msg.syntax_missing_string is not None: - assert msg.syntax_missing_string is not None - _t1794 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1794,)) - if msg.syntax_delim is not None: - assert msg.syntax_delim is not None - _t1795 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1795,)) - if msg.syntax_quotechar is not None: - assert msg.syntax_quotechar is not None - _t1796 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1796,)) - if msg.syntax_escapechar is not None: - assert msg.syntax_escapechar is not None - _t1797 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1797,)) -======= - _t1870 = self._make_value_int64(msg.partition_size) - result.append(("partition_size", _t1870,)) + _t1883 = self._make_value_int64(msg.partition_size) + result.append(("partition_size", _t1883,)) if msg.compression is not None: assert msg.compression is not None - _t1871 = self._make_value_string(msg.compression) - result.append(("compression", _t1871,)) + _t1884 = self._make_value_string(msg.compression) + result.append(("compression", _t1884,)) if msg.syntax_header_row is not None: assert msg.syntax_header_row is not None - _t1872 = self._make_value_boolean(msg.syntax_header_row) - result.append(("syntax_header_row", _t1872,)) + _t1885 = self._make_value_boolean(msg.syntax_header_row) + result.append(("syntax_header_row", _t1885,)) if msg.syntax_missing_string is not None: assert msg.syntax_missing_string is not None - _t1873 = self._make_value_string(msg.syntax_missing_string) - result.append(("syntax_missing_string", _t1873,)) + _t1886 = self._make_value_string(msg.syntax_missing_string) + result.append(("syntax_missing_string", _t1886,)) if msg.syntax_delim is not None: assert msg.syntax_delim is not None - _t1874 = self._make_value_string(msg.syntax_delim) - result.append(("syntax_delim", _t1874,)) + _t1887 = self._make_value_string(msg.syntax_delim) + result.append(("syntax_delim", _t1887,)) if msg.syntax_quotechar is not None: assert msg.syntax_quotechar is not None - _t1875 = self._make_value_string(msg.syntax_quotechar) - result.append(("syntax_quotechar", _t1875,)) + _t1888 = self._make_value_string(msg.syntax_quotechar) + result.append(("syntax_quotechar", _t1888,)) if msg.syntax_escapechar is not None: assert msg.syntax_escapechar is not None - _t1876 = self._make_value_string(msg.syntax_escapechar) - result.append(("syntax_escapechar", _t1876,)) ->>>>>>> origin/main + _t1889 = self._make_value_string(msg.syntax_escapechar) + result.append(("syntax_escapechar", _t1889,)) return sorted(result) def mask_secret_value(self, pair: tuple[str, str]) -> str: @@ -546,11 +399,7 @@ def deconstruct_iceberg_catalog_config_scope_optional(self, msg: logic_pb2.Icebe assert msg.scope is not None return msg.scope else: -<<<<<<< HEAD - _t1798 = None -======= - _t1877 = None ->>>>>>> origin/main + _t1890 = None return None def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -559,11 +408,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: -<<<<<<< HEAD - _t1799 = None -======= - _t1878 = None ->>>>>>> origin/main + _t1891 = None return None def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -572,11 +417,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: -<<<<<<< HEAD - _t1800 = None -======= - _t1879 = None ->>>>>>> origin/main + _t1892 = None return None def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.ExportIcebergConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: @@ -584,37 +425,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 -<<<<<<< HEAD - _t1801 = self._make_value_string(msg.prefix) - result.append(("prefix", _t1801,)) - 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 - _t1802 = self._make_value_int64(msg.target_file_size_bytes) - result.append(("target_file_size_bytes", _t1802,)) - if msg.compression != "": - _t1803 = self._make_value_string(msg.compression) - result.append(("compression", _t1803,)) - if len(result) == 0: - return None - else: - _t1804 = None -======= - _t1880 = self._make_value_string(msg.prefix) - result.append(("prefix", _t1880,)) + _t1893 = self._make_value_string(msg.prefix) + result.append(("prefix", _t1893,)) 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 - _t1881 = self._make_value_int64(msg.target_file_size_bytes) - result.append(("target_file_size_bytes", _t1881,)) + _t1894 = self._make_value_int64(msg.target_file_size_bytes) + result.append(("target_file_size_bytes", _t1894,)) if msg.compression != "": - _t1882 = self._make_value_string(msg.compression) - result.append(("compression", _t1882,)) + _t1895 = self._make_value_string(msg.compression) + result.append(("compression", _t1895,)) if len(result) == 0: return None else: - _t1883 = None ->>>>>>> origin/main + _t1896 = None return sorted(result) def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: @@ -627,11 +451,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: -<<<<<<< HEAD - _t1805 = None -======= - _t1884 = None ->>>>>>> origin/main + _t1897 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -646,7998 +466,4164 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): -<<<<<<< HEAD - flat813 = self._try_flat(msg, self.pretty_transaction) - if flat813 is not None: - assert flat813 is not None - self.write(flat813) -======= - flat851 = self._try_flat(msg, self.pretty_transaction) - if flat851 is not None: - assert flat851 is not None - self.write(flat851) ->>>>>>> origin/main + flat856 = self._try_flat(msg, self.pretty_transaction) + if flat856 is not None: + assert flat856 is not None + self.write(flat856) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("configure"): -<<<<<<< HEAD - _t1608 = _dollar_dollar.configure - else: - _t1608 = None - if _dollar_dollar.HasField("sync"): - _t1609 = _dollar_dollar.sync + _t1694 = _dollar_dollar.configure else: - _t1609 = None - fields804 = (_t1608, _t1609, _dollar_dollar.epochs,) - assert fields804 is not None - unwrapped_fields805 = fields804 - self.write("(transaction") - self.indent_sexp() - field806 = unwrapped_fields805[0] - if field806 is not None: - self.newline() - assert field806 is not None - opt_val807 = field806 - self.pretty_configure(opt_val807) - field808 = unwrapped_fields805[1] - if field808 is not None: - self.newline() - assert field808 is not None - opt_val809 = field808 - self.pretty_sync(opt_val809) - field810 = unwrapped_fields805[2] - if not len(field810) == 0: - self.newline() - for i812, elem811 in enumerate(field810): - if (i812 > 0): - self.newline() - self.pretty_epoch(elem811) -======= - _t1684 = _dollar_dollar.configure - else: - _t1684 = None + _t1694 = None if _dollar_dollar.HasField("sync"): - _t1685 = _dollar_dollar.sync + _t1695 = _dollar_dollar.sync else: - _t1685 = None - fields842 = (_t1684, _t1685, _dollar_dollar.epochs,) - assert fields842 is not None - unwrapped_fields843 = fields842 + _t1695 = None + fields847 = (_t1694, _t1695, _dollar_dollar.epochs,) + assert fields847 is not None + unwrapped_fields848 = fields847 self.write("(transaction") self.indent_sexp() - field844 = unwrapped_fields843[0] - if field844 is not None: + field849 = unwrapped_fields848[0] + if field849 is not None: self.newline() - assert field844 is not None - opt_val845 = field844 - self.pretty_configure(opt_val845) - field846 = unwrapped_fields843[1] - if field846 is not None: + assert field849 is not None + opt_val850 = field849 + self.pretty_configure(opt_val850) + field851 = unwrapped_fields848[1] + if field851 is not None: self.newline() - assert field846 is not None - opt_val847 = field846 - self.pretty_sync(opt_val847) - field848 = unwrapped_fields843[2] - if not len(field848) == 0: + assert field851 is not None + opt_val852 = field851 + self.pretty_sync(opt_val852) + field853 = unwrapped_fields848[2] + if not len(field853) == 0: self.newline() - for i850, elem849 in enumerate(field848): - if (i850 > 0): + for i855, elem854 in enumerate(field853): + if (i855 > 0): self.newline() - self.pretty_epoch(elem849) ->>>>>>> origin/main + self.pretty_epoch(elem854) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): -<<<<<<< HEAD - flat816 = self._try_flat(msg, self.pretty_configure) - if flat816 is not None: - assert flat816 is not None - self.write(flat816) - return None - else: - _dollar_dollar = msg - _t1610 = self.deconstruct_configure(_dollar_dollar) - fields814 = _t1610 - assert fields814 is not None - unwrapped_fields815 = fields814 - self.write("(configure") - self.indent_sexp() - self.newline() - self.pretty_config_dict(unwrapped_fields815) -======= - flat854 = self._try_flat(msg, self.pretty_configure) - if flat854 is not None: - assert flat854 is not None - self.write(flat854) + flat859 = self._try_flat(msg, self.pretty_configure) + if flat859 is not None: + assert flat859 is not None + self.write(flat859) return None else: _dollar_dollar = msg - _t1686 = self.deconstruct_configure(_dollar_dollar) - fields852 = _t1686 - assert fields852 is not None - unwrapped_fields853 = fields852 + _t1696 = self.deconstruct_configure(_dollar_dollar) + fields857 = _t1696 + assert fields857 is not None + unwrapped_fields858 = fields857 self.write("(configure") self.indent_sexp() self.newline() - self.pretty_config_dict(unwrapped_fields853) ->>>>>>> origin/main + self.pretty_config_dict(unwrapped_fields858) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): -<<<<<<< HEAD - flat820 = self._try_flat(msg, self.pretty_config_dict) - if flat820 is not None: - assert flat820 is not None - self.write(flat820) - return None - else: - fields817 = msg - self.write("{") - self.indent() - if not len(fields817) == 0: - self.newline() - for i819, elem818 in enumerate(fields817): - if (i819 > 0): - self.newline() - self.pretty_config_key_value(elem818) -======= - flat858 = self._try_flat(msg, self.pretty_config_dict) - if flat858 is not None: - assert flat858 is not None - self.write(flat858) + flat863 = self._try_flat(msg, self.pretty_config_dict) + if flat863 is not None: + assert flat863 is not None + self.write(flat863) return None else: - fields855 = msg + fields860 = msg self.write("{") self.indent() - if not len(fields855) == 0: + if not len(fields860) == 0: self.newline() - for i857, elem856 in enumerate(fields855): - if (i857 > 0): + for i862, elem861 in enumerate(fields860): + if (i862 > 0): self.newline() - self.pretty_config_key_value(elem856) ->>>>>>> origin/main + self.pretty_config_key_value(elem861) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): -<<<<<<< HEAD - flat825 = self._try_flat(msg, self.pretty_config_key_value) - if flat825 is not None: - assert flat825 is not None - self.write(flat825) + flat868 = self._try_flat(msg, self.pretty_config_key_value) + if flat868 is not None: + assert flat868 is not None + self.write(flat868) return None else: _dollar_dollar = msg - fields821 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields821 is not None - unwrapped_fields822 = fields821 + fields864 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields864 is not None + unwrapped_fields865 = fields864 self.write(":") - field823 = unwrapped_fields822[0] - self.write(field823) + field866 = unwrapped_fields865[0] + self.write(field866) self.write(" ") - field824 = unwrapped_fields822[1] - self.pretty_raw_value(field824) + field867 = unwrapped_fields865[1] + self.pretty_raw_value(field867) def pretty_raw_value(self, msg: logic_pb2.Value): - flat851 = self._try_flat(msg, self.pretty_raw_value) - if flat851 is not None: - assert flat851 is not None - self.write(flat851) + flat894 = self._try_flat(msg, self.pretty_raw_value) + if flat894 is not None: + assert flat894 is not None + self.write(flat894) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("date_value"): - _t1611 = _dollar_dollar.date_value + _t1697 = _dollar_dollar.date_value else: - _t1611 = None - deconstruct_result849 = _t1611 - if deconstruct_result849 is not None: - assert deconstruct_result849 is not None - unwrapped850 = deconstruct_result849 - self.pretty_raw_date(unwrapped850) + _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) else: _dollar_dollar = msg if _dollar_dollar.HasField("datetime_value"): - _t1612 = _dollar_dollar.datetime_value + _t1698 = _dollar_dollar.datetime_value else: - _t1612 = None - deconstruct_result847 = _t1612 - if deconstruct_result847 is not None: - assert deconstruct_result847 is not None - unwrapped848 = deconstruct_result847 - self.pretty_raw_datetime(unwrapped848) + _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) else: _dollar_dollar = msg if _dollar_dollar.HasField("string_value"): - _t1613 = _dollar_dollar.string_value + _t1699 = _dollar_dollar.string_value else: - _t1613 = None - deconstruct_result845 = _t1613 - if deconstruct_result845 is not None: - assert deconstruct_result845 is not None - unwrapped846 = deconstruct_result845 - self.write(self.format_string_value(unwrapped846)) + _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)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int32_value"): - _t1614 = _dollar_dollar.int32_value + _t1700 = _dollar_dollar.int32_value else: - _t1614 = None - deconstruct_result843 = _t1614 - if deconstruct_result843 is not None: - assert deconstruct_result843 is not None - unwrapped844 = deconstruct_result843 - self.write((str(unwrapped844) + 'i32')) + _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')) else: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1615 = _dollar_dollar.int_value + _t1701 = _dollar_dollar.int_value else: - _t1615 = None - deconstruct_result841 = _t1615 - if deconstruct_result841 is not None: - assert deconstruct_result841 is not None - unwrapped842 = deconstruct_result841 - self.write(str(unwrapped842)) + _t1701 = None + deconstruct_result884 = _t1701 + if deconstruct_result884 is not None: + assert deconstruct_result884 is not None + unwrapped885 = deconstruct_result884 + self.write(str(unwrapped885)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float32_value"): - _t1616 = _dollar_dollar.float32_value + _t1702 = _dollar_dollar.float32_value else: - _t1616 = None - deconstruct_result839 = _t1616 - if deconstruct_result839 is not None: - assert deconstruct_result839 is not None - unwrapped840 = deconstruct_result839 - self.write(self.format_float32_literal(unwrapped840)) + _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)) else: _dollar_dollar = msg if _dollar_dollar.HasField("float_value"): - _t1617 = _dollar_dollar.float_value + _t1703 = _dollar_dollar.float_value else: - _t1617 = None - deconstruct_result837 = _t1617 - if deconstruct_result837 is not None: - assert deconstruct_result837 is not None - unwrapped838 = deconstruct_result837 - self.write(str(unwrapped838)) + _t1703 = None + deconstruct_result880 = _t1703 + if deconstruct_result880 is not None: + assert deconstruct_result880 is not None + unwrapped881 = deconstruct_result880 + self.write(str(unwrapped881)) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint32_value"): - _t1618 = _dollar_dollar.uint32_value + _t1704 = _dollar_dollar.uint32_value else: - _t1618 = None - deconstruct_result835 = _t1618 - if deconstruct_result835 is not None: - assert deconstruct_result835 is not None - unwrapped836 = deconstruct_result835 - self.write((str(unwrapped836) + 'u32')) + _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')) else: _dollar_dollar = msg if _dollar_dollar.HasField("uint128_value"): - _t1619 = _dollar_dollar.uint128_value + _t1705 = _dollar_dollar.uint128_value else: - _t1619 = None - deconstruct_result833 = _t1619 - if deconstruct_result833 is not None: - assert deconstruct_result833 is not None - unwrapped834 = deconstruct_result833 - self.write(self.format_uint128(unwrapped834)) + _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)) else: _dollar_dollar = msg if _dollar_dollar.HasField("int128_value"): - _t1620 = _dollar_dollar.int128_value + _t1706 = _dollar_dollar.int128_value else: - _t1620 = None - deconstruct_result831 = _t1620 - if deconstruct_result831 is not None: - assert deconstruct_result831 is not None - unwrapped832 = deconstruct_result831 - self.write(self.format_int128(unwrapped832)) + _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)) else: _dollar_dollar = msg if _dollar_dollar.HasField("decimal_value"): - _t1621 = _dollar_dollar.decimal_value + _t1707 = _dollar_dollar.decimal_value else: - _t1621 = None - deconstruct_result829 = _t1621 - if deconstruct_result829 is not None: - assert deconstruct_result829 is not None - unwrapped830 = deconstruct_result829 - self.write(self.format_decimal(unwrapped830)) + _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)) else: _dollar_dollar = msg if _dollar_dollar.HasField("boolean_value"): - _t1622 = _dollar_dollar.boolean_value + _t1708 = _dollar_dollar.boolean_value else: - _t1622 = None - deconstruct_result827 = _t1622 - if deconstruct_result827 is not None: - assert deconstruct_result827 is not None - unwrapped828 = deconstruct_result827 - self.pretty_boolean_value(unwrapped828) + _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) else: - fields826 = msg + fields869 = msg self.write("missing") def pretty_raw_date(self, msg: logic_pb2.DateValue): - flat857 = self._try_flat(msg, self.pretty_raw_date) - if flat857 is not None: - assert flat857 is not None - self.write(flat857) + flat900 = self._try_flat(msg, self.pretty_raw_date) + if flat900 is not None: + assert flat900 is not None + self.write(flat900) return None else: _dollar_dollar = msg - fields852 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields852 is not None - unwrapped_fields853 = fields852 + fields895 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields895 is not None + unwrapped_fields896 = fields895 self.write("(date") self.indent_sexp() self.newline() - field854 = unwrapped_fields853[0] - self.write(str(field854)) + field897 = unwrapped_fields896[0] + self.write(str(field897)) self.newline() - field855 = unwrapped_fields853[1] - self.write(str(field855)) + field898 = unwrapped_fields896[1] + self.write(str(field898)) self.newline() - field856 = unwrapped_fields853[2] - self.write(str(field856)) + field899 = unwrapped_fields896[2] + self.write(str(field899)) self.dedent() self.write(")") def pretty_raw_datetime(self, msg: logic_pb2.DateTimeValue): - flat868 = self._try_flat(msg, self.pretty_raw_datetime) - if flat868 is not None: - assert flat868 is not None - self.write(flat868) + flat911 = self._try_flat(msg, self.pretty_raw_datetime) + if flat911 is not None: + assert flat911 is not None + self.write(flat911) return None else: _dollar_dollar = msg - fields858 = (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 fields858 is not None - unwrapped_fields859 = fields858 + 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 self.write("(datetime") self.indent_sexp() self.newline() - field860 = unwrapped_fields859[0] - self.write(str(field860)) + field903 = unwrapped_fields902[0] + self.write(str(field903)) self.newline() - field861 = unwrapped_fields859[1] - self.write(str(field861)) + field904 = unwrapped_fields902[1] + self.write(str(field904)) self.newline() - field862 = unwrapped_fields859[2] - self.write(str(field862)) + field905 = unwrapped_fields902[2] + self.write(str(field905)) self.newline() - field863 = unwrapped_fields859[3] - self.write(str(field863)) + field906 = unwrapped_fields902[3] + self.write(str(field906)) self.newline() - field864 = unwrapped_fields859[4] - self.write(str(field864)) + field907 = unwrapped_fields902[4] + self.write(str(field907)) self.newline() - field865 = unwrapped_fields859[5] - self.write(str(field865)) - field866 = unwrapped_fields859[6] - if field866 is not None: + field908 = unwrapped_fields902[5] + self.write(str(field908)) + field909 = unwrapped_fields902[6] + if field909 is not None: self.newline() - assert field866 is not None - opt_val867 = field866 - self.write(str(opt_val867)) + assert field909 is not None + opt_val910 = field909 + self.write(str(opt_val910)) self.dedent() self.write(")") def pretty_boolean_value(self, msg: bool): _dollar_dollar = msg if _dollar_dollar: - _t1623 = () + _t1709 = () else: - _t1623 = None - deconstruct_result871 = _t1623 - if deconstruct_result871 is not None: - assert deconstruct_result871 is not None - unwrapped872 = deconstruct_result871 + _t1709 = None + deconstruct_result914 = _t1709 + if deconstruct_result914 is not None: + assert deconstruct_result914 is not None + unwrapped915 = deconstruct_result914 self.write("true") else: _dollar_dollar = msg if not _dollar_dollar: - _t1624 = () + _t1710 = () else: - _t1624 = None - deconstruct_result869 = _t1624 - if deconstruct_result869 is not None: - assert deconstruct_result869 is not None - unwrapped870 = deconstruct_result869 + _t1710 = None + deconstruct_result912 = _t1710 + if deconstruct_result912 is not None: + assert deconstruct_result912 is not None + unwrapped913 = deconstruct_result912 self.write("false") else: raise ParseError("No matching rule for boolean_value") def pretty_sync(self, msg: transactions_pb2.Sync): - flat877 = self._try_flat(msg, self.pretty_sync) - if flat877 is not None: - assert flat877 is not None - self.write(flat877) + flat920 = self._try_flat(msg, self.pretty_sync) + if flat920 is not None: + assert flat920 is not None + self.write(flat920) return None else: _dollar_dollar = msg - fields873 = _dollar_dollar.fragments - assert fields873 is not None - unwrapped_fields874 = fields873 + fields916 = _dollar_dollar.fragments + assert fields916 is not None + unwrapped_fields917 = fields916 self.write("(sync") self.indent_sexp() - if not len(unwrapped_fields874) == 0: + if not len(unwrapped_fields917) == 0: self.newline() - for i876, elem875 in enumerate(unwrapped_fields874): - if (i876 > 0): + for i919, elem918 in enumerate(unwrapped_fields917): + if (i919 > 0): self.newline() - self.pretty_fragment_id(elem875) + self.pretty_fragment_id(elem918) self.dedent() self.write(")") def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat880 = self._try_flat(msg, self.pretty_fragment_id) - if flat880 is not None: - assert flat880 is not None - self.write(flat880) + flat923 = self._try_flat(msg, self.pretty_fragment_id) + if flat923 is not None: + assert flat923 is not None + self.write(flat923) return None else: _dollar_dollar = msg - fields878 = self.fragment_id_to_string(_dollar_dollar) - assert fields878 is not None - unwrapped_fields879 = fields878 + fields921 = self.fragment_id_to_string(_dollar_dollar) + assert fields921 is not None + unwrapped_fields922 = fields921 self.write(":") - self.write(unwrapped_fields879) + self.write(unwrapped_fields922) def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat887 = self._try_flat(msg, self.pretty_epoch) - if flat887 is not None: - assert flat887 is not None - self.write(flat887) + flat930 = self._try_flat(msg, self.pretty_epoch) + if flat930 is not None: + assert flat930 is not None + self.write(flat930) return None else: _dollar_dollar = msg if not len(_dollar_dollar.writes) == 0: - _t1625 = _dollar_dollar.writes + _t1711 = _dollar_dollar.writes else: - _t1625 = None + _t1711 = None if not len(_dollar_dollar.reads) == 0: - _t1626 = _dollar_dollar.reads + _t1712 = _dollar_dollar.reads else: - _t1626 = None - fields881 = (_t1625, _t1626,) - assert fields881 is not None - unwrapped_fields882 = fields881 + _t1712 = None + fields924 = (_t1711, _t1712,) + assert fields924 is not None + unwrapped_fields925 = fields924 self.write("(epoch") self.indent_sexp() - field883 = unwrapped_fields882[0] - if field883 is not None: + field926 = unwrapped_fields925[0] + if field926 is not None: self.newline() - assert field883 is not None - opt_val884 = field883 - self.pretty_epoch_writes(opt_val884) - field885 = unwrapped_fields882[1] - if field885 is not None: + assert field926 is not None + opt_val927 = field926 + self.pretty_epoch_writes(opt_val927) + field928 = unwrapped_fields925[1] + if field928 is not None: self.newline() - assert field885 is not None - opt_val886 = field885 - self.pretty_epoch_reads(opt_val886) + assert field928 is not None + opt_val929 = field928 + self.pretty_epoch_reads(opt_val929) self.dedent() self.write(")") def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat891 = self._try_flat(msg, self.pretty_epoch_writes) - if flat891 is not None: - assert flat891 is not None - self.write(flat891) + flat934 = self._try_flat(msg, self.pretty_epoch_writes) + if flat934 is not None: + assert flat934 is not None + self.write(flat934) return None else: - fields888 = msg + fields931 = msg self.write("(writes") self.indent_sexp() - if not len(fields888) == 0: + if not len(fields931) == 0: self.newline() - for i890, elem889 in enumerate(fields888): - if (i890 > 0): + for i933, elem932 in enumerate(fields931): + if (i933 > 0): self.newline() - self.pretty_write(elem889) + self.pretty_write(elem932) self.dedent() self.write(")") def pretty_write(self, msg: transactions_pb2.Write): - flat900 = self._try_flat(msg, self.pretty_write) - if flat900 is not None: - assert flat900 is not None - self.write(flat900) + flat943 = self._try_flat(msg, self.pretty_write) + if flat943 is not None: + assert flat943 is not None + self.write(flat943) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("define"): - _t1627 = _dollar_dollar.define + _t1713 = _dollar_dollar.define else: - _t1627 = None - deconstruct_result898 = _t1627 - if deconstruct_result898 is not None: - assert deconstruct_result898 is not None - unwrapped899 = deconstruct_result898 - self.pretty_define(unwrapped899) + _t1713 = None + deconstruct_result941 = _t1713 + if deconstruct_result941 is not None: + assert deconstruct_result941 is not None + unwrapped942 = deconstruct_result941 + self.pretty_define(unwrapped942) else: _dollar_dollar = msg if _dollar_dollar.HasField("undefine"): - _t1628 = _dollar_dollar.undefine + _t1714 = _dollar_dollar.undefine else: - _t1628 = None - deconstruct_result896 = _t1628 - if deconstruct_result896 is not None: - assert deconstruct_result896 is not None - unwrapped897 = deconstruct_result896 - self.pretty_undefine(unwrapped897) + _t1714 = None + deconstruct_result939 = _t1714 + if deconstruct_result939 is not None: + assert deconstruct_result939 is not None + unwrapped940 = deconstruct_result939 + self.pretty_undefine(unwrapped940) else: _dollar_dollar = msg if _dollar_dollar.HasField("context"): - _t1629 = _dollar_dollar.context + _t1715 = _dollar_dollar.context else: - _t1629 = None - deconstruct_result894 = _t1629 - if deconstruct_result894 is not None: - assert deconstruct_result894 is not None - unwrapped895 = deconstruct_result894 - self.pretty_context(unwrapped895) + _t1715 = None + deconstruct_result937 = _t1715 + if deconstruct_result937 is not None: + assert deconstruct_result937 is not None + unwrapped938 = deconstruct_result937 + self.pretty_context(unwrapped938) else: _dollar_dollar = msg if _dollar_dollar.HasField("snapshot"): - _t1630 = _dollar_dollar.snapshot + _t1716 = _dollar_dollar.snapshot else: - _t1630 = None - deconstruct_result892 = _t1630 - if deconstruct_result892 is not None: - assert deconstruct_result892 is not None - unwrapped893 = deconstruct_result892 - self.pretty_snapshot(unwrapped893) + _t1716 = None + deconstruct_result935 = _t1716 + if deconstruct_result935 is not None: + assert deconstruct_result935 is not None + unwrapped936 = deconstruct_result935 + self.pretty_snapshot(unwrapped936) else: raise ParseError("No matching rule for write") def pretty_define(self, msg: transactions_pb2.Define): - flat903 = self._try_flat(msg, self.pretty_define) - if flat903 is not None: - assert flat903 is not None - self.write(flat903) + flat946 = self._try_flat(msg, self.pretty_define) + if flat946 is not None: + assert flat946 is not None + self.write(flat946) return None else: _dollar_dollar = msg - fields901 = _dollar_dollar.fragment - assert fields901 is not None - unwrapped_fields902 = fields901 + fields944 = _dollar_dollar.fragment + assert fields944 is not None + unwrapped_fields945 = fields944 self.write("(define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields902) + self.pretty_fragment(unwrapped_fields945) self.dedent() self.write(")") def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat910 = self._try_flat(msg, self.pretty_fragment) - if flat910 is not None: - assert flat910 is not None - self.write(flat910) + flat953 = self._try_flat(msg, self.pretty_fragment) + if flat953 is not None: + assert flat953 is not None + self.write(flat953) return None else: _dollar_dollar = msg self.start_pretty_fragment(_dollar_dollar) - fields904 = (_dollar_dollar.id, _dollar_dollar.declarations,) - assert fields904 is not None - unwrapped_fields905 = fields904 + fields947 = (_dollar_dollar.id, _dollar_dollar.declarations,) + assert fields947 is not None + unwrapped_fields948 = fields947 self.write("(fragment") self.indent_sexp() self.newline() - field906 = unwrapped_fields905[0] - self.pretty_new_fragment_id(field906) - field907 = unwrapped_fields905[1] - if not len(field907) == 0: + field949 = unwrapped_fields948[0] + self.pretty_new_fragment_id(field949) + field950 = unwrapped_fields948[1] + if not len(field950) == 0: self.newline() - for i909, elem908 in enumerate(field907): - if (i909 > 0): + for i952, elem951 in enumerate(field950): + if (i952 > 0): self.newline() - self.pretty_declaration(elem908) + self.pretty_declaration(elem951) self.dedent() self.write(")") def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat912 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat912 is not None: - assert flat912 is not None - self.write(flat912) + flat955 = self._try_flat(msg, self.pretty_new_fragment_id) + if flat955 is not None: + assert flat955 is not None + self.write(flat955) return None else: - fields911 = msg - self.pretty_fragment_id(fields911) + fields954 = msg + self.pretty_fragment_id(fields954) def pretty_declaration(self, msg: logic_pb2.Declaration): - flat921 = self._try_flat(msg, self.pretty_declaration) - if flat921 is not None: - assert flat921 is not None - self.write(flat921) + flat964 = self._try_flat(msg, self.pretty_declaration) + if flat964 is not None: + assert flat964 is not None + self.write(flat964) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("def"): - _t1631 = getattr(_dollar_dollar, 'def') + _t1717 = getattr(_dollar_dollar, 'def') else: - _t1631 = None - deconstruct_result919 = _t1631 - if deconstruct_result919 is not None: - assert deconstruct_result919 is not None - unwrapped920 = deconstruct_result919 - self.pretty_def(unwrapped920) + _t1717 = None + deconstruct_result962 = _t1717 + if deconstruct_result962 is not None: + assert deconstruct_result962 is not None + unwrapped963 = deconstruct_result962 + self.pretty_def(unwrapped963) else: _dollar_dollar = msg if _dollar_dollar.HasField("algorithm"): - _t1632 = _dollar_dollar.algorithm + _t1718 = _dollar_dollar.algorithm else: - _t1632 = None - deconstruct_result917 = _t1632 - if deconstruct_result917 is not None: - assert deconstruct_result917 is not None - unwrapped918 = deconstruct_result917 - self.pretty_algorithm(unwrapped918) + _t1718 = None + deconstruct_result960 = _t1718 + if deconstruct_result960 is not None: + assert deconstruct_result960 is not None + unwrapped961 = deconstruct_result960 + self.pretty_algorithm(unwrapped961) else: _dollar_dollar = msg if _dollar_dollar.HasField("constraint"): - _t1633 = _dollar_dollar.constraint + _t1719 = _dollar_dollar.constraint else: - _t1633 = None - deconstruct_result915 = _t1633 - if deconstruct_result915 is not None: - assert deconstruct_result915 is not None - unwrapped916 = deconstruct_result915 - self.pretty_constraint(unwrapped916) + _t1719 = None + deconstruct_result958 = _t1719 + if deconstruct_result958 is not None: + assert deconstruct_result958 is not None + unwrapped959 = deconstruct_result958 + self.pretty_constraint(unwrapped959) else: _dollar_dollar = msg if _dollar_dollar.HasField("data"): - _t1634 = _dollar_dollar.data + _t1720 = _dollar_dollar.data else: - _t1634 = None - deconstruct_result913 = _t1634 - if deconstruct_result913 is not None: - assert deconstruct_result913 is not None - unwrapped914 = deconstruct_result913 - self.pretty_data(unwrapped914) + _t1720 = None + deconstruct_result956 = _t1720 + if deconstruct_result956 is not None: + assert deconstruct_result956 is not None + unwrapped957 = deconstruct_result956 + self.pretty_data(unwrapped957) else: raise ParseError("No matching rule for declaration") def pretty_def(self, msg: logic_pb2.Def): - flat928 = self._try_flat(msg, self.pretty_def) - if flat928 is not None: - assert flat928 is not None - self.write(flat928) + flat971 = self._try_flat(msg, self.pretty_def) + if flat971 is not None: + assert flat971 is not None + self.write(flat971) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1635 = _dollar_dollar.attrs + _t1721 = _dollar_dollar.attrs else: - _t1635 = None - fields922 = (_dollar_dollar.name, _dollar_dollar.body, _t1635,) - assert fields922 is not None - unwrapped_fields923 = fields922 + _t1721 = None + fields965 = (_dollar_dollar.name, _dollar_dollar.body, _t1721,) + assert fields965 is not None + unwrapped_fields966 = fields965 self.write("(def") self.indent_sexp() self.newline() - field924 = unwrapped_fields923[0] - self.pretty_relation_id(field924) + field967 = unwrapped_fields966[0] + self.pretty_relation_id(field967) self.newline() - field925 = unwrapped_fields923[1] - self.pretty_abstraction(field925) - field926 = unwrapped_fields923[2] - if field926 is not None: + field968 = unwrapped_fields966[1] + self.pretty_abstraction(field968) + field969 = unwrapped_fields966[2] + if field969 is not None: self.newline() - assert field926 is not None - opt_val927 = field926 - self.pretty_attrs(opt_val927) + assert field969 is not None + opt_val970 = field969 + self.pretty_attrs(opt_val970) self.dedent() self.write(")") def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat933 = self._try_flat(msg, self.pretty_relation_id) - if flat933 is not None: - assert flat933 is not None - self.write(flat933) -======= - flat863 = self._try_flat(msg, self.pretty_config_key_value) - if flat863 is not None: - assert flat863 is not None - self.write(flat863) + flat976 = self._try_flat(msg, self.pretty_relation_id) + if flat976 is not None: + assert flat976 is not None + self.write(flat976) return None else: _dollar_dollar = msg - fields859 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields859 is not None - unwrapped_fields860 = fields859 - self.write(":") - field861 = unwrapped_fields860[0] - self.write(field861) - self.write(" ") - field862 = unwrapped_fields860[1] - self.pretty_raw_value(field862) + if self.relation_id_to_string(_dollar_dollar) is not None: + _t1723 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1722 = _t1723 + else: + _t1722 = None + deconstruct_result974 = _t1722 + if deconstruct_result974 is not None: + assert deconstruct_result974 is not None + unwrapped975 = deconstruct_result974 + self.write(":") + self.write(unwrapped975) + 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)) + else: + raise ParseError("No matching rule for relation_id") - def pretty_raw_value(self, msg: logic_pb2.Value): - flat889 = self._try_flat(msg, self.pretty_raw_value) - if flat889 is not None: - assert flat889 is not None - self.write(flat889) + 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) return None else: _dollar_dollar = msg - if _dollar_dollar.HasField("date_value"): - _t1687 = _dollar_dollar.date_value + _t1725 = self.deconstruct_bindings(_dollar_dollar) + fields977 = (_t1725, _dollar_dollar.value,) + assert fields977 is not None + unwrapped_fields978 = fields977 + self.write("(") + self.indent() + field979 = unwrapped_fields978[0] + self.pretty_bindings(field979) + self.newline() + field980 = unwrapped_fields978[1] + self.pretty_formula(field980) + 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) + return None + else: + _dollar_dollar = msg + if not len(_dollar_dollar[1]) == 0: + _t1726 = _dollar_dollar[1] + else: + _t1726 = None + fields982 = (_dollar_dollar[0], _t1726,) + assert fields982 is not None + unwrapped_fields983 = fields982 + self.write("[") + self.indent() + field984 = unwrapped_fields983[0] + for i986, elem985 in enumerate(field984): + if (i986 > 0): + self.newline() + self.pretty_binding(elem985) + field987 = unwrapped_fields983[1] + if field987 is not None: + self.newline() + assert field987 is not None + opt_val988 = field987 + self.pretty_value_bindings(opt_val988) + 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) + 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) + self.write("::") + field993 = unwrapped_fields991[1] + self.pretty_type(field993) + + 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) + return None + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("unspecified_type"): + _t1727 = _dollar_dollar.unspecified_type else: - _t1687 = None - deconstruct_result887 = _t1687 - if deconstruct_result887 is not None: - assert deconstruct_result887 is not None - unwrapped888 = deconstruct_result887 - self.pretty_raw_date(unwrapped888) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("datetime_value"): - _t1688 = _dollar_dollar.datetime_value + if _dollar_dollar.HasField("string_type"): + _t1728 = _dollar_dollar.string_type else: - _t1688 = None - deconstruct_result885 = _t1688 - if deconstruct_result885 is not None: - assert deconstruct_result885 is not None - unwrapped886 = deconstruct_result885 - self.pretty_raw_datetime(unwrapped886) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("string_value"): - _t1689 = _dollar_dollar.string_value + if _dollar_dollar.HasField("int_type"): + _t1729 = _dollar_dollar.int_type else: - _t1689 = None - deconstruct_result883 = _t1689 - if deconstruct_result883 is not None: - assert deconstruct_result883 is not None - unwrapped884 = deconstruct_result883 - self.write(self.format_string_value(unwrapped884)) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("int32_value"): - _t1690 = _dollar_dollar.int32_value + if _dollar_dollar.HasField("float_type"): + _t1730 = _dollar_dollar.float_type else: - _t1690 = None - deconstruct_result881 = _t1690 - if deconstruct_result881 is not None: - assert deconstruct_result881 is not None - unwrapped882 = deconstruct_result881 - self.write((str(unwrapped882) + 'i32')) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("int_value"): - _t1691 = _dollar_dollar.int_value + if _dollar_dollar.HasField("uint128_type"): + _t1731 = _dollar_dollar.uint128_type else: - _t1691 = None - deconstruct_result879 = _t1691 - if deconstruct_result879 is not None: - assert deconstruct_result879 is not None - unwrapped880 = deconstruct_result879 - self.write(str(unwrapped880)) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("float32_value"): - _t1692 = _dollar_dollar.float32_value + if _dollar_dollar.HasField("int128_type"): + _t1732 = _dollar_dollar.int128_type else: - _t1692 = None - deconstruct_result877 = _t1692 - if deconstruct_result877 is not None: - assert deconstruct_result877 is not None - unwrapped878 = deconstruct_result877 - self.write(self.format_float32_literal(unwrapped878)) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("float_value"): - _t1693 = _dollar_dollar.float_value + if _dollar_dollar.HasField("date_type"): + _t1733 = _dollar_dollar.date_type else: - _t1693 = None - deconstruct_result875 = _t1693 - if deconstruct_result875 is not None: - assert deconstruct_result875 is not None - unwrapped876 = deconstruct_result875 - self.write(str(unwrapped876)) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("uint32_value"): - _t1694 = _dollar_dollar.uint32_value + if _dollar_dollar.HasField("datetime_type"): + _t1734 = _dollar_dollar.datetime_type else: - _t1694 = None - deconstruct_result873 = _t1694 - if deconstruct_result873 is not None: - assert deconstruct_result873 is not None - unwrapped874 = deconstruct_result873 - self.write((str(unwrapped874) + 'u32')) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("uint128_value"): - _t1695 = _dollar_dollar.uint128_value + if _dollar_dollar.HasField("missing_type"): + _t1735 = _dollar_dollar.missing_type else: - _t1695 = None - deconstruct_result871 = _t1695 - if deconstruct_result871 is not None: - assert deconstruct_result871 is not None - unwrapped872 = deconstruct_result871 - self.write(self.format_uint128(unwrapped872)) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("int128_value"): - _t1696 = _dollar_dollar.int128_value + if _dollar_dollar.HasField("decimal_type"): + _t1736 = _dollar_dollar.decimal_type else: - _t1696 = None - deconstruct_result869 = _t1696 - if deconstruct_result869 is not None: - assert deconstruct_result869 is not None - unwrapped870 = deconstruct_result869 - self.write(self.format_int128(unwrapped870)) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("decimal_value"): - _t1697 = _dollar_dollar.decimal_value + if _dollar_dollar.HasField("boolean_type"): + _t1737 = _dollar_dollar.boolean_type else: - _t1697 = None - deconstruct_result867 = _t1697 - if deconstruct_result867 is not None: - assert deconstruct_result867 is not None - unwrapped868 = deconstruct_result867 - self.write(self.format_decimal(unwrapped868)) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("boolean_value"): - _t1698 = _dollar_dollar.boolean_value + if _dollar_dollar.HasField("int32_type"): + _t1738 = _dollar_dollar.int32_type else: - _t1698 = None - deconstruct_result865 = _t1698 - if deconstruct_result865 is not None: - assert deconstruct_result865 is not None - unwrapped866 = deconstruct_result865 - self.pretty_boolean_value(unwrapped866) + _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) else: - fields864 = msg - self.write("missing") - - def pretty_raw_date(self, msg: logic_pb2.DateValue): - flat895 = self._try_flat(msg, self.pretty_raw_date) - if flat895 is not None: - assert flat895 is not None - self.write(flat895) - return None - else: - _dollar_dollar = msg - fields890 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields890 is not None - unwrapped_fields891 = fields890 - self.write("(date") - self.indent_sexp() - self.newline() - field892 = unwrapped_fields891[0] - self.write(str(field892)) - self.newline() - field893 = unwrapped_fields891[1] - self.write(str(field893)) - self.newline() - field894 = unwrapped_fields891[2] - self.write(str(field894)) - self.dedent() - self.write(")") + _dollar_dollar = msg + if _dollar_dollar.HasField("float32_type"): + _t1739 = _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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("uint32_type"): + _t1740 = _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) + else: + raise ParseError("No matching rule for type") - def pretty_raw_datetime(self, msg: logic_pb2.DateTimeValue): - flat906 = self._try_flat(msg, self.pretty_raw_datetime) - if flat906 is not None: - assert flat906 is not None - self.write(flat906) - return None - else: - _dollar_dollar = msg - fields896 = (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 fields896 is not None - unwrapped_fields897 = fields896 - self.write("(datetime") - self.indent_sexp() - self.newline() - field898 = unwrapped_fields897[0] - self.write(str(field898)) - self.newline() - field899 = unwrapped_fields897[1] - self.write(str(field899)) - self.newline() - field900 = unwrapped_fields897[2] - self.write(str(field900)) - self.newline() - field901 = unwrapped_fields897[3] - self.write(str(field901)) - self.newline() - field902 = unwrapped_fields897[4] - self.write(str(field902)) - self.newline() - field903 = unwrapped_fields897[5] - self.write(str(field903)) - field904 = unwrapped_fields897[6] - if field904 is not None: - self.newline() - assert field904 is not None - opt_val905 = field904 - self.write(str(opt_val905)) - self.dedent() - self.write(")") + def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): + fields1024 = msg + self.write("UNKNOWN") - def pretty_boolean_value(self, msg: bool): - _dollar_dollar = msg - if _dollar_dollar: - _t1699 = () - else: - _t1699 = None - deconstruct_result909 = _t1699 - if deconstruct_result909 is not None: - assert deconstruct_result909 is not None - unwrapped910 = deconstruct_result909 - self.write("true") - else: - _dollar_dollar = msg - if not _dollar_dollar: - _t1700 = () - else: - _t1700 = None - deconstruct_result907 = _t1700 - if deconstruct_result907 is not None: - assert deconstruct_result907 is not None - unwrapped908 = deconstruct_result907 - self.write("false") - else: - raise ParseError("No matching rule for boolean_value") - - def pretty_sync(self, msg: transactions_pb2.Sync): - flat915 = self._try_flat(msg, self.pretty_sync) - if flat915 is not None: - assert flat915 is not None - self.write(flat915) - return None - else: - _dollar_dollar = msg - fields911 = _dollar_dollar.fragments - assert fields911 is not None - unwrapped_fields912 = fields911 - self.write("(sync") - self.indent_sexp() - if not len(unwrapped_fields912) == 0: - self.newline() - for i914, elem913 in enumerate(unwrapped_fields912): - if (i914 > 0): - self.newline() - self.pretty_fragment_id(elem913) - self.dedent() - self.write(")") - - def pretty_fragment_id(self, msg: fragments_pb2.FragmentId): - flat918 = self._try_flat(msg, self.pretty_fragment_id) - if flat918 is not None: - assert flat918 is not None - self.write(flat918) - return None - else: - _dollar_dollar = msg - fields916 = self.fragment_id_to_string(_dollar_dollar) - assert fields916 is not None - unwrapped_fields917 = fields916 - self.write(":") - self.write(unwrapped_fields917) + def pretty_string_type(self, msg: logic_pb2.StringType): + fields1025 = msg + self.write("STRING") - def pretty_epoch(self, msg: transactions_pb2.Epoch): - flat925 = self._try_flat(msg, self.pretty_epoch) - if flat925 is not None: - assert flat925 is not None - self.write(flat925) - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.writes) == 0: - _t1701 = _dollar_dollar.writes - else: - _t1701 = None - if not len(_dollar_dollar.reads) == 0: - _t1702 = _dollar_dollar.reads - else: - _t1702 = None - fields919 = (_t1701, _t1702,) - assert fields919 is not None - unwrapped_fields920 = fields919 - self.write("(epoch") - self.indent_sexp() - field921 = unwrapped_fields920[0] - if field921 is not None: - self.newline() - assert field921 is not None - opt_val922 = field921 - self.pretty_epoch_writes(opt_val922) - field923 = unwrapped_fields920[1] - if field923 is not None: - self.newline() - assert field923 is not None - opt_val924 = field923 - self.pretty_epoch_reads(opt_val924) - self.dedent() - self.write(")") + def pretty_int_type(self, msg: logic_pb2.IntType): + fields1026 = msg + self.write("INT") - def pretty_epoch_writes(self, msg: Sequence[transactions_pb2.Write]): - flat929 = self._try_flat(msg, self.pretty_epoch_writes) - if flat929 is not None: - assert flat929 is not None - self.write(flat929) - return None - else: - fields926 = msg - self.write("(writes") - self.indent_sexp() - if not len(fields926) == 0: - self.newline() - for i928, elem927 in enumerate(fields926): - if (i928 > 0): - self.newline() - self.pretty_write(elem927) - self.dedent() - self.write(")") + def pretty_float_type(self, msg: logic_pb2.FloatType): + fields1027 = msg + self.write("FLOAT") - def pretty_write(self, msg: transactions_pb2.Write): - flat938 = self._try_flat(msg, self.pretty_write) - if flat938 is not None: - assert flat938 is not None - self.write(flat938) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("define"): - _t1703 = _dollar_dollar.define - else: - _t1703 = None - deconstruct_result936 = _t1703 - if deconstruct_result936 is not None: - assert deconstruct_result936 is not None - unwrapped937 = deconstruct_result936 - self.pretty_define(unwrapped937) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("undefine"): - _t1704 = _dollar_dollar.undefine - else: - _t1704 = None - deconstruct_result934 = _t1704 - if deconstruct_result934 is not None: - assert deconstruct_result934 is not None - unwrapped935 = deconstruct_result934 - self.pretty_undefine(unwrapped935) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("context"): - _t1705 = _dollar_dollar.context - else: - _t1705 = None - deconstruct_result932 = _t1705 - if deconstruct_result932 is not None: - assert deconstruct_result932 is not None - unwrapped933 = deconstruct_result932 - self.pretty_context(unwrapped933) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("snapshot"): - _t1706 = _dollar_dollar.snapshot - else: - _t1706 = None - deconstruct_result930 = _t1706 - if deconstruct_result930 is not None: - assert deconstruct_result930 is not None - unwrapped931 = deconstruct_result930 - self.pretty_snapshot(unwrapped931) - else: - raise ParseError("No matching rule for write") + def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): + fields1028 = msg + self.write("UINT128") - def pretty_define(self, msg: transactions_pb2.Define): - flat941 = self._try_flat(msg, self.pretty_define) - if flat941 is not None: - assert flat941 is not None - self.write(flat941) - return None - else: - _dollar_dollar = msg - fields939 = _dollar_dollar.fragment - assert fields939 is not None - unwrapped_fields940 = fields939 - self.write("(define") - self.indent_sexp() - self.newline() - self.pretty_fragment(unwrapped_fields940) - self.dedent() - self.write(")") + def pretty_int128_type(self, msg: logic_pb2.Int128Type): + fields1029 = msg + self.write("INT128") - def pretty_fragment(self, msg: fragments_pb2.Fragment): - flat948 = self._try_flat(msg, self.pretty_fragment) - if flat948 is not None: - assert flat948 is not None - self.write(flat948) - return None - else: - _dollar_dollar = msg - self.start_pretty_fragment(_dollar_dollar) - fields942 = (_dollar_dollar.id, _dollar_dollar.declarations,) - assert fields942 is not None - unwrapped_fields943 = fields942 - self.write("(fragment") - self.indent_sexp() - self.newline() - field944 = unwrapped_fields943[0] - self.pretty_new_fragment_id(field944) - field945 = unwrapped_fields943[1] - if not len(field945) == 0: - self.newline() - for i947, elem946 in enumerate(field945): - if (i947 > 0): - self.newline() - self.pretty_declaration(elem946) - self.dedent() - self.write(")") + def pretty_date_type(self, msg: logic_pb2.DateType): + fields1030 = msg + self.write("DATE") - def pretty_new_fragment_id(self, msg: fragments_pb2.FragmentId): - flat950 = self._try_flat(msg, self.pretty_new_fragment_id) - if flat950 is not None: - assert flat950 is not None - self.write(flat950) - return None - else: - fields949 = msg - self.pretty_fragment_id(fields949) + def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): + fields1031 = msg + self.write("DATETIME") - def pretty_declaration(self, msg: logic_pb2.Declaration): - flat959 = self._try_flat(msg, self.pretty_declaration) - if flat959 is not None: - assert flat959 is not None - self.write(flat959) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("def"): - _t1707 = getattr(_dollar_dollar, 'def') - else: - _t1707 = None - deconstruct_result957 = _t1707 - if deconstruct_result957 is not None: - assert deconstruct_result957 is not None - unwrapped958 = deconstruct_result957 - self.pretty_def(unwrapped958) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("algorithm"): - _t1708 = _dollar_dollar.algorithm - else: - _t1708 = None - deconstruct_result955 = _t1708 - if deconstruct_result955 is not None: - assert deconstruct_result955 is not None - unwrapped956 = deconstruct_result955 - self.pretty_algorithm(unwrapped956) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("constraint"): - _t1709 = _dollar_dollar.constraint - else: - _t1709 = None - deconstruct_result953 = _t1709 - if deconstruct_result953 is not None: - assert deconstruct_result953 is not None - unwrapped954 = deconstruct_result953 - self.pretty_constraint(unwrapped954) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("data"): - _t1710 = _dollar_dollar.data - else: - _t1710 = None - deconstruct_result951 = _t1710 - if deconstruct_result951 is not None: - assert deconstruct_result951 is not None - unwrapped952 = deconstruct_result951 - self.pretty_data(unwrapped952) - else: - raise ParseError("No matching rule for declaration") + def pretty_missing_type(self, msg: logic_pb2.MissingType): + fields1032 = msg + self.write("MISSING") - def pretty_def(self, msg: logic_pb2.Def): - flat966 = self._try_flat(msg, self.pretty_def) - if flat966 is not None: - assert flat966 is not None - self.write(flat966) + 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) return None else: _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: - _t1711 = _dollar_dollar.attrs - else: - _t1711 = None - fields960 = (_dollar_dollar.name, _dollar_dollar.body, _t1711,) - assert fields960 is not None - unwrapped_fields961 = fields960 - self.write("(def") + fields1033 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) + assert fields1033 is not None + unwrapped_fields1034 = fields1033 + self.write("(DECIMAL") self.indent_sexp() self.newline() - field962 = unwrapped_fields961[0] - self.pretty_relation_id(field962) + field1035 = unwrapped_fields1034[0] + self.write(str(field1035)) self.newline() - field963 = unwrapped_fields961[1] - self.pretty_abstraction(field963) - field964 = unwrapped_fields961[2] - if field964 is not None: - self.newline() - assert field964 is not None - opt_val965 = field964 - self.pretty_attrs(opt_val965) + field1036 = unwrapped_fields1034[1] + self.write(str(field1036)) self.dedent() self.write(")") - def pretty_relation_id(self, msg: logic_pb2.RelationId): - flat971 = self._try_flat(msg, self.pretty_relation_id) - if flat971 is not None: - assert flat971 is not None - self.write(flat971) ->>>>>>> origin/main - return None - else: - _dollar_dollar = msg - if self.relation_id_to_string(_dollar_dollar) is not None: -<<<<<<< HEAD - _t1637 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1636 = _t1637 - else: - _t1636 = None - deconstruct_result931 = _t1636 - if deconstruct_result931 is not None: - assert deconstruct_result931 is not None - unwrapped932 = deconstruct_result931 - self.write(":") - self.write(unwrapped932) - else: - _dollar_dollar = msg - _t1638 = self.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result929 = _t1638 - if deconstruct_result929 is not None: - assert deconstruct_result929 is not None - unwrapped930 = deconstruct_result929 - self.write(self.format_uint128(unwrapped930)) -======= - _t1713 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1712 = _t1713 - else: - _t1712 = None - deconstruct_result969 = _t1712 - if deconstruct_result969 is not None: - assert deconstruct_result969 is not None - unwrapped970 = deconstruct_result969 - self.write(":") - self.write(unwrapped970) - else: - _dollar_dollar = msg - _t1714 = self.deconstruct_relation_id_uint128(_dollar_dollar) - deconstruct_result967 = _t1714 - if deconstruct_result967 is not None: - assert deconstruct_result967 is not None - unwrapped968 = deconstruct_result967 - self.write(self.format_uint128(unwrapped968)) ->>>>>>> origin/main - else: - raise ParseError("No matching rule for relation_id") + def pretty_boolean_type(self, msg: logic_pb2.BooleanType): + fields1038 = msg + self.write("BOOLEAN") - def pretty_abstraction(self, msg: logic_pb2.Abstraction): -<<<<<<< HEAD - flat938 = self._try_flat(msg, self.pretty_abstraction) - if flat938 is not None: - assert flat938 is not None - self.write(flat938) - return None - else: - _dollar_dollar = msg - _t1639 = self.deconstruct_bindings(_dollar_dollar) - fields934 = (_t1639, _dollar_dollar.value,) - assert fields934 is not None - unwrapped_fields935 = fields934 - self.write("(") - self.indent() - field936 = unwrapped_fields935[0] - self.pretty_bindings(field936) - self.newline() - field937 = unwrapped_fields935[1] - self.pretty_formula(field937) -======= - flat976 = self._try_flat(msg, self.pretty_abstraction) - if flat976 is not None: - assert flat976 is not None - self.write(flat976) - return None - else: - _dollar_dollar = msg - _t1715 = self.deconstruct_bindings(_dollar_dollar) - fields972 = (_t1715, _dollar_dollar.value,) - assert fields972 is not None - unwrapped_fields973 = fields972 - self.write("(") - self.indent() - field974 = unwrapped_fields973[0] - self.pretty_bindings(field974) - self.newline() - field975 = unwrapped_fields973[1] - self.pretty_formula(field975) ->>>>>>> origin/main - self.dedent() - self.write(")") + def pretty_int32_type(self, msg: logic_pb2.Int32Type): + fields1039 = msg + self.write("INT32") - def pretty_bindings(self, msg: tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]): -<<<<<<< HEAD - flat946 = self._try_flat(msg, self.pretty_bindings) - if flat946 is not None: - assert flat946 is not None - self.write(flat946) -======= - flat984 = self._try_flat(msg, self.pretty_bindings) - if flat984 is not None: - assert flat984 is not None - self.write(flat984) ->>>>>>> origin/main - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar[1]) == 0: -<<<<<<< HEAD - _t1640 = _dollar_dollar[1] - else: - _t1640 = None - fields939 = (_dollar_dollar[0], _t1640,) - assert fields939 is not None - unwrapped_fields940 = fields939 - self.write("[") - self.indent() - field941 = unwrapped_fields940[0] - for i943, elem942 in enumerate(field941): - if (i943 > 0): - self.newline() - self.pretty_binding(elem942) - field944 = unwrapped_fields940[1] - if field944 is not None: - self.newline() - assert field944 is not None - opt_val945 = field944 - self.pretty_value_bindings(opt_val945) -======= - _t1716 = _dollar_dollar[1] - else: - _t1716 = None - fields977 = (_dollar_dollar[0], _t1716,) - assert fields977 is not None - unwrapped_fields978 = fields977 - self.write("[") - self.indent() - field979 = unwrapped_fields978[0] - for i981, elem980 in enumerate(field979): - if (i981 > 0): - self.newline() - self.pretty_binding(elem980) - field982 = unwrapped_fields978[1] - if field982 is not None: - self.newline() - assert field982 is not None - opt_val983 = field982 - self.pretty_value_bindings(opt_val983) ->>>>>>> origin/main - self.dedent() - self.write("]") + def pretty_float32_type(self, msg: logic_pb2.Float32Type): + fields1040 = msg + self.write("FLOAT32") - def pretty_binding(self, msg: logic_pb2.Binding): -<<<<<<< HEAD - flat951 = self._try_flat(msg, self.pretty_binding) - if flat951 is not None: - assert flat951 is not None - self.write(flat951) + def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): + fields1041 = 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) return None else: - _dollar_dollar = msg - fields947 = (_dollar_dollar.var.name, _dollar_dollar.type,) - assert fields947 is not None - unwrapped_fields948 = fields947 - field949 = unwrapped_fields948[0] - self.write(field949) - self.write("::") - field950 = unwrapped_fields948[1] - self.pretty_type(field950) + fields1042 = msg + self.write("|") + if not len(fields1042) == 0: + self.write(" ") + for i1044, elem1043 in enumerate(fields1042): + if (i1044 > 0): + self.newline() + self.pretty_binding(elem1043) - def pretty_type(self, msg: logic_pb2.Type): - flat980 = self._try_flat(msg, self.pretty_type) - if flat980 is not None: - assert flat980 is not None - self.write(flat980) + 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) return None else: _dollar_dollar = msg - if _dollar_dollar.HasField("unspecified_type"): - _t1641 = _dollar_dollar.unspecified_type + if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): + _t1741 = _dollar_dollar.conjunction else: - _t1641 = None - deconstruct_result978 = _t1641 - if deconstruct_result978 is not None: - assert deconstruct_result978 is not None - unwrapped979 = deconstruct_result978 - self.pretty_unspecified_type(unwrapped979) + _t1741 = None + deconstruct_result1070 = _t1741 + if deconstruct_result1070 is not None: + assert deconstruct_result1070 is not None + unwrapped1071 = deconstruct_result1070 + self.pretty_true(unwrapped1071) else: _dollar_dollar = msg - if _dollar_dollar.HasField("string_type"): - _t1642 = _dollar_dollar.string_type + if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): + _t1742 = _dollar_dollar.disjunction else: - _t1642 = None - deconstruct_result976 = _t1642 - if deconstruct_result976 is not None: - assert deconstruct_result976 is not None - unwrapped977 = deconstruct_result976 - self.pretty_string_type(unwrapped977) + _t1742 = None + deconstruct_result1068 = _t1742 + if deconstruct_result1068 is not None: + assert deconstruct_result1068 is not None + unwrapped1069 = deconstruct_result1068 + self.pretty_false(unwrapped1069) else: _dollar_dollar = msg - if _dollar_dollar.HasField("int_type"): - _t1643 = _dollar_dollar.int_type + if _dollar_dollar.HasField("exists"): + _t1743 = _dollar_dollar.exists else: - _t1643 = None - deconstruct_result974 = _t1643 - if deconstruct_result974 is not None: - assert deconstruct_result974 is not None - unwrapped975 = deconstruct_result974 - self.pretty_int_type(unwrapped975) + _t1743 = None + deconstruct_result1066 = _t1743 + if deconstruct_result1066 is not None: + assert deconstruct_result1066 is not None + unwrapped1067 = deconstruct_result1066 + self.pretty_exists(unwrapped1067) else: _dollar_dollar = msg - if _dollar_dollar.HasField("float_type"): - _t1644 = _dollar_dollar.float_type + if _dollar_dollar.HasField("reduce"): + _t1744 = _dollar_dollar.reduce else: - _t1644 = None - deconstruct_result972 = _t1644 - if deconstruct_result972 is not None: - assert deconstruct_result972 is not None - unwrapped973 = deconstruct_result972 - self.pretty_float_type(unwrapped973) + _t1744 = None + deconstruct_result1064 = _t1744 + if deconstruct_result1064 is not None: + assert deconstruct_result1064 is not None + unwrapped1065 = deconstruct_result1064 + self.pretty_reduce(unwrapped1065) else: _dollar_dollar = msg - if _dollar_dollar.HasField("uint128_type"): - _t1645 = _dollar_dollar.uint128_type + if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): + _t1745 = _dollar_dollar.conjunction else: - _t1645 = None - deconstruct_result970 = _t1645 - if deconstruct_result970 is not None: - assert deconstruct_result970 is not None - unwrapped971 = deconstruct_result970 - self.pretty_uint128_type(unwrapped971) + _t1745 = None + deconstruct_result1062 = _t1745 + if deconstruct_result1062 is not None: + assert deconstruct_result1062 is not None + unwrapped1063 = deconstruct_result1062 + self.pretty_conjunction(unwrapped1063) else: _dollar_dollar = msg - if _dollar_dollar.HasField("int128_type"): - _t1646 = _dollar_dollar.int128_type + if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): + _t1746 = _dollar_dollar.disjunction else: - _t1646 = None - deconstruct_result968 = _t1646 - if deconstruct_result968 is not None: - assert deconstruct_result968 is not None - unwrapped969 = deconstruct_result968 - self.pretty_int128_type(unwrapped969) + _t1746 = None + deconstruct_result1060 = _t1746 + if deconstruct_result1060 is not None: + assert deconstruct_result1060 is not None + unwrapped1061 = deconstruct_result1060 + self.pretty_disjunction(unwrapped1061) else: _dollar_dollar = msg - if _dollar_dollar.HasField("date_type"): - _t1647 = _dollar_dollar.date_type + if _dollar_dollar.HasField("not"): + _t1747 = getattr(_dollar_dollar, 'not') else: - _t1647 = None - deconstruct_result966 = _t1647 - if deconstruct_result966 is not None: - assert deconstruct_result966 is not None - unwrapped967 = deconstruct_result966 - self.pretty_date_type(unwrapped967) + _t1747 = None + deconstruct_result1058 = _t1747 + if deconstruct_result1058 is not None: + assert deconstruct_result1058 is not None + unwrapped1059 = deconstruct_result1058 + self.pretty_not(unwrapped1059) else: _dollar_dollar = msg - if _dollar_dollar.HasField("datetime_type"): - _t1648 = _dollar_dollar.datetime_type + if _dollar_dollar.HasField("ffi"): + _t1748 = _dollar_dollar.ffi else: - _t1648 = None - deconstruct_result964 = _t1648 - if deconstruct_result964 is not None: - assert deconstruct_result964 is not None - unwrapped965 = deconstruct_result964 - self.pretty_datetime_type(unwrapped965) + _t1748 = None + deconstruct_result1056 = _t1748 + if deconstruct_result1056 is not None: + assert deconstruct_result1056 is not None + unwrapped1057 = deconstruct_result1056 + self.pretty_ffi(unwrapped1057) else: _dollar_dollar = msg - if _dollar_dollar.HasField("missing_type"): - _t1649 = _dollar_dollar.missing_type + if _dollar_dollar.HasField("atom"): + _t1749 = _dollar_dollar.atom else: - _t1649 = None - deconstruct_result962 = _t1649 - if deconstruct_result962 is not None: - assert deconstruct_result962 is not None - unwrapped963 = deconstruct_result962 - self.pretty_missing_type(unwrapped963) + _t1749 = None + deconstruct_result1054 = _t1749 + if deconstruct_result1054 is not None: + assert deconstruct_result1054 is not None + unwrapped1055 = deconstruct_result1054 + self.pretty_atom(unwrapped1055) else: _dollar_dollar = msg - if _dollar_dollar.HasField("decimal_type"): - _t1650 = _dollar_dollar.decimal_type + if _dollar_dollar.HasField("pragma"): + _t1750 = _dollar_dollar.pragma else: - _t1650 = None - deconstruct_result960 = _t1650 - if deconstruct_result960 is not None: - assert deconstruct_result960 is not None - unwrapped961 = deconstruct_result960 - self.pretty_decimal_type(unwrapped961) + _t1750 = None + deconstruct_result1052 = _t1750 + if deconstruct_result1052 is not None: + assert deconstruct_result1052 is not None + unwrapped1053 = deconstruct_result1052 + self.pretty_pragma(unwrapped1053) else: _dollar_dollar = msg - if _dollar_dollar.HasField("boolean_type"): - _t1651 = _dollar_dollar.boolean_type + if _dollar_dollar.HasField("primitive"): + _t1751 = _dollar_dollar.primitive else: - _t1651 = None - deconstruct_result958 = _t1651 - if deconstruct_result958 is not None: - assert deconstruct_result958 is not None - unwrapped959 = deconstruct_result958 - self.pretty_boolean_type(unwrapped959) + _t1751 = None + deconstruct_result1050 = _t1751 + if deconstruct_result1050 is not None: + assert deconstruct_result1050 is not None + unwrapped1051 = deconstruct_result1050 + self.pretty_primitive(unwrapped1051) else: _dollar_dollar = msg - if _dollar_dollar.HasField("int32_type"): - _t1652 = _dollar_dollar.int32_type + if _dollar_dollar.HasField("rel_atom"): + _t1752 = _dollar_dollar.rel_atom else: - _t1652 = None - deconstruct_result956 = _t1652 - if deconstruct_result956 is not None: - assert deconstruct_result956 is not None - unwrapped957 = deconstruct_result956 - self.pretty_int32_type(unwrapped957) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("float32_type"): - _t1653 = _dollar_dollar.float32_type + if _dollar_dollar.HasField("cast"): + _t1753 = _dollar_dollar.cast else: - _t1653 = None - deconstruct_result954 = _t1653 - if deconstruct_result954 is not None: - assert deconstruct_result954 is not None - unwrapped955 = deconstruct_result954 - self.pretty_float32_type(unwrapped955) + _t1753 = None + deconstruct_result1046 = _t1753 + if deconstruct_result1046 is not None: + assert deconstruct_result1046 is not None + unwrapped1047 = deconstruct_result1046 + self.pretty_cast(unwrapped1047) else: - _dollar_dollar = msg - if _dollar_dollar.HasField("uint32_type"): - _t1654 = _dollar_dollar.uint32_type - else: - _t1654 = None - deconstruct_result952 = _t1654 - if deconstruct_result952 is not None: - assert deconstruct_result952 is not None - unwrapped953 = deconstruct_result952 - self.pretty_uint32_type(unwrapped953) - else: - raise ParseError("No matching rule for type") - - def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields981 = msg - self.write("UNKNOWN") - - def pretty_string_type(self, msg: logic_pb2.StringType): - fields982 = msg - self.write("STRING") - - def pretty_int_type(self, msg: logic_pb2.IntType): - fields983 = msg - self.write("INT") - - def pretty_float_type(self, msg: logic_pb2.FloatType): - fields984 = msg - self.write("FLOAT") - - def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields985 = msg - self.write("UINT128") - - def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields986 = msg - self.write("INT128") - - def pretty_date_type(self, msg: logic_pb2.DateType): - fields987 = msg - self.write("DATE") - - def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields988 = msg - self.write("DATETIME") - - def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields989 = msg - self.write("MISSING") - - def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat994 = self._try_flat(msg, self.pretty_decimal_type) - if flat994 is not None: - assert flat994 is not None - self.write(flat994) - return None - else: - _dollar_dollar = msg - fields990 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - assert fields990 is not None - unwrapped_fields991 = fields990 - self.write("(DECIMAL") - self.indent_sexp() - self.newline() - field992 = unwrapped_fields991[0] - self.write(str(field992)) - self.newline() - field993 = unwrapped_fields991[1] - self.write(str(field993)) -======= - flat989 = self._try_flat(msg, self.pretty_binding) - if flat989 is not None: - assert flat989 is not None - self.write(flat989) - return None - else: - _dollar_dollar = msg - fields985 = (_dollar_dollar.var.name, _dollar_dollar.type,) - assert fields985 is not None - unwrapped_fields986 = fields985 - field987 = unwrapped_fields986[0] - self.write(field987) - self.write("::") - field988 = unwrapped_fields986[1] - self.pretty_type(field988) - - def pretty_type(self, msg: logic_pb2.Type): - flat1018 = self._try_flat(msg, self.pretty_type) - if flat1018 is not None: - assert flat1018 is not None - self.write(flat1018) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("unspecified_type"): - _t1717 = _dollar_dollar.unspecified_type - else: - _t1717 = None - deconstruct_result1016 = _t1717 - if deconstruct_result1016 is not None: - assert deconstruct_result1016 is not None - unwrapped1017 = deconstruct_result1016 - self.pretty_unspecified_type(unwrapped1017) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("string_type"): - _t1718 = _dollar_dollar.string_type - else: - _t1718 = None - deconstruct_result1014 = _t1718 - if deconstruct_result1014 is not None: - assert deconstruct_result1014 is not None - unwrapped1015 = deconstruct_result1014 - self.pretty_string_type(unwrapped1015) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("int_type"): - _t1719 = _dollar_dollar.int_type - else: - _t1719 = None - deconstruct_result1012 = _t1719 - if deconstruct_result1012 is not None: - assert deconstruct_result1012 is not None - unwrapped1013 = deconstruct_result1012 - self.pretty_int_type(unwrapped1013) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("float_type"): - _t1720 = _dollar_dollar.float_type - else: - _t1720 = None - deconstruct_result1010 = _t1720 - if deconstruct_result1010 is not None: - assert deconstruct_result1010 is not None - unwrapped1011 = deconstruct_result1010 - self.pretty_float_type(unwrapped1011) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("uint128_type"): - _t1721 = _dollar_dollar.uint128_type - else: - _t1721 = None - deconstruct_result1008 = _t1721 - if deconstruct_result1008 is not None: - assert deconstruct_result1008 is not None - unwrapped1009 = deconstruct_result1008 - self.pretty_uint128_type(unwrapped1009) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("int128_type"): - _t1722 = _dollar_dollar.int128_type - else: - _t1722 = None - deconstruct_result1006 = _t1722 - if deconstruct_result1006 is not None: - assert deconstruct_result1006 is not None - unwrapped1007 = deconstruct_result1006 - self.pretty_int128_type(unwrapped1007) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("date_type"): - _t1723 = _dollar_dollar.date_type - else: - _t1723 = None - deconstruct_result1004 = _t1723 - if deconstruct_result1004 is not None: - assert deconstruct_result1004 is not None - unwrapped1005 = deconstruct_result1004 - self.pretty_date_type(unwrapped1005) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("datetime_type"): - _t1724 = _dollar_dollar.datetime_type - else: - _t1724 = None - deconstruct_result1002 = _t1724 - if deconstruct_result1002 is not None: - assert deconstruct_result1002 is not None - unwrapped1003 = deconstruct_result1002 - self.pretty_datetime_type(unwrapped1003) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("missing_type"): - _t1725 = _dollar_dollar.missing_type - else: - _t1725 = None - deconstruct_result1000 = _t1725 - if deconstruct_result1000 is not None: - assert deconstruct_result1000 is not None - unwrapped1001 = deconstruct_result1000 - self.pretty_missing_type(unwrapped1001) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("decimal_type"): - _t1726 = _dollar_dollar.decimal_type - else: - _t1726 = None - deconstruct_result998 = _t1726 - if deconstruct_result998 is not None: - assert deconstruct_result998 is not None - unwrapped999 = deconstruct_result998 - self.pretty_decimal_type(unwrapped999) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("boolean_type"): - _t1727 = _dollar_dollar.boolean_type - else: - _t1727 = None - deconstruct_result996 = _t1727 - if deconstruct_result996 is not None: - assert deconstruct_result996 is not None - unwrapped997 = deconstruct_result996 - self.pretty_boolean_type(unwrapped997) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("int32_type"): - _t1728 = _dollar_dollar.int32_type - else: - _t1728 = None - deconstruct_result994 = _t1728 - if deconstruct_result994 is not None: - assert deconstruct_result994 is not None - unwrapped995 = deconstruct_result994 - self.pretty_int32_type(unwrapped995) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("float32_type"): - _t1729 = _dollar_dollar.float32_type - else: - _t1729 = None - deconstruct_result992 = _t1729 - if deconstruct_result992 is not None: - assert deconstruct_result992 is not None - unwrapped993 = deconstruct_result992 - self.pretty_float32_type(unwrapped993) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("uint32_type"): - _t1730 = _dollar_dollar.uint32_type - else: - _t1730 = None - deconstruct_result990 = _t1730 - if deconstruct_result990 is not None: - assert deconstruct_result990 is not None - unwrapped991 = deconstruct_result990 - self.pretty_uint32_type(unwrapped991) - else: - raise ParseError("No matching rule for type") - - def pretty_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields1019 = msg - self.write("UNKNOWN") - - def pretty_string_type(self, msg: logic_pb2.StringType): - fields1020 = msg - self.write("STRING") - - def pretty_int_type(self, msg: logic_pb2.IntType): - fields1021 = msg - self.write("INT") - - def pretty_float_type(self, msg: logic_pb2.FloatType): - fields1022 = msg - self.write("FLOAT") - - def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields1023 = msg - self.write("UINT128") - - def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields1024 = msg - self.write("INT128") - - def pretty_date_type(self, msg: logic_pb2.DateType): - fields1025 = msg - self.write("DATE") - - def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields1026 = msg - self.write("DATETIME") - - def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields1027 = msg - self.write("MISSING") - - def pretty_decimal_type(self, msg: logic_pb2.DecimalType): - flat1032 = self._try_flat(msg, self.pretty_decimal_type) - if flat1032 is not None: - assert flat1032 is not None - self.write(flat1032) - return None - else: - _dollar_dollar = msg - fields1028 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - assert fields1028 is not None - unwrapped_fields1029 = fields1028 - self.write("(DECIMAL") - self.indent_sexp() - self.newline() - field1030 = unwrapped_fields1029[0] - self.write(str(field1030)) - self.newline() - field1031 = unwrapped_fields1029[1] - self.write(str(field1031)) ->>>>>>> origin/main - self.dedent() - self.write(")") - - def pretty_boolean_type(self, msg: logic_pb2.BooleanType): -<<<<<<< HEAD - fields995 = msg - self.write("BOOLEAN") - - def pretty_int32_type(self, msg: logic_pb2.Int32Type): - fields996 = msg - self.write("INT32") - - def pretty_float32_type(self, msg: logic_pb2.Float32Type): - fields997 = msg - self.write("FLOAT32") - - def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): - fields998 = msg - self.write("UINT32") - - def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat1002 = self._try_flat(msg, self.pretty_value_bindings) - if flat1002 is not None: - assert flat1002 is not None - self.write(flat1002) - return None - else: - fields999 = msg - self.write("|") - if not len(fields999) == 0: - self.write(" ") - for i1001, elem1000 in enumerate(fields999): - if (i1001 > 0): - self.newline() - self.pretty_binding(elem1000) - - def pretty_formula(self, msg: logic_pb2.Formula): - flat1029 = self._try_flat(msg, self.pretty_formula) - if flat1029 is not None: - assert flat1029 is not None - self.write(flat1029) -======= - fields1033 = msg - self.write("BOOLEAN") - - def pretty_int32_type(self, msg: logic_pb2.Int32Type): - fields1034 = msg - self.write("INT32") - - def pretty_float32_type(self, msg: logic_pb2.Float32Type): - fields1035 = msg - self.write("FLOAT32") - - def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): - fields1036 = msg - self.write("UINT32") - - def pretty_value_bindings(self, msg: Sequence[logic_pb2.Binding]): - flat1040 = self._try_flat(msg, self.pretty_value_bindings) - if flat1040 is not None: - assert flat1040 is not None - self.write(flat1040) - return None - else: - fields1037 = msg - self.write("|") - if not len(fields1037) == 0: - self.write(" ") - for i1039, elem1038 in enumerate(fields1037): - if (i1039 > 0): - self.newline() - self.pretty_binding(elem1038) - - def pretty_formula(self, msg: logic_pb2.Formula): - flat1067 = self._try_flat(msg, self.pretty_formula) - if flat1067 is not None: - assert flat1067 is not None - self.write(flat1067) ->>>>>>> origin/main - return None - else: - _dollar_dollar = msg - if (_dollar_dollar.HasField("conjunction") and len(_dollar_dollar.conjunction.args) == 0): -<<<<<<< HEAD - _t1655 = _dollar_dollar.conjunction - else: - _t1655 = None - deconstruct_result1027 = _t1655 - if deconstruct_result1027 is not None: - assert deconstruct_result1027 is not None - unwrapped1028 = deconstruct_result1027 - self.pretty_true(unwrapped1028) - else: - _dollar_dollar = msg - if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1656 = _dollar_dollar.disjunction - else: - _t1656 = None - deconstruct_result1025 = _t1656 - if deconstruct_result1025 is not None: - assert deconstruct_result1025 is not None - unwrapped1026 = deconstruct_result1025 - self.pretty_false(unwrapped1026) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("exists"): - _t1657 = _dollar_dollar.exists - else: - _t1657 = None - deconstruct_result1023 = _t1657 - if deconstruct_result1023 is not None: - assert deconstruct_result1023 is not None - unwrapped1024 = deconstruct_result1023 - self.pretty_exists(unwrapped1024) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("reduce"): - _t1658 = _dollar_dollar.reduce - else: - _t1658 = None - deconstruct_result1021 = _t1658 - if deconstruct_result1021 is not None: - assert deconstruct_result1021 is not None - unwrapped1022 = deconstruct_result1021 - self.pretty_reduce(unwrapped1022) - else: - _dollar_dollar = msg - if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1659 = _dollar_dollar.conjunction - else: - _t1659 = None - deconstruct_result1019 = _t1659 - if deconstruct_result1019 is not None: - assert deconstruct_result1019 is not None - unwrapped1020 = deconstruct_result1019 - self.pretty_conjunction(unwrapped1020) - else: - _dollar_dollar = msg - if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1660 = _dollar_dollar.disjunction - else: - _t1660 = None - deconstruct_result1017 = _t1660 - if deconstruct_result1017 is not None: - assert deconstruct_result1017 is not None - unwrapped1018 = deconstruct_result1017 - self.pretty_disjunction(unwrapped1018) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("not"): - _t1661 = getattr(_dollar_dollar, 'not') - else: - _t1661 = None - deconstruct_result1015 = _t1661 - if deconstruct_result1015 is not None: - assert deconstruct_result1015 is not None - unwrapped1016 = deconstruct_result1015 - self.pretty_not(unwrapped1016) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("ffi"): - _t1662 = _dollar_dollar.ffi - else: - _t1662 = None - deconstruct_result1013 = _t1662 - if deconstruct_result1013 is not None: - assert deconstruct_result1013 is not None - unwrapped1014 = deconstruct_result1013 - self.pretty_ffi(unwrapped1014) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("atom"): - _t1663 = _dollar_dollar.atom - else: - _t1663 = None - deconstruct_result1011 = _t1663 - if deconstruct_result1011 is not None: - assert deconstruct_result1011 is not None - unwrapped1012 = deconstruct_result1011 - self.pretty_atom(unwrapped1012) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("pragma"): - _t1664 = _dollar_dollar.pragma - else: - _t1664 = None - deconstruct_result1009 = _t1664 - if deconstruct_result1009 is not None: - assert deconstruct_result1009 is not None - unwrapped1010 = deconstruct_result1009 - self.pretty_pragma(unwrapped1010) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("primitive"): - _t1665 = _dollar_dollar.primitive - else: - _t1665 = None - deconstruct_result1007 = _t1665 - if deconstruct_result1007 is not None: - assert deconstruct_result1007 is not None - unwrapped1008 = deconstruct_result1007 - self.pretty_primitive(unwrapped1008) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("rel_atom"): - _t1666 = _dollar_dollar.rel_atom - else: - _t1666 = None - deconstruct_result1005 = _t1666 - if deconstruct_result1005 is not None: - assert deconstruct_result1005 is not None - unwrapped1006 = deconstruct_result1005 - self.pretty_rel_atom(unwrapped1006) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("cast"): - _t1667 = _dollar_dollar.cast - else: - _t1667 = None - deconstruct_result1003 = _t1667 - if deconstruct_result1003 is not None: - assert deconstruct_result1003 is not None - unwrapped1004 = deconstruct_result1003 - self.pretty_cast(unwrapped1004) -======= - _t1731 = _dollar_dollar.conjunction - else: - _t1731 = None - deconstruct_result1065 = _t1731 - if deconstruct_result1065 is not None: - assert deconstruct_result1065 is not None - unwrapped1066 = deconstruct_result1065 - self.pretty_true(unwrapped1066) - else: - _dollar_dollar = msg - if (_dollar_dollar.HasField("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1732 = _dollar_dollar.disjunction - else: - _t1732 = None - deconstruct_result1063 = _t1732 - if deconstruct_result1063 is not None: - assert deconstruct_result1063 is not None - unwrapped1064 = deconstruct_result1063 - self.pretty_false(unwrapped1064) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("exists"): - _t1733 = _dollar_dollar.exists - else: - _t1733 = None - deconstruct_result1061 = _t1733 - if deconstruct_result1061 is not None: - assert deconstruct_result1061 is not None - unwrapped1062 = deconstruct_result1061 - self.pretty_exists(unwrapped1062) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("reduce"): - _t1734 = _dollar_dollar.reduce - else: - _t1734 = None - deconstruct_result1059 = _t1734 - if deconstruct_result1059 is not None: - assert deconstruct_result1059 is not None - unwrapped1060 = deconstruct_result1059 - self.pretty_reduce(unwrapped1060) - else: - _dollar_dollar = msg - if (_dollar_dollar.HasField("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1735 = _dollar_dollar.conjunction - else: - _t1735 = None - deconstruct_result1057 = _t1735 - if deconstruct_result1057 is not None: - assert deconstruct_result1057 is not None - unwrapped1058 = deconstruct_result1057 - self.pretty_conjunction(unwrapped1058) - else: - _dollar_dollar = msg - if (_dollar_dollar.HasField("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1736 = _dollar_dollar.disjunction - else: - _t1736 = None - deconstruct_result1055 = _t1736 - if deconstruct_result1055 is not None: - assert deconstruct_result1055 is not None - unwrapped1056 = deconstruct_result1055 - self.pretty_disjunction(unwrapped1056) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("not"): - _t1737 = getattr(_dollar_dollar, 'not') - else: - _t1737 = None - deconstruct_result1053 = _t1737 - if deconstruct_result1053 is not None: - assert deconstruct_result1053 is not None - unwrapped1054 = deconstruct_result1053 - self.pretty_not(unwrapped1054) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("ffi"): - _t1738 = _dollar_dollar.ffi - else: - _t1738 = None - deconstruct_result1051 = _t1738 - if deconstruct_result1051 is not None: - assert deconstruct_result1051 is not None - unwrapped1052 = deconstruct_result1051 - self.pretty_ffi(unwrapped1052) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("atom"): - _t1739 = _dollar_dollar.atom - else: - _t1739 = None - deconstruct_result1049 = _t1739 - if deconstruct_result1049 is not None: - assert deconstruct_result1049 is not None - unwrapped1050 = deconstruct_result1049 - self.pretty_atom(unwrapped1050) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("pragma"): - _t1740 = _dollar_dollar.pragma - else: - _t1740 = None - deconstruct_result1047 = _t1740 - if deconstruct_result1047 is not None: - assert deconstruct_result1047 is not None - unwrapped1048 = deconstruct_result1047 - self.pretty_pragma(unwrapped1048) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("primitive"): - _t1741 = _dollar_dollar.primitive - else: - _t1741 = None - deconstruct_result1045 = _t1741 - if deconstruct_result1045 is not None: - assert deconstruct_result1045 is not None - unwrapped1046 = deconstruct_result1045 - self.pretty_primitive(unwrapped1046) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("rel_atom"): - _t1742 = _dollar_dollar.rel_atom - else: - _t1742 = None - deconstruct_result1043 = _t1742 - if deconstruct_result1043 is not None: - assert deconstruct_result1043 is not None - unwrapped1044 = deconstruct_result1043 - self.pretty_rel_atom(unwrapped1044) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("cast"): - _t1743 = _dollar_dollar.cast - else: - _t1743 = None - deconstruct_result1041 = _t1743 - if deconstruct_result1041 is not None: - assert deconstruct_result1041 is not None - unwrapped1042 = deconstruct_result1041 - self.pretty_cast(unwrapped1042) ->>>>>>> origin/main - else: - raise ParseError("No matching rule for formula") - - def pretty_true(self, msg: logic_pb2.Conjunction): -<<<<<<< HEAD - fields1030 = msg - self.write("(true)") - - def pretty_false(self, msg: logic_pb2.Disjunction): - fields1031 = msg - self.write("(false)") - - def pretty_exists(self, msg: logic_pb2.Exists): - flat1036 = self._try_flat(msg, self.pretty_exists) - if flat1036 is not None: - assert flat1036 is not None - self.write(flat1036) - return None - else: - _dollar_dollar = msg - _t1668 = self.deconstruct_bindings(_dollar_dollar.body) - fields1032 = (_t1668, _dollar_dollar.body.value,) - assert fields1032 is not None - unwrapped_fields1033 = fields1032 - self.write("(exists") - self.indent_sexp() - self.newline() - field1034 = unwrapped_fields1033[0] - self.pretty_bindings(field1034) - self.newline() - field1035 = unwrapped_fields1033[1] - self.pretty_formula(field1035) -======= - fields1068 = msg - self.write("(true)") - - def pretty_false(self, msg: logic_pb2.Disjunction): - fields1069 = msg - self.write("(false)") - - def pretty_exists(self, msg: logic_pb2.Exists): - flat1074 = self._try_flat(msg, self.pretty_exists) - if flat1074 is not None: - assert flat1074 is not None - self.write(flat1074) - return None - else: - _dollar_dollar = msg - _t1744 = self.deconstruct_bindings(_dollar_dollar.body) - fields1070 = (_t1744, _dollar_dollar.body.value,) - assert fields1070 is not None - unwrapped_fields1071 = fields1070 - self.write("(exists") - self.indent_sexp() - self.newline() - field1072 = unwrapped_fields1071[0] - self.pretty_bindings(field1072) - self.newline() - field1073 = unwrapped_fields1071[1] - self.pretty_formula(field1073) ->>>>>>> origin/main - self.dedent() - self.write(")") - - def pretty_reduce(self, msg: logic_pb2.Reduce): -<<<<<<< HEAD - flat1042 = self._try_flat(msg, self.pretty_reduce) - if flat1042 is not None: - assert flat1042 is not None - self.write(flat1042) - return None - else: - _dollar_dollar = msg - fields1037 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - assert fields1037 is not None - unwrapped_fields1038 = fields1037 - self.write("(reduce") - self.indent_sexp() - self.newline() - field1039 = unwrapped_fields1038[0] - self.pretty_abstraction(field1039) - self.newline() - field1040 = unwrapped_fields1038[1] - self.pretty_abstraction(field1040) - self.newline() - field1041 = unwrapped_fields1038[2] - self.pretty_terms(field1041) -======= - flat1080 = self._try_flat(msg, self.pretty_reduce) - if flat1080 is not None: - assert flat1080 is not None - self.write(flat1080) - return None - else: - _dollar_dollar = msg - fields1075 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - assert fields1075 is not None - unwrapped_fields1076 = fields1075 - self.write("(reduce") - self.indent_sexp() - self.newline() - field1077 = unwrapped_fields1076[0] - self.pretty_abstraction(field1077) - self.newline() - field1078 = unwrapped_fields1076[1] - self.pretty_abstraction(field1078) - self.newline() - field1079 = unwrapped_fields1076[2] - self.pretty_terms(field1079) ->>>>>>> origin/main - self.dedent() - self.write(")") - - def pretty_terms(self, msg: Sequence[logic_pb2.Term]): -<<<<<<< HEAD - flat1046 = self._try_flat(msg, self.pretty_terms) - if flat1046 is not None: - assert flat1046 is not None - self.write(flat1046) -======= - flat1084 = self._try_flat(msg, self.pretty_terms) - if flat1084 is not None: - assert flat1084 is not None - self.write(flat1084) - return None - else: - fields1081 = msg - self.write("(terms") - self.indent_sexp() - if not len(fields1081) == 0: - self.newline() - for i1083, elem1082 in enumerate(fields1081): - if (i1083 > 0): - self.newline() - self.pretty_term(elem1082) - self.dedent() - self.write(")") - - def pretty_term(self, msg: logic_pb2.Term): - flat1089 = self._try_flat(msg, self.pretty_term) - if flat1089 is not None: - assert flat1089 is not None - self.write(flat1089) ->>>>>>> origin/main - return None - else: - fields1043 = msg - self.write("(terms") - self.indent_sexp() - if not len(fields1043) == 0: - self.newline() - for i1045, elem1044 in enumerate(fields1043): - if (i1045 > 0): - self.newline() - self.pretty_term(elem1044) - self.dedent() - self.write(")") - - def pretty_term(self, msg: logic_pb2.Term): - flat1051 = self._try_flat(msg, self.pretty_term) - if flat1051 is not None: - assert flat1051 is not None - self.write(flat1051) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("var"): -<<<<<<< HEAD - _t1669 = _dollar_dollar.var - else: - _t1669 = None - deconstruct_result1049 = _t1669 - if deconstruct_result1049 is not None: - assert deconstruct_result1049 is not None - unwrapped1050 = deconstruct_result1049 - self.pretty_var(unwrapped1050) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("constant"): - _t1670 = _dollar_dollar.constant - else: - _t1670 = None - deconstruct_result1047 = _t1670 - if deconstruct_result1047 is not None: - assert deconstruct_result1047 is not None - unwrapped1048 = deconstruct_result1047 - self.pretty_value(unwrapped1048) -======= - _t1745 = _dollar_dollar.var - else: - _t1745 = None - deconstruct_result1087 = _t1745 - if deconstruct_result1087 is not None: - assert deconstruct_result1087 is not None - unwrapped1088 = deconstruct_result1087 - self.pretty_var(unwrapped1088) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("constant"): - _t1746 = _dollar_dollar.constant - else: - _t1746 = None - deconstruct_result1085 = _t1746 - if deconstruct_result1085 is not None: - assert deconstruct_result1085 is not None - unwrapped1086 = deconstruct_result1085 - self.pretty_value(unwrapped1086) ->>>>>>> origin/main - else: - raise ParseError("No matching rule for term") - - def pretty_var(self, msg: logic_pb2.Var): -<<<<<<< HEAD - flat1054 = self._try_flat(msg, self.pretty_var) - if flat1054 is not None: - assert flat1054 is not None - self.write(flat1054) - return None - else: - _dollar_dollar = msg - fields1052 = _dollar_dollar.name - assert fields1052 is not None - unwrapped_fields1053 = fields1052 - self.write(unwrapped_fields1053) - - def pretty_value(self, msg: logic_pb2.Value): - flat1080 = self._try_flat(msg, self.pretty_value) - if flat1080 is not None: - assert flat1080 is not None - self.write(flat1080) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("date_value"): - _t1671 = _dollar_dollar.date_value - else: - _t1671 = None - deconstruct_result1078 = _t1671 - if deconstruct_result1078 is not None: - assert deconstruct_result1078 is not None - unwrapped1079 = deconstruct_result1078 - self.pretty_date(unwrapped1079) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("datetime_value"): - _t1672 = _dollar_dollar.datetime_value - else: - _t1672 = None - deconstruct_result1076 = _t1672 - if deconstruct_result1076 is not None: - assert deconstruct_result1076 is not None - unwrapped1077 = deconstruct_result1076 - self.pretty_datetime(unwrapped1077) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("string_value"): - _t1673 = _dollar_dollar.string_value - else: - _t1673 = None - deconstruct_result1074 = _t1673 - if deconstruct_result1074 is not None: - assert deconstruct_result1074 is not None - unwrapped1075 = deconstruct_result1074 - self.write(self.format_string_value(unwrapped1075)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("int32_value"): - _t1674 = _dollar_dollar.int32_value - else: - _t1674 = None - deconstruct_result1072 = _t1674 - if deconstruct_result1072 is not None: - assert deconstruct_result1072 is not None - unwrapped1073 = deconstruct_result1072 - self.write((str(unwrapped1073) + 'i32')) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("int_value"): - _t1675 = _dollar_dollar.int_value - else: - _t1675 = None - deconstruct_result1070 = _t1675 - if deconstruct_result1070 is not None: - assert deconstruct_result1070 is not None - unwrapped1071 = deconstruct_result1070 - self.write(str(unwrapped1071)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("float32_value"): - _t1676 = _dollar_dollar.float32_value - else: - _t1676 = None - deconstruct_result1068 = _t1676 - if deconstruct_result1068 is not None: - assert deconstruct_result1068 is not None - unwrapped1069 = deconstruct_result1068 - self.write(self.format_float32_literal(unwrapped1069)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("float_value"): - _t1677 = _dollar_dollar.float_value - else: - _t1677 = None - deconstruct_result1066 = _t1677 - if deconstruct_result1066 is not None: - assert deconstruct_result1066 is not None - unwrapped1067 = deconstruct_result1066 - self.write(str(unwrapped1067)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("uint32_value"): - _t1678 = _dollar_dollar.uint32_value - else: - _t1678 = None - deconstruct_result1064 = _t1678 - if deconstruct_result1064 is not None: - assert deconstruct_result1064 is not None - unwrapped1065 = deconstruct_result1064 - self.write((str(unwrapped1065) + 'u32')) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("uint128_value"): - _t1679 = _dollar_dollar.uint128_value - else: - _t1679 = None - deconstruct_result1062 = _t1679 - if deconstruct_result1062 is not None: - assert deconstruct_result1062 is not None - unwrapped1063 = deconstruct_result1062 - self.write(self.format_uint128(unwrapped1063)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("int128_value"): - _t1680 = _dollar_dollar.int128_value - else: - _t1680 = None - deconstruct_result1060 = _t1680 - if deconstruct_result1060 is not None: - assert deconstruct_result1060 is not None - unwrapped1061 = deconstruct_result1060 - self.write(self.format_int128(unwrapped1061)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("decimal_value"): - _t1681 = _dollar_dollar.decimal_value - else: - _t1681 = None - deconstruct_result1058 = _t1681 - if deconstruct_result1058 is not None: - assert deconstruct_result1058 is not None - unwrapped1059 = deconstruct_result1058 - self.write(self.format_decimal(unwrapped1059)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("boolean_value"): - _t1682 = _dollar_dollar.boolean_value - else: - _t1682 = None - deconstruct_result1056 = _t1682 - if deconstruct_result1056 is not None: - assert deconstruct_result1056 is not None - unwrapped1057 = deconstruct_result1056 - self.pretty_boolean_value(unwrapped1057) - else: - fields1055 = msg - self.write("missing") - - def pretty_date(self, msg: logic_pb2.DateValue): - flat1086 = self._try_flat(msg, self.pretty_date) - if flat1086 is not None: - assert flat1086 is not None - self.write(flat1086) - return None - else: - _dollar_dollar = msg - fields1081 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields1081 is not None - unwrapped_fields1082 = fields1081 - self.write("(date") - self.indent_sexp() - self.newline() - field1083 = unwrapped_fields1082[0] - self.write(str(field1083)) - self.newline() - field1084 = unwrapped_fields1082[1] - self.write(str(field1084)) - self.newline() - field1085 = unwrapped_fields1082[2] - self.write(str(field1085)) - self.dedent() - self.write(")") - - def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat1097 = self._try_flat(msg, self.pretty_datetime) - if flat1097 is not None: - assert flat1097 is not None - self.write(flat1097) - return None - else: - _dollar_dollar = msg - fields1087 = (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 fields1087 is not None - unwrapped_fields1088 = fields1087 - self.write("(datetime") - self.indent_sexp() - self.newline() - field1089 = unwrapped_fields1088[0] - self.write(str(field1089)) - self.newline() - field1090 = unwrapped_fields1088[1] - self.write(str(field1090)) - self.newline() - field1091 = unwrapped_fields1088[2] - self.write(str(field1091)) - self.newline() - field1092 = unwrapped_fields1088[3] - self.write(str(field1092)) - self.newline() - field1093 = unwrapped_fields1088[4] - self.write(str(field1093)) - self.newline() - field1094 = unwrapped_fields1088[5] - self.write(str(field1094)) - field1095 = unwrapped_fields1088[6] - if field1095 is not None: - self.newline() - assert field1095 is not None - opt_val1096 = field1095 - self.write(str(opt_val1096)) - self.dedent() - self.write(")") - - def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat1102 = self._try_flat(msg, self.pretty_conjunction) - if flat1102 is not None: - assert flat1102 is not None - self.write(flat1102) - return None - else: - _dollar_dollar = msg - fields1098 = _dollar_dollar.args - assert fields1098 is not None - unwrapped_fields1099 = fields1098 - self.write("(and") - self.indent_sexp() - if not len(unwrapped_fields1099) == 0: - self.newline() - for i1101, elem1100 in enumerate(unwrapped_fields1099): - if (i1101 > 0): - self.newline() - self.pretty_formula(elem1100) - self.dedent() - self.write(")") - - def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat1107 = self._try_flat(msg, self.pretty_disjunction) - if flat1107 is not None: - assert flat1107 is not None - self.write(flat1107) - return None - else: - _dollar_dollar = msg - fields1103 = _dollar_dollar.args - assert fields1103 is not None - unwrapped_fields1104 = fields1103 - self.write("(or") - self.indent_sexp() - if not len(unwrapped_fields1104) == 0: - self.newline() - for i1106, elem1105 in enumerate(unwrapped_fields1104): - if (i1106 > 0): - self.newline() - self.pretty_formula(elem1105) - self.dedent() - self.write(")") - - def pretty_not(self, msg: logic_pb2.Not): - flat1110 = self._try_flat(msg, self.pretty_not) - if flat1110 is not None: - assert flat1110 is not None - self.write(flat1110) - return None - else: - _dollar_dollar = msg - fields1108 = _dollar_dollar.arg - assert fields1108 is not None - unwrapped_fields1109 = fields1108 - self.write("(not") - self.indent_sexp() - self.newline() - self.pretty_formula(unwrapped_fields1109) - self.dedent() - self.write(")") - - def pretty_ffi(self, msg: logic_pb2.FFI): - flat1116 = self._try_flat(msg, self.pretty_ffi) - if flat1116 is not None: - assert flat1116 is not None - self.write(flat1116) - return None - else: - _dollar_dollar = msg - fields1111 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - assert fields1111 is not None - unwrapped_fields1112 = fields1111 - self.write("(ffi") - self.indent_sexp() - self.newline() - field1113 = unwrapped_fields1112[0] - self.pretty_name(field1113) - self.newline() - field1114 = unwrapped_fields1112[1] - self.pretty_ffi_args(field1114) - self.newline() - field1115 = unwrapped_fields1112[2] - self.pretty_terms(field1115) - self.dedent() - self.write(")") - - def pretty_name(self, msg: str): - flat1118 = self._try_flat(msg, self.pretty_name) - if flat1118 is not None: - assert flat1118 is not None - self.write(flat1118) - return None - else: - fields1117 = msg - self.write(":") - self.write(fields1117) - - def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat1122 = self._try_flat(msg, self.pretty_ffi_args) - if flat1122 is not None: - assert flat1122 is not None - self.write(flat1122) - return None - else: - fields1119 = msg - self.write("(args") - self.indent_sexp() - if not len(fields1119) == 0: - self.newline() - for i1121, elem1120 in enumerate(fields1119): - if (i1121 > 0): - self.newline() - self.pretty_abstraction(elem1120) - self.dedent() - self.write(")") - - def pretty_atom(self, msg: logic_pb2.Atom): - flat1129 = self._try_flat(msg, self.pretty_atom) - if flat1129 is not None: - assert flat1129 is not None - self.write(flat1129) - return None - else: - _dollar_dollar = msg - fields1123 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1123 is not None - unwrapped_fields1124 = fields1123 - self.write("(atom") - self.indent_sexp() - self.newline() - field1125 = unwrapped_fields1124[0] - self.pretty_relation_id(field1125) - field1126 = unwrapped_fields1124[1] - if not len(field1126) == 0: - self.newline() - for i1128, elem1127 in enumerate(field1126): - if (i1128 > 0): - self.newline() - self.pretty_term(elem1127) - self.dedent() - self.write(")") - - def pretty_pragma(self, msg: logic_pb2.Pragma): - flat1136 = self._try_flat(msg, self.pretty_pragma) - if flat1136 is not None: - assert flat1136 is not None - self.write(flat1136) - return None - else: - _dollar_dollar = msg - fields1130 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1130 is not None - unwrapped_fields1131 = fields1130 - self.write("(pragma") - self.indent_sexp() - self.newline() - field1132 = unwrapped_fields1131[0] - self.pretty_name(field1132) - field1133 = unwrapped_fields1131[1] - if not len(field1133) == 0: - self.newline() - for i1135, elem1134 in enumerate(field1133): - if (i1135 > 0): - self.newline() - self.pretty_term(elem1134) - self.dedent() - self.write(")") - - def pretty_primitive(self, msg: logic_pb2.Primitive): - flat1152 = self._try_flat(msg, self.pretty_primitive) - if flat1152 is not None: - assert flat1152 is not None - self.write(flat1152) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_eq": - _t1683 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1683 = None - guard_result1151 = _t1683 - if guard_result1151 is not None: - self.pretty_eq(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1684 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1684 = None - guard_result1150 = _t1684 - if guard_result1150 is not None: - self.pretty_lt(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1685 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1685 = None - guard_result1149 = _t1685 - if guard_result1149 is not None: - self.pretty_lt_eq(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1686 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1686 = None - guard_result1148 = _t1686 - if guard_result1148 is not None: - self.pretty_gt(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1687 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1687 = None - guard_result1147 = _t1687 - if guard_result1147 is not None: - self.pretty_gt_eq(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1688 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1688 = None - guard_result1146 = _t1688 - if guard_result1146 is not None: - self.pretty_add(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1689 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1689 = None - guard_result1145 = _t1689 - if guard_result1145 is not None: - self.pretty_minus(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1690 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1690 = None - guard_result1144 = _t1690 - if guard_result1144 is not None: - self.pretty_multiply(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1691 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1691 = None - guard_result1143 = _t1691 - if guard_result1143 is not None: - self.pretty_divide(msg) - else: - _dollar_dollar = msg - fields1137 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1137 is not None - unwrapped_fields1138 = fields1137 - self.write("(primitive") - self.indent_sexp() - self.newline() - field1139 = unwrapped_fields1138[0] - self.pretty_name(field1139) - field1140 = unwrapped_fields1138[1] - if not len(field1140) == 0: - self.newline() - for i1142, elem1141 in enumerate(field1140): - if (i1142 > 0): - self.newline() - self.pretty_rel_term(elem1141) - self.dedent() - self.write(")") - - def pretty_eq(self, msg: logic_pb2.Primitive): - flat1157 = self._try_flat(msg, self.pretty_eq) - if flat1157 is not None: - assert flat1157 is not None - self.write(flat1157) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_eq": - _t1692 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1692 = None - fields1153 = _t1692 - assert fields1153 is not None - unwrapped_fields1154 = fields1153 - self.write("(=") -======= - flat1092 = self._try_flat(msg, self.pretty_var) - if flat1092 is not None: - assert flat1092 is not None - self.write(flat1092) - return None - else: - _dollar_dollar = msg - fields1090 = _dollar_dollar.name - assert fields1090 is not None - unwrapped_fields1091 = fields1090 - self.write(unwrapped_fields1091) - - def pretty_value(self, msg: logic_pb2.Value): - flat1118 = self._try_flat(msg, self.pretty_value) - if flat1118 is not None: - assert flat1118 is not None - self.write(flat1118) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("date_value"): - _t1747 = _dollar_dollar.date_value - else: - _t1747 = None - deconstruct_result1116 = _t1747 - if deconstruct_result1116 is not None: - assert deconstruct_result1116 is not None - unwrapped1117 = deconstruct_result1116 - self.pretty_date(unwrapped1117) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("datetime_value"): - _t1748 = _dollar_dollar.datetime_value - else: - _t1748 = None - deconstruct_result1114 = _t1748 - if deconstruct_result1114 is not None: - assert deconstruct_result1114 is not None - unwrapped1115 = deconstruct_result1114 - self.pretty_datetime(unwrapped1115) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("string_value"): - _t1749 = _dollar_dollar.string_value - else: - _t1749 = None - deconstruct_result1112 = _t1749 - if deconstruct_result1112 is not None: - assert deconstruct_result1112 is not None - unwrapped1113 = deconstruct_result1112 - self.write(self.format_string_value(unwrapped1113)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("int32_value"): - _t1750 = _dollar_dollar.int32_value - else: - _t1750 = None - deconstruct_result1110 = _t1750 - if deconstruct_result1110 is not None: - assert deconstruct_result1110 is not None - unwrapped1111 = deconstruct_result1110 - self.write((str(unwrapped1111) + 'i32')) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("int_value"): - _t1751 = _dollar_dollar.int_value - else: - _t1751 = None - deconstruct_result1108 = _t1751 - if deconstruct_result1108 is not None: - assert deconstruct_result1108 is not None - unwrapped1109 = deconstruct_result1108 - self.write(str(unwrapped1109)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("float32_value"): - _t1752 = _dollar_dollar.float32_value - else: - _t1752 = None - deconstruct_result1106 = _t1752 - if deconstruct_result1106 is not None: - assert deconstruct_result1106 is not None - unwrapped1107 = deconstruct_result1106 - self.write(self.format_float32_literal(unwrapped1107)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("float_value"): - _t1753 = _dollar_dollar.float_value - else: - _t1753 = None - deconstruct_result1104 = _t1753 - if deconstruct_result1104 is not None: - assert deconstruct_result1104 is not None - unwrapped1105 = deconstruct_result1104 - self.write(str(unwrapped1105)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("uint32_value"): - _t1754 = _dollar_dollar.uint32_value - else: - _t1754 = None - deconstruct_result1102 = _t1754 - if deconstruct_result1102 is not None: - assert deconstruct_result1102 is not None - unwrapped1103 = deconstruct_result1102 - self.write((str(unwrapped1103) + 'u32')) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("uint128_value"): - _t1755 = _dollar_dollar.uint128_value - else: - _t1755 = None - deconstruct_result1100 = _t1755 - if deconstruct_result1100 is not None: - assert deconstruct_result1100 is not None - unwrapped1101 = deconstruct_result1100 - self.write(self.format_uint128(unwrapped1101)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("int128_value"): - _t1756 = _dollar_dollar.int128_value - else: - _t1756 = None - deconstruct_result1098 = _t1756 - if deconstruct_result1098 is not None: - assert deconstruct_result1098 is not None - unwrapped1099 = deconstruct_result1098 - self.write(self.format_int128(unwrapped1099)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("decimal_value"): - _t1757 = _dollar_dollar.decimal_value - else: - _t1757 = None - deconstruct_result1096 = _t1757 - if deconstruct_result1096 is not None: - assert deconstruct_result1096 is not None - unwrapped1097 = deconstruct_result1096 - self.write(self.format_decimal(unwrapped1097)) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("boolean_value"): - _t1758 = _dollar_dollar.boolean_value - else: - _t1758 = None - deconstruct_result1094 = _t1758 - if deconstruct_result1094 is not None: - assert deconstruct_result1094 is not None - unwrapped1095 = deconstruct_result1094 - self.pretty_boolean_value(unwrapped1095) - else: - fields1093 = msg - self.write("missing") - - def pretty_date(self, msg: logic_pb2.DateValue): - flat1124 = self._try_flat(msg, self.pretty_date) - if flat1124 is not None: - assert flat1124 is not None - self.write(flat1124) - return None - else: - _dollar_dollar = msg - fields1119 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields1119 is not None - unwrapped_fields1120 = fields1119 - self.write("(date") - self.indent_sexp() - self.newline() - field1121 = unwrapped_fields1120[0] - self.write(str(field1121)) - self.newline() - field1122 = unwrapped_fields1120[1] - self.write(str(field1122)) - self.newline() - field1123 = unwrapped_fields1120[2] - self.write(str(field1123)) - self.dedent() - self.write(")") - - def pretty_datetime(self, msg: logic_pb2.DateTimeValue): - flat1135 = self._try_flat(msg, self.pretty_datetime) - if flat1135 is not None: - assert flat1135 is not None - self.write(flat1135) - return None - else: - _dollar_dollar = msg - fields1125 = (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 fields1125 is not None - unwrapped_fields1126 = fields1125 - self.write("(datetime") - self.indent_sexp() - self.newline() - field1127 = unwrapped_fields1126[0] - self.write(str(field1127)) - self.newline() - field1128 = unwrapped_fields1126[1] - self.write(str(field1128)) - self.newline() - field1129 = unwrapped_fields1126[2] - self.write(str(field1129)) - self.newline() - field1130 = unwrapped_fields1126[3] - self.write(str(field1130)) - self.newline() - field1131 = unwrapped_fields1126[4] - self.write(str(field1131)) - self.newline() - field1132 = unwrapped_fields1126[5] - self.write(str(field1132)) - field1133 = unwrapped_fields1126[6] - if field1133 is not None: - self.newline() - assert field1133 is not None - opt_val1134 = field1133 - self.write(str(opt_val1134)) - self.dedent() - self.write(")") - - def pretty_conjunction(self, msg: logic_pb2.Conjunction): - flat1140 = self._try_flat(msg, self.pretty_conjunction) - if flat1140 is not None: - assert flat1140 is not None - self.write(flat1140) - return None - else: - _dollar_dollar = msg - fields1136 = _dollar_dollar.args - assert fields1136 is not None - unwrapped_fields1137 = fields1136 - self.write("(and") - self.indent_sexp() - if not len(unwrapped_fields1137) == 0: - self.newline() - for i1139, elem1138 in enumerate(unwrapped_fields1137): - if (i1139 > 0): - self.newline() - self.pretty_formula(elem1138) - self.dedent() - self.write(")") - - def pretty_disjunction(self, msg: logic_pb2.Disjunction): - flat1145 = self._try_flat(msg, self.pretty_disjunction) - if flat1145 is not None: - assert flat1145 is not None - self.write(flat1145) - return None - else: - _dollar_dollar = msg - fields1141 = _dollar_dollar.args - assert fields1141 is not None - unwrapped_fields1142 = fields1141 - self.write("(or") - self.indent_sexp() - if not len(unwrapped_fields1142) == 0: - self.newline() - for i1144, elem1143 in enumerate(unwrapped_fields1142): - if (i1144 > 0): - self.newline() - self.pretty_formula(elem1143) - self.dedent() - self.write(")") - - def pretty_not(self, msg: logic_pb2.Not): - flat1148 = self._try_flat(msg, self.pretty_not) - if flat1148 is not None: - assert flat1148 is not None - self.write(flat1148) - return None - else: - _dollar_dollar = msg - fields1146 = _dollar_dollar.arg - assert fields1146 is not None - unwrapped_fields1147 = fields1146 - self.write("(not") - self.indent_sexp() - self.newline() - self.pretty_formula(unwrapped_fields1147) - self.dedent() - self.write(")") - - def pretty_ffi(self, msg: logic_pb2.FFI): - flat1154 = self._try_flat(msg, self.pretty_ffi) - if flat1154 is not None: - assert flat1154 is not None - self.write(flat1154) - return None - else: - _dollar_dollar = msg - fields1149 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - assert fields1149 is not None - unwrapped_fields1150 = fields1149 - self.write("(ffi") ->>>>>>> origin/main - self.indent_sexp() - self.newline() - field1151 = unwrapped_fields1150[0] - self.pretty_name(field1151) - self.newline() - field1152 = unwrapped_fields1150[1] - self.pretty_ffi_args(field1152) - self.newline() - field1153 = unwrapped_fields1150[2] - self.pretty_terms(field1153) - self.dedent() - self.write(")") - -<<<<<<< HEAD - def pretty_lt(self, msg: logic_pb2.Primitive): - flat1162 = self._try_flat(msg, self.pretty_lt) - if flat1162 is not None: - assert flat1162 is not None - self.write(flat1162) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1693 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1693 = None - fields1158 = _t1693 - assert fields1158 is not None - unwrapped_fields1159 = fields1158 - self.write("(<") -======= - def pretty_name(self, msg: str): - flat1156 = self._try_flat(msg, self.pretty_name) - if flat1156 is not None: - assert flat1156 is not None - self.write(flat1156) - return None - else: - fields1155 = msg - self.write(":") - self.write(fields1155) - - def pretty_ffi_args(self, msg: Sequence[logic_pb2.Abstraction]): - flat1160 = self._try_flat(msg, self.pretty_ffi_args) - if flat1160 is not None: - assert flat1160 is not None - self.write(flat1160) - return None - else: - fields1157 = msg - self.write("(args") ->>>>>>> origin/main - self.indent_sexp() - if not len(fields1157) == 0: - self.newline() - for i1159, elem1158 in enumerate(fields1157): - if (i1159 > 0): - self.newline() - self.pretty_abstraction(elem1158) - self.dedent() - self.write(")") - -<<<<<<< HEAD - def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat1167 = self._try_flat(msg, self.pretty_lt_eq) -======= - def pretty_atom(self, msg: logic_pb2.Atom): - flat1167 = self._try_flat(msg, self.pretty_atom) ->>>>>>> origin/main - if flat1167 is not None: - assert flat1167 is not None - self.write(flat1167) - return None - else: - _dollar_dollar = msg -<<<<<<< HEAD - if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1694 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1694 = None - fields1163 = _t1694 - assert fields1163 is not None - unwrapped_fields1164 = fields1163 - self.write("(<=") -======= - fields1161 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1161 is not None - unwrapped_fields1162 = fields1161 - self.write("(atom") ->>>>>>> origin/main - self.indent_sexp() - self.newline() - field1163 = unwrapped_fields1162[0] - self.pretty_relation_id(field1163) - field1164 = unwrapped_fields1162[1] - if not len(field1164) == 0: - self.newline() - for i1166, elem1165 in enumerate(field1164): - if (i1166 > 0): - self.newline() - self.pretty_term(elem1165) - self.dedent() - self.write(")") - -<<<<<<< HEAD - def pretty_gt(self, msg: logic_pb2.Primitive): - flat1172 = self._try_flat(msg, self.pretty_gt) - if flat1172 is not None: - assert flat1172 is not None - self.write(flat1172) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1695 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1695 = None - fields1168 = _t1695 - assert fields1168 is not None - unwrapped_fields1169 = fields1168 - self.write("(>") -======= - def pretty_pragma(self, msg: logic_pb2.Pragma): - flat1174 = self._try_flat(msg, self.pretty_pragma) - if flat1174 is not None: - assert flat1174 is not None - self.write(flat1174) - return None - else: - _dollar_dollar = msg - fields1168 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1168 is not None - unwrapped_fields1169 = fields1168 - self.write("(pragma") ->>>>>>> origin/main - self.indent_sexp() - self.newline() - field1170 = unwrapped_fields1169[0] - self.pretty_name(field1170) - field1171 = unwrapped_fields1169[1] - if not len(field1171) == 0: - self.newline() - for i1173, elem1172 in enumerate(field1171): - if (i1173 > 0): - self.newline() - self.pretty_term(elem1172) - self.dedent() - self.write(")") - -<<<<<<< HEAD - def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat1177 = self._try_flat(msg, self.pretty_gt_eq) - if flat1177 is not None: - assert flat1177 is not None - self.write(flat1177) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1696 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1696 = None - fields1173 = _t1696 - assert fields1173 is not None - unwrapped_fields1174 = fields1173 - self.write("(>=") - self.indent_sexp() - self.newline() - field1175 = unwrapped_fields1174[0] - self.pretty_term(field1175) - self.newline() - field1176 = unwrapped_fields1174[1] - self.pretty_term(field1176) - self.dedent() - self.write(")") - - def pretty_add(self, msg: logic_pb2.Primitive): - flat1183 = self._try_flat(msg, self.pretty_add) - if flat1183 is not None: - assert flat1183 is not None - self.write(flat1183) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1697 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1697 = None - fields1178 = _t1697 - assert fields1178 is not None - unwrapped_fields1179 = fields1178 - self.write("(+") - self.indent_sexp() - self.newline() - field1180 = unwrapped_fields1179[0] - self.pretty_term(field1180) - self.newline() - field1181 = unwrapped_fields1179[1] - self.pretty_term(field1181) - self.newline() - field1182 = unwrapped_fields1179[2] - self.pretty_term(field1182) - self.dedent() - self.write(")") - - def pretty_minus(self, msg: logic_pb2.Primitive): - flat1189 = self._try_flat(msg, self.pretty_minus) - if flat1189 is not None: - assert flat1189 is not None - self.write(flat1189) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1698 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1698 = None - fields1184 = _t1698 - assert fields1184 is not None - unwrapped_fields1185 = fields1184 - self.write("(-") - self.indent_sexp() - self.newline() - field1186 = unwrapped_fields1185[0] - self.pretty_term(field1186) - self.newline() - field1187 = unwrapped_fields1185[1] - self.pretty_term(field1187) - self.newline() - field1188 = unwrapped_fields1185[2] - self.pretty_term(field1188) - self.dedent() - self.write(")") - - def pretty_multiply(self, msg: logic_pb2.Primitive): - flat1195 = self._try_flat(msg, self.pretty_multiply) - if flat1195 is not None: - assert flat1195 is not None - self.write(flat1195) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1699 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1699 = None - fields1190 = _t1699 - assert fields1190 is not None - unwrapped_fields1191 = fields1190 - self.write("(*") - self.indent_sexp() - self.newline() - field1192 = unwrapped_fields1191[0] - self.pretty_term(field1192) - self.newline() - field1193 = unwrapped_fields1191[1] - self.pretty_term(field1193) - self.newline() - field1194 = unwrapped_fields1191[2] - self.pretty_term(field1194) - self.dedent() - self.write(")") - - def pretty_divide(self, msg: logic_pb2.Primitive): - flat1201 = self._try_flat(msg, self.pretty_divide) - if flat1201 is not None: - assert flat1201 is not None - self.write(flat1201) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1700 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1700 = None - fields1196 = _t1700 - assert fields1196 is not None - unwrapped_fields1197 = fields1196 - self.write("(/") -======= - def pretty_primitive(self, msg: logic_pb2.Primitive): - flat1190 = self._try_flat(msg, self.pretty_primitive) - if flat1190 is not None: - assert flat1190 is not None - self.write(flat1190) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_eq": - _t1759 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1759 = None - guard_result1189 = _t1759 - if guard_result1189 is not None: - self.pretty_eq(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1760 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1760 = None - guard_result1188 = _t1760 - if guard_result1188 is not None: - self.pretty_lt(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1761 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1761 = None - guard_result1187 = _t1761 - if guard_result1187 is not None: - self.pretty_lt_eq(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1762 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1762 = None - guard_result1186 = _t1762 - if guard_result1186 is not None: - self.pretty_gt(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1763 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1763 = None - guard_result1185 = _t1763 - if guard_result1185 is not None: - self.pretty_gt_eq(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1764 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1764 = None - guard_result1184 = _t1764 - if guard_result1184 is not None: - self.pretty_add(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1765 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1765 = None - guard_result1183 = _t1765 - if guard_result1183 is not None: - self.pretty_minus(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1766 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1766 = None - guard_result1182 = _t1766 - if guard_result1182 is not None: - self.pretty_multiply(msg) - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1767 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1767 = None - guard_result1181 = _t1767 - if guard_result1181 is not None: - self.pretty_divide(msg) - else: - _dollar_dollar = msg - fields1175 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1175 is not None - unwrapped_fields1176 = fields1175 - self.write("(primitive") - self.indent_sexp() - self.newline() - field1177 = unwrapped_fields1176[0] - self.pretty_name(field1177) - field1178 = unwrapped_fields1176[1] - if not len(field1178) == 0: - self.newline() - for i1180, elem1179 in enumerate(field1178): - if (i1180 > 0): - self.newline() - self.pretty_rel_term(elem1179) - self.dedent() - self.write(")") - - def pretty_eq(self, msg: logic_pb2.Primitive): - flat1195 = self._try_flat(msg, self.pretty_eq) - if flat1195 is not None: - assert flat1195 is not None - self.write(flat1195) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_eq": - _t1768 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1768 = None - fields1191 = _t1768 - assert fields1191 is not None - unwrapped_fields1192 = fields1191 - self.write("(=") - self.indent_sexp() - self.newline() - field1193 = unwrapped_fields1192[0] - self.pretty_term(field1193) - self.newline() - field1194 = unwrapped_fields1192[1] - self.pretty_term(field1194) - self.dedent() - self.write(")") - - def pretty_lt(self, msg: logic_pb2.Primitive): - flat1200 = self._try_flat(msg, self.pretty_lt) - if flat1200 is not None: - assert flat1200 is not None - self.write(flat1200) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1769 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1769 = None - fields1196 = _t1769 - assert fields1196 is not None - unwrapped_fields1197 = fields1196 - self.write("(<") ->>>>>>> origin/main - self.indent_sexp() - self.newline() - field1198 = unwrapped_fields1197[0] - self.pretty_term(field1198) - self.newline() - field1199 = unwrapped_fields1197[1] - self.pretty_term(field1199) -<<<<<<< HEAD - self.newline() - field1200 = unwrapped_fields1197[2] - self.pretty_term(field1200) - self.dedent() - self.write(")") - - def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat1206 = self._try_flat(msg, self.pretty_rel_term) - if flat1206 is not None: - assert flat1206 is not None - self.write(flat1206) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("specialized_value"): - _t1701 = _dollar_dollar.specialized_value - else: - _t1701 = None - deconstruct_result1204 = _t1701 - if deconstruct_result1204 is not None: - assert deconstruct_result1204 is not None - unwrapped1205 = deconstruct_result1204 - self.pretty_specialized_value(unwrapped1205) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("term"): - _t1702 = _dollar_dollar.term - else: - _t1702 = None - deconstruct_result1202 = _t1702 - if deconstruct_result1202 is not None: - assert deconstruct_result1202 is not None - unwrapped1203 = deconstruct_result1202 - self.pretty_term(unwrapped1203) - else: - raise ParseError("No matching rule for rel_term") - - def pretty_specialized_value(self, msg: logic_pb2.Value): - flat1208 = self._try_flat(msg, self.pretty_specialized_value) - if flat1208 is not None: - assert flat1208 is not None - self.write(flat1208) - return None - else: - fields1207 = msg - self.write("#") - self.pretty_raw_value(fields1207) - - def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat1215 = self._try_flat(msg, self.pretty_rel_atom) -======= - self.dedent() - self.write(")") - - def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat1205 = self._try_flat(msg, self.pretty_lt_eq) - if flat1205 is not None: - assert flat1205 is not None - self.write(flat1205) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1770 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1770 = None - fields1201 = _t1770 - assert fields1201 is not None - unwrapped_fields1202 = fields1201 - self.write("(<=") - self.indent_sexp() - self.newline() - field1203 = unwrapped_fields1202[0] - self.pretty_term(field1203) - self.newline() - field1204 = unwrapped_fields1202[1] - self.pretty_term(field1204) - self.dedent() - self.write(")") - - def pretty_gt(self, msg: logic_pb2.Primitive): - flat1210 = self._try_flat(msg, self.pretty_gt) - if flat1210 is not None: - assert flat1210 is not None - self.write(flat1210) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1771 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1771 = None - fields1206 = _t1771 - assert fields1206 is not None - unwrapped_fields1207 = fields1206 - self.write("(>") - self.indent_sexp() - self.newline() - field1208 = unwrapped_fields1207[0] - self.pretty_term(field1208) - self.newline() - field1209 = unwrapped_fields1207[1] - self.pretty_term(field1209) - self.dedent() - self.write(")") - - def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat1215 = self._try_flat(msg, self.pretty_gt_eq) ->>>>>>> origin/main - if flat1215 is not None: - assert flat1215 is not None - self.write(flat1215) - return None - else: - _dollar_dollar = msg -<<<<<<< HEAD - fields1209 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1209 is not None - unwrapped_fields1210 = fields1209 - self.write("(relatom") - self.indent_sexp() - self.newline() - field1211 = unwrapped_fields1210[0] - self.pretty_name(field1211) - field1212 = unwrapped_fields1210[1] - if not len(field1212) == 0: - self.newline() - for i1214, elem1213 in enumerate(field1212): - if (i1214 > 0): - self.newline() - self.pretty_rel_term(elem1213) - self.dedent() - self.write(")") - - def pretty_cast(self, msg: logic_pb2.Cast): - flat1220 = self._try_flat(msg, self.pretty_cast) - if flat1220 is not None: - assert flat1220 is not None - self.write(flat1220) - return None - else: - _dollar_dollar = msg - fields1216 = (_dollar_dollar.input, _dollar_dollar.result,) - assert fields1216 is not None - unwrapped_fields1217 = fields1216 - self.write("(cast") -======= - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1772 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) - else: - _t1772 = None - fields1211 = _t1772 - assert fields1211 is not None - unwrapped_fields1212 = fields1211 - self.write("(>=") ->>>>>>> origin/main - self.indent_sexp() - self.newline() - field1218 = unwrapped_fields1217[0] - self.pretty_term(field1218) - self.newline() - field1219 = unwrapped_fields1217[1] - self.pretty_term(field1219) - self.dedent() - self.write(")") - -<<<<<<< HEAD - def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1224 = self._try_flat(msg, self.pretty_attrs) - if flat1224 is not None: - assert flat1224 is not None - self.write(flat1224) - return None - else: - fields1221 = msg - self.write("(attrs") - self.indent_sexp() - if not len(fields1221) == 0: - self.newline() - for i1223, elem1222 in enumerate(fields1221): - if (i1223 > 0): - self.newline() - self.pretty_attribute(elem1222) -======= - def pretty_add(self, msg: logic_pb2.Primitive): - flat1221 = self._try_flat(msg, self.pretty_add) - if flat1221 is not None: - assert flat1221 is not None - self.write(flat1221) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_add_monotype": - _t1773 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1773 = None - fields1216 = _t1773 - assert fields1216 is not None - unwrapped_fields1217 = fields1216 - self.write("(+") - self.indent_sexp() - self.newline() - field1218 = unwrapped_fields1217[0] - self.pretty_term(field1218) - self.newline() - field1219 = unwrapped_fields1217[1] - self.pretty_term(field1219) - self.newline() - field1220 = unwrapped_fields1217[2] - self.pretty_term(field1220) - self.dedent() - self.write(")") - - def pretty_minus(self, msg: logic_pb2.Primitive): - flat1227 = self._try_flat(msg, self.pretty_minus) - if flat1227 is not None: - assert flat1227 is not None - self.write(flat1227) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1774 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1774 = None - fields1222 = _t1774 - assert fields1222 is not None - unwrapped_fields1223 = fields1222 - self.write("(-") - self.indent_sexp() - self.newline() - field1224 = unwrapped_fields1223[0] - self.pretty_term(field1224) - self.newline() - field1225 = unwrapped_fields1223[1] - self.pretty_term(field1225) - self.newline() - field1226 = unwrapped_fields1223[2] - self.pretty_term(field1226) - self.dedent() - self.write(")") - - def pretty_multiply(self, msg: logic_pb2.Primitive): - flat1233 = self._try_flat(msg, self.pretty_multiply) - if flat1233 is not None: - assert flat1233 is not None - self.write(flat1233) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_multiply_monotype": - _t1775 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1775 = None - fields1228 = _t1775 - assert fields1228 is not None - unwrapped_fields1229 = fields1228 - self.write("(*") - self.indent_sexp() - self.newline() - field1230 = unwrapped_fields1229[0] - self.pretty_term(field1230) - self.newline() - field1231 = unwrapped_fields1229[1] - self.pretty_term(field1231) - self.newline() - field1232 = unwrapped_fields1229[2] - self.pretty_term(field1232) - self.dedent() - self.write(")") - - def pretty_divide(self, msg: logic_pb2.Primitive): - flat1239 = self._try_flat(msg, self.pretty_divide) - if flat1239 is not None: - assert flat1239 is not None - self.write(flat1239) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_divide_monotype": - _t1776 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) - else: - _t1776 = None - fields1234 = _t1776 - assert fields1234 is not None - unwrapped_fields1235 = fields1234 - self.write("(/") - self.indent_sexp() - self.newline() - field1236 = unwrapped_fields1235[0] - self.pretty_term(field1236) - self.newline() - field1237 = unwrapped_fields1235[1] - self.pretty_term(field1237) - self.newline() - field1238 = unwrapped_fields1235[2] - self.pretty_term(field1238) - self.dedent() - self.write(")") - - def pretty_rel_term(self, msg: logic_pb2.RelTerm): - flat1244 = self._try_flat(msg, self.pretty_rel_term) - if flat1244 is not None: - assert flat1244 is not None - self.write(flat1244) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("specialized_value"): - _t1777 = _dollar_dollar.specialized_value - else: - _t1777 = None - deconstruct_result1242 = _t1777 - if deconstruct_result1242 is not None: - assert deconstruct_result1242 is not None - unwrapped1243 = deconstruct_result1242 - self.pretty_specialized_value(unwrapped1243) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("term"): - _t1778 = _dollar_dollar.term - else: - _t1778 = None - deconstruct_result1240 = _t1778 - if deconstruct_result1240 is not None: - assert deconstruct_result1240 is not None - unwrapped1241 = deconstruct_result1240 - self.pretty_term(unwrapped1241) - else: - raise ParseError("No matching rule for rel_term") - - def pretty_specialized_value(self, msg: logic_pb2.Value): - flat1246 = self._try_flat(msg, self.pretty_specialized_value) - if flat1246 is not None: - assert flat1246 is not None - self.write(flat1246) - return None - else: - fields1245 = msg - self.write("#") - self.pretty_raw_value(fields1245) - - def pretty_rel_atom(self, msg: logic_pb2.RelAtom): - flat1253 = self._try_flat(msg, self.pretty_rel_atom) - if flat1253 is not None: - assert flat1253 is not None - self.write(flat1253) - return None - else: - _dollar_dollar = msg - fields1247 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1247 is not None - unwrapped_fields1248 = fields1247 - self.write("(relatom") - self.indent_sexp() - self.newline() - field1249 = unwrapped_fields1248[0] - self.pretty_name(field1249) - field1250 = unwrapped_fields1248[1] - if not len(field1250) == 0: - self.newline() - for i1252, elem1251 in enumerate(field1250): - if (i1252 > 0): - self.newline() - self.pretty_rel_term(elem1251) - self.dedent() - self.write(")") - - def pretty_cast(self, msg: logic_pb2.Cast): - flat1258 = self._try_flat(msg, self.pretty_cast) - if flat1258 is not None: - assert flat1258 is not None - self.write(flat1258) - return None - else: - _dollar_dollar = msg - fields1254 = (_dollar_dollar.input, _dollar_dollar.result,) - assert fields1254 is not None - unwrapped_fields1255 = fields1254 - self.write("(cast") - self.indent_sexp() - self.newline() - field1256 = unwrapped_fields1255[0] - self.pretty_term(field1256) - self.newline() - field1257 = unwrapped_fields1255[1] - self.pretty_term(field1257) - self.dedent() - self.write(")") - - def pretty_attrs(self, msg: Sequence[logic_pb2.Attribute]): - flat1262 = self._try_flat(msg, self.pretty_attrs) - if flat1262 is not None: - assert flat1262 is not None - self.write(flat1262) - return None - else: - fields1259 = msg - self.write("(attrs") - self.indent_sexp() - if not len(fields1259) == 0: - self.newline() - for i1261, elem1260 in enumerate(fields1259): - if (i1261 > 0): - self.newline() - self.pretty_attribute(elem1260) ->>>>>>> origin/main - self.dedent() - self.write(")") - - def pretty_attribute(self, msg: logic_pb2.Attribute): -<<<<<<< HEAD - flat1231 = self._try_flat(msg, self.pretty_attribute) - if flat1231 is not None: - assert flat1231 is not None - self.write(flat1231) - return None - else: - _dollar_dollar = msg - fields1225 = (_dollar_dollar.name, _dollar_dollar.args,) - assert fields1225 is not None - unwrapped_fields1226 = fields1225 - self.write("(attribute") - self.indent_sexp() - self.newline() - field1227 = unwrapped_fields1226[0] - self.pretty_name(field1227) - field1228 = unwrapped_fields1226[1] - if not len(field1228) == 0: - self.newline() - for i1230, elem1229 in enumerate(field1228): - if (i1230 > 0): - self.newline() - self.pretty_raw_value(elem1229) -======= - flat1269 = self._try_flat(msg, self.pretty_attribute) - if flat1269 is not None: - assert flat1269 is not None - self.write(flat1269) - return None - else: - _dollar_dollar = msg - fields1263 = (_dollar_dollar.name, _dollar_dollar.args,) - assert fields1263 is not None - unwrapped_fields1264 = fields1263 - self.write("(attribute") - self.indent_sexp() - self.newline() - field1265 = unwrapped_fields1264[0] - self.pretty_name(field1265) - field1266 = unwrapped_fields1264[1] - if not len(field1266) == 0: - self.newline() - for i1268, elem1267 in enumerate(field1266): - if (i1268 > 0): - self.newline() - self.pretty_raw_value(elem1267) ->>>>>>> origin/main - self.dedent() - self.write(")") - - def pretty_algorithm(self, msg: logic_pb2.Algorithm): -<<<<<<< HEAD - flat1240 = self._try_flat(msg, self.pretty_algorithm) - if flat1240 is not None: - assert flat1240 is not None - self.write(flat1240) - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: - _t1703 = _dollar_dollar.attrs - else: - _t1703 = None - fields1232 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1703,) - assert fields1232 is not None - unwrapped_fields1233 = fields1232 - self.write("(algorithm") - self.indent_sexp() - field1234 = unwrapped_fields1233[0] - if not len(field1234) == 0: - self.newline() - for i1236, elem1235 in enumerate(field1234): - if (i1236 > 0): - self.newline() - self.pretty_relation_id(elem1235) - self.newline() - field1237 = unwrapped_fields1233[1] - self.pretty_script(field1237) - field1238 = unwrapped_fields1233[2] - if field1238 is not None: - self.newline() - assert field1238 is not None - opt_val1239 = field1238 - self.pretty_attrs(opt_val1239) - self.dedent() - self.write(")") - - def pretty_script(self, msg: logic_pb2.Script): - flat1245 = self._try_flat(msg, self.pretty_script) - if flat1245 is not None: - assert flat1245 is not None - self.write(flat1245) - return None - else: - _dollar_dollar = msg - fields1241 = _dollar_dollar.constructs - assert fields1241 is not None - unwrapped_fields1242 = fields1241 - self.write("(script") - self.indent_sexp() - if not len(unwrapped_fields1242) == 0: - self.newline() - for i1244, elem1243 in enumerate(unwrapped_fields1242): - if (i1244 > 0): - self.newline() - self.pretty_construct(elem1243) -======= - flat1278 = self._try_flat(msg, self.pretty_algorithm) - if flat1278 is not None: - assert flat1278 is not None - self.write(flat1278) - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: - _t1779 = _dollar_dollar.attrs - else: - _t1779 = None - fields1270 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1779,) - assert fields1270 is not None - unwrapped_fields1271 = fields1270 - self.write("(algorithm") - self.indent_sexp() - field1272 = unwrapped_fields1271[0] - if not len(field1272) == 0: - self.newline() - for i1274, elem1273 in enumerate(field1272): - if (i1274 > 0): - self.newline() - self.pretty_relation_id(elem1273) - self.newline() - field1275 = unwrapped_fields1271[1] - self.pretty_script(field1275) - field1276 = unwrapped_fields1271[2] - if field1276 is not None: - self.newline() - assert field1276 is not None - opt_val1277 = field1276 - self.pretty_attrs(opt_val1277) - self.dedent() - self.write(")") - - def pretty_script(self, msg: logic_pb2.Script): - flat1283 = self._try_flat(msg, self.pretty_script) - if flat1283 is not None: - assert flat1283 is not None - self.write(flat1283) - return None - else: - _dollar_dollar = msg - fields1279 = _dollar_dollar.constructs - assert fields1279 is not None - unwrapped_fields1280 = fields1279 - self.write("(script") - self.indent_sexp() - if not len(unwrapped_fields1280) == 0: - self.newline() - for i1282, elem1281 in enumerate(unwrapped_fields1280): - if (i1282 > 0): - self.newline() - self.pretty_construct(elem1281) ->>>>>>> origin/main - self.dedent() - self.write(")") - - def pretty_construct(self, msg: logic_pb2.Construct): -<<<<<<< HEAD - flat1250 = self._try_flat(msg, self.pretty_construct) - if flat1250 is not None: - assert flat1250 is not None - self.write(flat1250) -======= - flat1288 = self._try_flat(msg, self.pretty_construct) - if flat1288 is not None: - assert flat1288 is not None - self.write(flat1288) ->>>>>>> origin/main - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("loop"): -<<<<<<< HEAD - _t1704 = _dollar_dollar.loop - else: - _t1704 = None - deconstruct_result1248 = _t1704 - if deconstruct_result1248 is not None: - assert deconstruct_result1248 is not None - unwrapped1249 = deconstruct_result1248 - self.pretty_loop(unwrapped1249) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("instruction"): - _t1705 = _dollar_dollar.instruction - else: - _t1705 = None - deconstruct_result1246 = _t1705 - if deconstruct_result1246 is not None: - assert deconstruct_result1246 is not None - unwrapped1247 = deconstruct_result1246 - self.pretty_instruction(unwrapped1247) -======= - _t1780 = _dollar_dollar.loop - else: - _t1780 = None - deconstruct_result1286 = _t1780 - if deconstruct_result1286 is not None: - assert deconstruct_result1286 is not None - unwrapped1287 = deconstruct_result1286 - self.pretty_loop(unwrapped1287) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("instruction"): - _t1781 = _dollar_dollar.instruction - else: - _t1781 = None - deconstruct_result1284 = _t1781 - if deconstruct_result1284 is not None: - assert deconstruct_result1284 is not None - unwrapped1285 = deconstruct_result1284 - self.pretty_instruction(unwrapped1285) ->>>>>>> origin/main - else: - raise ParseError("No matching rule for construct") - - def pretty_loop(self, msg: logic_pb2.Loop): -<<<<<<< HEAD - flat1257 = self._try_flat(msg, self.pretty_loop) - if flat1257 is not None: - assert flat1257 is not None - self.write(flat1257) -======= - flat1295 = self._try_flat(msg, self.pretty_loop) - if flat1295 is not None: - assert flat1295 is not None - self.write(flat1295) ->>>>>>> origin/main - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: -<<<<<<< HEAD - _t1706 = _dollar_dollar.attrs - else: - _t1706 = None - fields1251 = (_dollar_dollar.init, _dollar_dollar.body, _t1706,) - assert fields1251 is not None - unwrapped_fields1252 = fields1251 - self.write("(loop") - self.indent_sexp() - self.newline() - field1253 = unwrapped_fields1252[0] - self.pretty_init(field1253) - self.newline() - field1254 = unwrapped_fields1252[1] - self.pretty_script(field1254) - field1255 = unwrapped_fields1252[2] - if field1255 is not None: - self.newline() - assert field1255 is not None - opt_val1256 = field1255 - self.pretty_attrs(opt_val1256) -======= - _t1782 = _dollar_dollar.attrs - else: - _t1782 = None - fields1289 = (_dollar_dollar.init, _dollar_dollar.body, _t1782,) - assert fields1289 is not None - unwrapped_fields1290 = fields1289 - self.write("(loop") - self.indent_sexp() - self.newline() - field1291 = unwrapped_fields1290[0] - self.pretty_init(field1291) - self.newline() - field1292 = unwrapped_fields1290[1] - self.pretty_script(field1292) - field1293 = unwrapped_fields1290[2] - if field1293 is not None: - self.newline() - assert field1293 is not None - opt_val1294 = field1293 - self.pretty_attrs(opt_val1294) ->>>>>>> origin/main - self.dedent() - self.write(")") - - def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): -<<<<<<< HEAD - flat1261 = self._try_flat(msg, self.pretty_init) - if flat1261 is not None: - assert flat1261 is not None - self.write(flat1261) - return None - else: - fields1258 = msg - self.write("(init") - self.indent_sexp() - if not len(fields1258) == 0: - self.newline() - for i1260, elem1259 in enumerate(fields1258): - if (i1260 > 0): - self.newline() - self.pretty_instruction(elem1259) -======= - flat1299 = self._try_flat(msg, self.pretty_init) - if flat1299 is not None: - assert flat1299 is not None - self.write(flat1299) - return None - else: - fields1296 = msg - self.write("(init") - self.indent_sexp() - if not len(fields1296) == 0: - self.newline() - for i1298, elem1297 in enumerate(fields1296): - if (i1298 > 0): - self.newline() - self.pretty_instruction(elem1297) ->>>>>>> origin/main - self.dedent() - self.write(")") - - def pretty_instruction(self, msg: logic_pb2.Instruction): -<<<<<<< HEAD - flat1272 = self._try_flat(msg, self.pretty_instruction) - if flat1272 is not None: - assert flat1272 is not None - self.write(flat1272) -======= - flat1310 = self._try_flat(msg, self.pretty_instruction) - if flat1310 is not None: - assert flat1310 is not None - self.write(flat1310) ->>>>>>> origin/main - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("assign"): -<<<<<<< HEAD - _t1707 = _dollar_dollar.assign - else: - _t1707 = None - deconstruct_result1270 = _t1707 - if deconstruct_result1270 is not None: - assert deconstruct_result1270 is not None - unwrapped1271 = deconstruct_result1270 - self.pretty_assign(unwrapped1271) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("upsert"): - _t1708 = _dollar_dollar.upsert - else: - _t1708 = None - deconstruct_result1268 = _t1708 - if deconstruct_result1268 is not None: - assert deconstruct_result1268 is not None - unwrapped1269 = deconstruct_result1268 - self.pretty_upsert(unwrapped1269) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("break"): - _t1709 = getattr(_dollar_dollar, 'break') - else: - _t1709 = None - deconstruct_result1266 = _t1709 - if deconstruct_result1266 is not None: - assert deconstruct_result1266 is not None - unwrapped1267 = deconstruct_result1266 - self.pretty_break(unwrapped1267) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("monoid_def"): - _t1710 = _dollar_dollar.monoid_def - else: - _t1710 = None - deconstruct_result1264 = _t1710 - if deconstruct_result1264 is not None: - assert deconstruct_result1264 is not None - unwrapped1265 = deconstruct_result1264 - self.pretty_monoid_def(unwrapped1265) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("monus_def"): - _t1711 = _dollar_dollar.monus_def - else: - _t1711 = None - deconstruct_result1262 = _t1711 - if deconstruct_result1262 is not None: - assert deconstruct_result1262 is not None - unwrapped1263 = deconstruct_result1262 - self.pretty_monus_def(unwrapped1263) -======= - _t1783 = _dollar_dollar.assign - else: - _t1783 = None - deconstruct_result1308 = _t1783 - if deconstruct_result1308 is not None: - assert deconstruct_result1308 is not None - unwrapped1309 = deconstruct_result1308 - self.pretty_assign(unwrapped1309) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("upsert"): - _t1784 = _dollar_dollar.upsert - else: - _t1784 = None - deconstruct_result1306 = _t1784 - if deconstruct_result1306 is not None: - assert deconstruct_result1306 is not None - unwrapped1307 = deconstruct_result1306 - self.pretty_upsert(unwrapped1307) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("break"): - _t1785 = getattr(_dollar_dollar, 'break') - else: - _t1785 = None - deconstruct_result1304 = _t1785 - if deconstruct_result1304 is not None: - assert deconstruct_result1304 is not None - unwrapped1305 = deconstruct_result1304 - self.pretty_break(unwrapped1305) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("monoid_def"): - _t1786 = _dollar_dollar.monoid_def - else: - _t1786 = None - deconstruct_result1302 = _t1786 - if deconstruct_result1302 is not None: - assert deconstruct_result1302 is not None - unwrapped1303 = deconstruct_result1302 - self.pretty_monoid_def(unwrapped1303) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("monus_def"): - _t1787 = _dollar_dollar.monus_def - else: - _t1787 = None - deconstruct_result1300 = _t1787 - if deconstruct_result1300 is not None: - assert deconstruct_result1300 is not None - unwrapped1301 = deconstruct_result1300 - self.pretty_monus_def(unwrapped1301) ->>>>>>> origin/main - else: - raise ParseError("No matching rule for instruction") - - def pretty_assign(self, msg: logic_pb2.Assign): -<<<<<<< HEAD - flat1279 = self._try_flat(msg, self.pretty_assign) - if flat1279 is not None: - assert flat1279 is not None - self.write(flat1279) -======= - flat1317 = self._try_flat(msg, self.pretty_assign) - if flat1317 is not None: - assert flat1317 is not None - self.write(flat1317) - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: - _t1788 = _dollar_dollar.attrs - else: - _t1788 = None - fields1311 = (_dollar_dollar.name, _dollar_dollar.body, _t1788,) - assert fields1311 is not None - unwrapped_fields1312 = fields1311 - self.write("(assign") - self.indent_sexp() - self.newline() - field1313 = unwrapped_fields1312[0] - self.pretty_relation_id(field1313) - self.newline() - field1314 = unwrapped_fields1312[1] - self.pretty_abstraction(field1314) - field1315 = unwrapped_fields1312[2] - if field1315 is not None: - self.newline() - assert field1315 is not None - opt_val1316 = field1315 - self.pretty_attrs(opt_val1316) - self.dedent() - self.write(")") - - def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1324 = self._try_flat(msg, self.pretty_upsert) - if flat1324 is not None: - assert flat1324 is not None - self.write(flat1324) ->>>>>>> origin/main - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: -<<<<<<< HEAD - _t1712 = _dollar_dollar.attrs - else: - _t1712 = None - fields1273 = (_dollar_dollar.name, _dollar_dollar.body, _t1712,) - assert fields1273 is not None - unwrapped_fields1274 = fields1273 - self.write("(assign") - self.indent_sexp() - self.newline() - field1275 = unwrapped_fields1274[0] - self.pretty_relation_id(field1275) - self.newline() - field1276 = unwrapped_fields1274[1] - self.pretty_abstraction(field1276) - field1277 = unwrapped_fields1274[2] - if field1277 is not None: - self.newline() - assert field1277 is not None - opt_val1278 = field1277 - self.pretty_attrs(opt_val1278) - self.dedent() - self.write(")") - - def pretty_upsert(self, msg: logic_pb2.Upsert): - flat1286 = self._try_flat(msg, self.pretty_upsert) - 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: - _t1713 = _dollar_dollar.attrs - else: - _t1713 = None - fields1280 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1713,) - assert fields1280 is not None - unwrapped_fields1281 = fields1280 - self.write("(upsert") - self.indent_sexp() - self.newline() - field1282 = unwrapped_fields1281[0] - self.pretty_relation_id(field1282) - self.newline() - field1283 = unwrapped_fields1281[1] - self.pretty_abstraction_with_arity(field1283) - field1284 = unwrapped_fields1281[2] - if field1284 is not None: - self.newline() - assert field1284 is not None - opt_val1285 = field1284 - self.pretty_attrs(opt_val1285) - self.dedent() - self.write(")") - - def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1291 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1291 is not None: - assert flat1291 is not None - self.write(flat1291) - return None - else: - _dollar_dollar = msg - _t1714 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - fields1287 = (_t1714, _dollar_dollar[0].value,) - assert fields1287 is not None - unwrapped_fields1288 = fields1287 - self.write("(") - self.indent() - field1289 = unwrapped_fields1288[0] - self.pretty_bindings(field1289) - self.newline() - field1290 = unwrapped_fields1288[1] - self.pretty_formula(field1290) - self.dedent() - self.write(")") - - def pretty_break(self, msg: logic_pb2.Break): - flat1298 = self._try_flat(msg, self.pretty_break) - if flat1298 is not None: - assert flat1298 is not None - self.write(flat1298) - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: - _t1715 = _dollar_dollar.attrs - else: - _t1715 = None - fields1292 = (_dollar_dollar.name, _dollar_dollar.body, _t1715,) - assert fields1292 is not None - unwrapped_fields1293 = fields1292 - self.write("(break") - self.indent_sexp() - self.newline() - field1294 = unwrapped_fields1293[0] - self.pretty_relation_id(field1294) - self.newline() - field1295 = unwrapped_fields1293[1] - self.pretty_abstraction(field1295) - field1296 = unwrapped_fields1293[2] - if field1296 is not None: - self.newline() - assert field1296 is not None - opt_val1297 = field1296 - self.pretty_attrs(opt_val1297) - self.dedent() - self.write(")") - - def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1306 = self._try_flat(msg, self.pretty_monoid_def) - if flat1306 is not None: - assert flat1306 is not None - self.write(flat1306) - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: - _t1716 = _dollar_dollar.attrs - else: - _t1716 = None - fields1299 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1716,) - assert fields1299 is not None - unwrapped_fields1300 = fields1299 - self.write("(monoid") - self.indent_sexp() - self.newline() - field1301 = unwrapped_fields1300[0] - self.pretty_monoid(field1301) - self.newline() - field1302 = unwrapped_fields1300[1] - self.pretty_relation_id(field1302) - self.newline() - field1303 = unwrapped_fields1300[2] - self.pretty_abstraction_with_arity(field1303) - field1304 = unwrapped_fields1300[3] - if field1304 is not None: - self.newline() - assert field1304 is not None - opt_val1305 = field1304 - self.pretty_attrs(opt_val1305) - self.dedent() - self.write(")") - - def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1315 = self._try_flat(msg, self.pretty_monoid) - if flat1315 is not None: - assert flat1315 is not None - self.write(flat1315) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("or_monoid"): - _t1717 = _dollar_dollar.or_monoid - else: - _t1717 = None - deconstruct_result1313 = _t1717 - if deconstruct_result1313 is not None: - assert deconstruct_result1313 is not None - unwrapped1314 = deconstruct_result1313 - self.pretty_or_monoid(unwrapped1314) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("min_monoid"): - _t1718 = _dollar_dollar.min_monoid - else: - _t1718 = None - deconstruct_result1311 = _t1718 - if deconstruct_result1311 is not None: - assert deconstruct_result1311 is not None - unwrapped1312 = deconstruct_result1311 - self.pretty_min_monoid(unwrapped1312) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("max_monoid"): - _t1719 = _dollar_dollar.max_monoid - else: - _t1719 = None - deconstruct_result1309 = _t1719 - if deconstruct_result1309 is not None: - assert deconstruct_result1309 is not None - unwrapped1310 = deconstruct_result1309 - self.pretty_max_monoid(unwrapped1310) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("sum_monoid"): - _t1720 = _dollar_dollar.sum_monoid - else: - _t1720 = None - deconstruct_result1307 = _t1720 - if deconstruct_result1307 is not None: - assert deconstruct_result1307 is not None - unwrapped1308 = deconstruct_result1307 - self.pretty_sum_monoid(unwrapped1308) - else: - raise ParseError("No matching rule for monoid") - - def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1316 = msg - self.write("(or)") - - def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1319 = self._try_flat(msg, self.pretty_min_monoid) - if flat1319 is not None: - assert flat1319 is not None - self.write(flat1319) - return None - else: - _dollar_dollar = msg - fields1317 = _dollar_dollar.type - assert fields1317 is not None - unwrapped_fields1318 = fields1317 - self.write("(min") - self.indent_sexp() - self.newline() - self.pretty_type(unwrapped_fields1318) - self.dedent() - self.write(")") - - def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1322 = self._try_flat(msg, self.pretty_max_monoid) - if flat1322 is not None: - assert flat1322 is not None - self.write(flat1322) - return None - else: - _dollar_dollar = msg - fields1320 = _dollar_dollar.type - assert fields1320 is not None - unwrapped_fields1321 = fields1320 - self.write("(max") - self.indent_sexp() - self.newline() - self.pretty_type(unwrapped_fields1321) - self.dedent() - self.write(")") + raise ParseError("No matching rule for formula") - def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1325 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1325 is not None: - assert flat1325 is not None - self.write(flat1325) - return None - else: - _dollar_dollar = msg - fields1323 = _dollar_dollar.type - assert fields1323 is not None - unwrapped_fields1324 = fields1323 - self.write("(sum") - self.indent_sexp() - self.newline() - self.pretty_type(unwrapped_fields1324) - self.dedent() - self.write(")") + def pretty_true(self, msg: logic_pb2.Conjunction): + fields1073 = msg + self.write("(true)") - def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1333 = self._try_flat(msg, self.pretty_monus_def) - if flat1333 is not None: - assert flat1333 is not None - self.write(flat1333) - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: - _t1721 = _dollar_dollar.attrs - else: - _t1721 = None - fields1326 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1721,) - assert fields1326 is not None - unwrapped_fields1327 = fields1326 - self.write("(monus") - self.indent_sexp() - self.newline() - field1328 = unwrapped_fields1327[0] - self.pretty_monoid(field1328) - self.newline() - field1329 = unwrapped_fields1327[1] - self.pretty_relation_id(field1329) - self.newline() - field1330 = unwrapped_fields1327[2] - self.pretty_abstraction_with_arity(field1330) - field1331 = unwrapped_fields1327[3] - if field1331 is not None: - self.newline() - assert field1331 is not None - opt_val1332 = field1331 - self.pretty_attrs(opt_val1332) - self.dedent() - self.write(")") + def pretty_false(self, msg: logic_pb2.Disjunction): + fields1074 = msg + self.write("(false)") - def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1340 = self._try_flat(msg, self.pretty_constraint) - if flat1340 is not None: - assert flat1340 is not None - self.write(flat1340) + 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) return None else: _dollar_dollar = msg - fields1334 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - assert fields1334 is not None - unwrapped_fields1335 = fields1334 - self.write("(functional_dependency") + _t1754 = self.deconstruct_bindings(_dollar_dollar.body) + fields1075 = (_t1754, _dollar_dollar.body.value,) + assert fields1075 is not None + unwrapped_fields1076 = fields1075 + self.write("(exists") self.indent_sexp() self.newline() - field1336 = unwrapped_fields1335[0] - self.pretty_relation_id(field1336) - self.newline() - field1337 = unwrapped_fields1335[1] - self.pretty_abstraction(field1337) - self.newline() - field1338 = unwrapped_fields1335[2] - self.pretty_functional_dependency_keys(field1338) + field1077 = unwrapped_fields1076[0] + self.pretty_bindings(field1077) self.newline() - field1339 = unwrapped_fields1335[3] - self.pretty_functional_dependency_values(field1339) - self.dedent() - self.write(")") - - def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1344 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1344 is not None: - assert flat1344 is not None - self.write(flat1344) - return None - else: - fields1341 = msg - self.write("(keys") - self.indent_sexp() - if not len(fields1341) == 0: - self.newline() - for i1343, elem1342 in enumerate(fields1341): - if (i1343 > 0): - self.newline() - self.pretty_var(elem1342) - self.dedent() - self.write(")") - - def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1348 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1348 is not None: - assert flat1348 is not None - self.write(flat1348) - return None - else: - fields1345 = msg - self.write("(values") - self.indent_sexp() - if not len(fields1345) == 0: - self.newline() - for i1347, elem1346 in enumerate(fields1345): - if (i1347 > 0): - self.newline() - self.pretty_var(elem1346) + field1078 = unwrapped_fields1076[1] + self.pretty_formula(field1078) self.dedent() self.write(")") - def pretty_data(self, msg: logic_pb2.Data): - flat1357 = self._try_flat(msg, self.pretty_data) - if flat1357 is not None: - assert flat1357 is not None - self.write(flat1357) + 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) return None else: _dollar_dollar = msg - if _dollar_dollar.HasField("edb"): - _t1722 = _dollar_dollar.edb - else: - _t1722 = None - deconstruct_result1355 = _t1722 - if deconstruct_result1355 is not None: - assert deconstruct_result1355 is not None - unwrapped1356 = deconstruct_result1355 - self.pretty_edb(unwrapped1356) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("betree_relation"): - _t1723 = _dollar_dollar.betree_relation - else: - _t1723 = None - deconstruct_result1353 = _t1723 - if deconstruct_result1353 is not None: - assert deconstruct_result1353 is not None - unwrapped1354 = deconstruct_result1353 - self.pretty_betree_relation(unwrapped1354) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("csv_data"): - _t1724 = _dollar_dollar.csv_data - else: - _t1724 = None - deconstruct_result1351 = _t1724 - if deconstruct_result1351 is not None: - assert deconstruct_result1351 is not None - unwrapped1352 = deconstruct_result1351 - self.pretty_csv_data(unwrapped1352) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("iceberg_data"): - _t1725 = _dollar_dollar.iceberg_data - else: - _t1725 = None - deconstruct_result1349 = _t1725 - if deconstruct_result1349 is not None: - assert deconstruct_result1349 is not None - unwrapped1350 = deconstruct_result1349 - self.pretty_iceberg_data(unwrapped1350) -======= - _t1789 = _dollar_dollar.attrs - else: - _t1789 = None - fields1318 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1789,) - assert fields1318 is not None - unwrapped_fields1319 = fields1318 - self.write("(upsert") + fields1080 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + assert fields1080 is not None + unwrapped_fields1081 = fields1080 + self.write("(reduce") self.indent_sexp() self.newline() - field1320 = unwrapped_fields1319[0] - self.pretty_relation_id(field1320) - self.newline() - field1321 = unwrapped_fields1319[1] - self.pretty_abstraction_with_arity(field1321) - field1322 = unwrapped_fields1319[2] - if field1322 is not None: - self.newline() - assert field1322 is not None - opt_val1323 = field1322 - self.pretty_attrs(opt_val1323) - self.dedent() - self.write(")") - - def pretty_abstraction_with_arity(self, msg: tuple[logic_pb2.Abstraction, int]): - flat1329 = self._try_flat(msg, self.pretty_abstraction_with_arity) - if flat1329 is not None: - assert flat1329 is not None - self.write(flat1329) - return None - else: - _dollar_dollar = msg - _t1790 = self.deconstruct_bindings_with_arity(_dollar_dollar[0], _dollar_dollar[1]) - fields1325 = (_t1790, _dollar_dollar[0].value,) - assert fields1325 is not None - unwrapped_fields1326 = fields1325 - self.write("(") - self.indent() - field1327 = unwrapped_fields1326[0] - self.pretty_bindings(field1327) - self.newline() - field1328 = unwrapped_fields1326[1] - self.pretty_formula(field1328) - self.dedent() - self.write(")") - - def pretty_break(self, msg: logic_pb2.Break): - flat1336 = self._try_flat(msg, self.pretty_break) - if flat1336 is not None: - assert flat1336 is not None - self.write(flat1336) - return None - else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: - _t1791 = _dollar_dollar.attrs - else: - _t1791 = None - fields1330 = (_dollar_dollar.name, _dollar_dollar.body, _t1791,) - assert fields1330 is not None - unwrapped_fields1331 = fields1330 - self.write("(break") - self.indent_sexp() + field1082 = unwrapped_fields1081[0] + self.pretty_abstraction(field1082) self.newline() - field1332 = unwrapped_fields1331[0] - self.pretty_relation_id(field1332) + field1083 = unwrapped_fields1081[1] + self.pretty_abstraction(field1083) self.newline() - field1333 = unwrapped_fields1331[1] - self.pretty_abstraction(field1333) - field1334 = unwrapped_fields1331[2] - if field1334 is not None: - self.newline() - assert field1334 is not None - opt_val1335 = field1334 - self.pretty_attrs(opt_val1335) + field1084 = unwrapped_fields1081[2] + self.pretty_terms(field1084) self.dedent() self.write(")") - def pretty_monoid_def(self, msg: logic_pb2.MonoidDef): - flat1344 = self._try_flat(msg, self.pretty_monoid_def) - if flat1344 is not None: - assert flat1344 is not None - self.write(flat1344) + 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) return None else: - _dollar_dollar = msg - if not len(_dollar_dollar.attrs) == 0: - _t1792 = _dollar_dollar.attrs - else: - _t1792 = None - fields1337 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1792,) - assert fields1337 is not None - unwrapped_fields1338 = fields1337 - self.write("(monoid") + fields1086 = msg + self.write("(terms") self.indent_sexp() - self.newline() - field1339 = unwrapped_fields1338[0] - self.pretty_monoid(field1339) - self.newline() - field1340 = unwrapped_fields1338[1] - self.pretty_relation_id(field1340) - self.newline() - field1341 = unwrapped_fields1338[2] - self.pretty_abstraction_with_arity(field1341) - field1342 = unwrapped_fields1338[3] - if field1342 is not None: + if not len(fields1086) == 0: self.newline() - assert field1342 is not None - opt_val1343 = field1342 - self.pretty_attrs(opt_val1343) + for i1088, elem1087 in enumerate(fields1086): + if (i1088 > 0): + self.newline() + self.pretty_term(elem1087) self.dedent() self.write(")") - def pretty_monoid(self, msg: logic_pb2.Monoid): - flat1353 = self._try_flat(msg, self.pretty_monoid) - if flat1353 is not None: - assert flat1353 is not None - self.write(flat1353) + 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) return None else: _dollar_dollar = msg - if _dollar_dollar.HasField("or_monoid"): - _t1793 = _dollar_dollar.or_monoid + if _dollar_dollar.HasField("var"): + _t1755 = _dollar_dollar.var else: - _t1793 = None - deconstruct_result1351 = _t1793 - if deconstruct_result1351 is not None: - assert deconstruct_result1351 is not None - unwrapped1352 = deconstruct_result1351 - self.pretty_or_monoid(unwrapped1352) + _t1755 = None + deconstruct_result1092 = _t1755 + if deconstruct_result1092 is not None: + assert deconstruct_result1092 is not None + unwrapped1093 = deconstruct_result1092 + self.pretty_var(unwrapped1093) else: _dollar_dollar = msg - if _dollar_dollar.HasField("min_monoid"): - _t1794 = _dollar_dollar.min_monoid + if _dollar_dollar.HasField("constant"): + _t1756 = _dollar_dollar.constant else: - _t1794 = None - deconstruct_result1349 = _t1794 - if deconstruct_result1349 is not None: - assert deconstruct_result1349 is not None - unwrapped1350 = deconstruct_result1349 - self.pretty_min_monoid(unwrapped1350) + _t1756 = None + deconstruct_result1090 = _t1756 + if deconstruct_result1090 is not None: + assert deconstruct_result1090 is not None + unwrapped1091 = deconstruct_result1090 + self.pretty_value(unwrapped1091) + 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) + return None + else: + _dollar_dollar = msg + fields1095 = _dollar_dollar.name + assert fields1095 is not None + unwrapped_fields1096 = fields1095 + self.write(unwrapped_fields1096) + + 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) + return None + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("date_value"): + _t1757 = _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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("datetime_value"): + _t1758 = _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("max_monoid"): - _t1795 = _dollar_dollar.max_monoid + if _dollar_dollar.HasField("string_value"): + _t1759 = _dollar_dollar.string_value else: - _t1795 = None - deconstruct_result1347 = _t1795 - if deconstruct_result1347 is not None: - assert deconstruct_result1347 is not None - unwrapped1348 = deconstruct_result1347 - self.pretty_max_monoid(unwrapped1348) + _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)) else: _dollar_dollar = msg - if _dollar_dollar.HasField("sum_monoid"): - _t1796 = _dollar_dollar.sum_monoid + if _dollar_dollar.HasField("int32_value"): + _t1760 = _dollar_dollar.int32_value else: - _t1796 = None - deconstruct_result1345 = _t1796 - if deconstruct_result1345 is not None: - assert deconstruct_result1345 is not None - unwrapped1346 = deconstruct_result1345 - self.pretty_sum_monoid(unwrapped1346) ->>>>>>> origin/main + _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')) else: - raise ParseError("No matching rule for monoid") + _dollar_dollar = msg + if _dollar_dollar.HasField("int_value"): + _t1761 = _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)) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("float32_value"): + _t1762 = _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)) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("float_value"): + _t1763 = _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)) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("uint32_value"): + _t1764 = _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')) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("uint128_value"): + _t1765 = _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)) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("int128_value"): + _t1766 = _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)) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("decimal_value"): + _t1767 = _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)) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("boolean_value"): + _t1768 = _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) + else: + fields1098 = msg + self.write("missing") -<<<<<<< HEAD - def pretty_edb(self, msg: logic_pb2.EDB): - flat1363 = self._try_flat(msg, self.pretty_edb) - if flat1363 is not None: - assert flat1363 is not None - self.write(flat1363) + 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) return None else: _dollar_dollar = msg - fields1358 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - assert fields1358 is not None - unwrapped_fields1359 = fields1358 - self.write("(edb") + fields1124 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) + assert fields1124 is not None + unwrapped_fields1125 = fields1124 + self.write("(date") self.indent_sexp() self.newline() - field1360 = unwrapped_fields1359[0] - self.pretty_relation_id(field1360) + field1126 = unwrapped_fields1125[0] + self.write(str(field1126)) self.newline() - field1361 = unwrapped_fields1359[1] - self.pretty_edb_path(field1361) + field1127 = unwrapped_fields1125[1] + self.write(str(field1127)) self.newline() - field1362 = unwrapped_fields1359[2] - self.pretty_edb_types(field1362) + field1128 = unwrapped_fields1125[2] + self.write(str(field1128)) self.dedent() self.write(")") - def pretty_edb_path(self, msg: Sequence[str]): - flat1367 = self._try_flat(msg, self.pretty_edb_path) - if flat1367 is not None: - assert flat1367 is not None - self.write(flat1367) - return None - else: - fields1364 = msg - self.write("[") - self.indent() - for i1366, elem1365 in enumerate(fields1364): - if (i1366 > 0): - self.newline() - self.write(self.format_string_value(elem1365)) -======= - def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): - fields1354 = msg - self.write("(or)") - - def pretty_min_monoid(self, msg: logic_pb2.MinMonoid): - flat1357 = self._try_flat(msg, self.pretty_min_monoid) - if flat1357 is not None: - assert flat1357 is not None - self.write(flat1357) + 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) return None else: _dollar_dollar = msg - fields1355 = _dollar_dollar.type - assert fields1355 is not None - unwrapped_fields1356 = fields1355 - self.write("(min") + 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 + self.write("(datetime") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1356) + 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] + self.write(str(field1135)) + self.newline() + field1136 = unwrapped_fields1131[4] + self.write(str(field1136)) + self.newline() + field1137 = unwrapped_fields1131[5] + self.write(str(field1137)) + field1138 = unwrapped_fields1131[6] + if field1138 is not None: + self.newline() + assert field1138 is not None + opt_val1139 = field1138 + self.write(str(opt_val1139)) self.dedent() self.write(")") - def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): - flat1360 = self._try_flat(msg, self.pretty_max_monoid) - if flat1360 is not None: - assert flat1360 is not None - self.write(flat1360) + 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) return None else: _dollar_dollar = msg - fields1358 = _dollar_dollar.type - assert fields1358 is not None - unwrapped_fields1359 = fields1358 - self.write("(max") + fields1141 = _dollar_dollar.args + assert fields1141 is not None + unwrapped_fields1142 = fields1141 + self.write("(and") self.indent_sexp() - self.newline() - self.pretty_type(unwrapped_fields1359) ->>>>>>> origin/main + if not len(unwrapped_fields1142) == 0: + self.newline() + for i1144, elem1143 in enumerate(unwrapped_fields1142): + if (i1144 > 0): + self.newline() + self.pretty_formula(elem1143) self.dedent() self.write(")") -<<<<<<< HEAD - def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1371 = self._try_flat(msg, self.pretty_edb_types) -======= - def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): - flat1363 = self._try_flat(msg, self.pretty_sum_monoid) - if flat1363 is not None: - assert flat1363 is not None - self.write(flat1363) + 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) return None else: _dollar_dollar = msg - fields1361 = _dollar_dollar.type - assert fields1361 is not None - unwrapped_fields1362 = fields1361 - self.write("(sum") + fields1146 = _dollar_dollar.args + assert fields1146 is not None + unwrapped_fields1147 = fields1146 + self.write("(or") self.indent_sexp() - self.newline() - self.pretty_type(unwrapped_fields1362) + if not len(unwrapped_fields1147) == 0: + self.newline() + for i1149, elem1148 in enumerate(unwrapped_fields1147): + if (i1149 > 0): + self.newline() + self.pretty_formula(elem1148) self.dedent() self.write(")") - def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1371 = self._try_flat(msg, self.pretty_monus_def) ->>>>>>> origin/main - if flat1371 is not None: - assert flat1371 is not None - self.write(flat1371) + 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) return None else: - fields1368 = msg - self.write("[") - self.indent() - for i1370, elem1369 in enumerate(fields1368): - if (i1370 > 0): - self.newline() - self.pretty_type(elem1369) + _dollar_dollar = msg + fields1151 = _dollar_dollar.arg + assert fields1151 is not None + unwrapped_fields1152 = fields1151 + self.write("(not") + self.indent_sexp() + self.newline() + self.pretty_formula(unwrapped_fields1152) self.dedent() - self.write("]") + self.write(")") - def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1376 = self._try_flat(msg, self.pretty_betree_relation) - if flat1376 is not None: - assert flat1376 is not None - self.write(flat1376) + 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) return None else: _dollar_dollar = msg -<<<<<<< HEAD - fields1372 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - assert fields1372 is not None - unwrapped_fields1373 = fields1372 - self.write("(betree_relation") + fields1154 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + assert fields1154 is not None + unwrapped_fields1155 = fields1154 + self.write("(ffi") self.indent_sexp() self.newline() - field1374 = unwrapped_fields1373[0] - self.pretty_relation_id(field1374) + field1156 = unwrapped_fields1155[0] + self.pretty_name(field1156) + self.newline() + field1157 = unwrapped_fields1155[1] + self.pretty_ffi_args(field1157) self.newline() - field1375 = unwrapped_fields1373[1] - self.pretty_betree_info(field1375) + field1158 = unwrapped_fields1155[2] + self.pretty_terms(field1158) self.dedent() self.write(")") - def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1382 = self._try_flat(msg, self.pretty_betree_info) - if flat1382 is not None: - assert flat1382 is not None - self.write(flat1382) + 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) return None else: - _dollar_dollar = msg - _t1726 = self.deconstruct_betree_info_config(_dollar_dollar) - fields1377 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1726,) - assert fields1377 is not None - unwrapped_fields1378 = fields1377 - self.write("(betree_info") + fields1160 = msg + self.write(":") + self.write(fields1160) + + 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) + return None + else: + fields1162 = msg + self.write("(args") self.indent_sexp() - self.newline() - field1379 = unwrapped_fields1378[0] - self.pretty_betree_info_key_types(field1379) - self.newline() - field1380 = unwrapped_fields1378[1] - self.pretty_betree_info_value_types(field1380) - self.newline() - field1381 = unwrapped_fields1378[2] - self.pretty_config_dict(field1381) + if not len(fields1162) == 0: + self.newline() + for i1164, elem1163 in enumerate(fields1162): + if (i1164 > 0): + self.newline() + self.pretty_abstraction(elem1163) self.dedent() self.write(")") - def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1386 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1386 is not None: - assert flat1386 is not None - self.write(flat1386) + 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) return None else: - fields1383 = msg - self.write("(key_types") + _dollar_dollar = msg + fields1166 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1166 is not None + unwrapped_fields1167 = fields1166 + self.write("(atom") self.indent_sexp() - if not len(fields1383) == 0: + self.newline() + field1168 = unwrapped_fields1167[0] + self.pretty_relation_id(field1168) + field1169 = unwrapped_fields1167[1] + if not len(field1169) == 0: self.newline() - for i1385, elem1384 in enumerate(fields1383): - if (i1385 > 0): + for i1171, elem1170 in enumerate(field1169): + if (i1171 > 0): self.newline() - self.pretty_type(elem1384) + self.pretty_term(elem1170) self.dedent() self.write(")") - def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1390 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1390 is not None: - assert flat1390 is not None - self.write(flat1390) + 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) return None else: - fields1387 = msg - self.write("(value_types") + _dollar_dollar = msg + fields1173 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1173 is not None + unwrapped_fields1174 = fields1173 + self.write("(pragma") self.indent_sexp() - if not len(fields1387) == 0: + self.newline() + field1175 = unwrapped_fields1174[0] + self.pretty_name(field1175) + field1176 = unwrapped_fields1174[1] + if not len(field1176) == 0: self.newline() - for i1389, elem1388 in enumerate(fields1387): - if (i1389 > 0): + for i1178, elem1177 in enumerate(field1176): + if (i1178 > 0): self.newline() - self.pretty_type(elem1388) + self.pretty_term(elem1177) self.dedent() self.write(")") - def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1397 = self._try_flat(msg, self.pretty_csv_data) - if flat1397 is not None: - assert flat1397 is not None - self.write(flat1397) + 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) + return None + else: + _dollar_dollar = msg + if _dollar_dollar.name == "rel_primitive_eq": + _t1769 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + else: + _t1769 = None + guard_result1194 = _t1769 + if guard_result1194 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,) + else: + _t1770 = None + guard_result1193 = _t1770 + if guard_result1193 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,) + else: + _t1771 = None + guard_result1192 = _t1771 + if guard_result1192 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,) + else: + _t1772 = None + guard_result1191 = _t1772 + if guard_result1191 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,) + else: + _t1773 = None + guard_result1190 = _t1773 + if guard_result1190 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,) + else: + _t1774 = None + guard_result1189 = _t1774 + if guard_result1189 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,) + else: + _t1775 = None + guard_result1188 = _t1775 + if guard_result1188 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,) + else: + _t1776 = None + guard_result1187 = _t1776 + if guard_result1187 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,) + else: + _t1777 = None + guard_result1186 = _t1777 + if guard_result1186 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 + 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: + self.newline() + for i1185, elem1184 in enumerate(field1183): + if (i1185 > 0): + self.newline() + self.pretty_rel_term(elem1184) + 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) return None else: _dollar_dollar = msg - fields1391 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _dollar_dollar.asof,) - assert fields1391 is not None - unwrapped_fields1392 = fields1391 - self.write("(csv_data") + if _dollar_dollar.name == "rel_primitive_eq": + _t1778 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + else: + _t1778 = None + fields1196 = _t1778 + assert fields1196 is not None + unwrapped_fields1197 = fields1196 + self.write("(=") self.indent_sexp() self.newline() - field1393 = unwrapped_fields1392[0] - self.pretty_csvlocator(field1393) - self.newline() - field1394 = unwrapped_fields1392[1] - self.pretty_csv_config(field1394) - self.newline() - field1395 = unwrapped_fields1392[2] - self.pretty_gnf_columns(field1395) + field1198 = unwrapped_fields1197[0] + self.pretty_term(field1198) self.newline() - field1396 = unwrapped_fields1392[3] - self.pretty_csv_asof(field1396) + field1199 = unwrapped_fields1197[1] + self.pretty_term(field1199) self.dedent() self.write(")") - def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1404 = self._try_flat(msg, self.pretty_csvlocator) - if flat1404 is not None: - assert flat1404 is not None - self.write(flat1404) + 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) return None else: _dollar_dollar = msg - if not len(_dollar_dollar.paths) == 0: - _t1727 = _dollar_dollar.paths - else: - _t1727 = None - if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1728 = _dollar_dollar.inline_data.decode('utf-8') + if _dollar_dollar.name == "rel_primitive_lt_monotype": + _t1779 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1728 = None - fields1398 = (_t1727, _t1728,) - assert fields1398 is not None - unwrapped_fields1399 = fields1398 - self.write("(csv_locator") - self.indent_sexp() - field1400 = unwrapped_fields1399[0] - if field1400 is not None: - self.newline() - assert field1400 is not None - opt_val1401 = field1400 - self.pretty_csv_locator_paths(opt_val1401) - field1402 = unwrapped_fields1399[1] - if field1402 is not None: - self.newline() - assert field1402 is not None - opt_val1403 = field1402 - self.pretty_csv_locator_inline_data(opt_val1403) - self.dedent() - self.write(")") - - def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1408 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1408 is not None: - assert flat1408 is not None - self.write(flat1408) - return None - else: - fields1405 = msg - self.write("(paths") - self.indent_sexp() - if not len(fields1405) == 0: - self.newline() - for i1407, elem1406 in enumerate(fields1405): - if (i1407 > 0): - self.newline() - self.write(self.format_string_value(elem1406)) - self.dedent() - self.write(")") - - def pretty_csv_locator_inline_data(self, msg: str): - flat1410 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1410 is not None: - assert flat1410 is not None - self.write(flat1410) - return None - else: - fields1409 = msg - self.write("(inline_data") + _t1779 = None + fields1201 = _t1779 + assert fields1201 is not None + unwrapped_fields1202 = fields1201 + self.write("(<") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1409)) + field1203 = unwrapped_fields1202[0] + self.pretty_term(field1203) + self.newline() + field1204 = unwrapped_fields1202[1] + self.pretty_term(field1204) self.dedent() self.write(")") - def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1416 = self._try_flat(msg, self.pretty_csv_config) - if flat1416 is not None: - assert flat1416 is not None - self.write(flat1416) + 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) return None else: _dollar_dollar = msg - _t1729 = self.deconstruct_csv_config(_dollar_dollar) - _t1730 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1411 = (_t1729, _t1730,) - assert fields1411 is not None - unwrapped_fields1412 = fields1411 - self.write("(csv_config") + if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": + _t1780 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + else: + _t1780 = None + fields1206 = _t1780 + assert fields1206 is not None + unwrapped_fields1207 = fields1206 + self.write("(<=") self.indent_sexp() self.newline() - field1413 = unwrapped_fields1412[0] - self.pretty_config_dict(field1413) - field1414 = unwrapped_fields1412[1] - if field1414 is not None: - self.newline() - assert field1414 is not None - opt_val1415 = field1414 - self.pretty__storage_integration(opt_val1415) + field1208 = unwrapped_fields1207[0] + self.pretty_term(field1208) + self.newline() + field1209 = unwrapped_fields1207[1] + self.pretty_term(field1209) self.dedent() self.write(")") - def pretty__storage_integration(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat1418 = self._try_flat(msg, self.pretty__storage_integration) - if flat1418 is not None: - assert flat1418 is not None - self.write(flat1418) + 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) return None else: - fields1417 = msg - self.write("(storage_integration") + _dollar_dollar = msg + if _dollar_dollar.name == "rel_primitive_gt_monotype": + _t1781 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + else: + _t1781 = None + fields1211 = _t1781 + assert fields1211 is not None + unwrapped_fields1212 = fields1211 + self.write("(>") self.indent_sexp() self.newline() - self.pretty_config_dict(fields1417) + field1213 = unwrapped_fields1212[0] + self.pretty_term(field1213) + self.newline() + field1214 = unwrapped_fields1212[1] + self.pretty_term(field1214) self.dedent() self.write(")") - def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): - flat1422 = self._try_flat(msg, self.pretty_gnf_columns) - if flat1422 is not None: - assert flat1422 is not None - self.write(flat1422) + 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) return None else: - fields1419 = msg - self.write("(columns") + _dollar_dollar = msg + if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": + _t1782 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + else: + _t1782 = None + fields1216 = _t1782 + assert fields1216 is not None + unwrapped_fields1217 = fields1216 + self.write("(>=") self.indent_sexp() - if not len(fields1419) == 0: - self.newline() - for i1421, elem1420 in enumerate(fields1419): - if (i1421 > 0): - self.newline() - self.pretty_gnf_column(elem1420) + self.newline() + field1218 = unwrapped_fields1217[0] + self.pretty_term(field1218) + self.newline() + field1219 = unwrapped_fields1217[1] + self.pretty_term(field1219) self.dedent() self.write(")") - def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): - flat1431 = self._try_flat(msg, self.pretty_gnf_column) - if flat1431 is not None: - assert flat1431 is not None - self.write(flat1431) + 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) return None else: _dollar_dollar = msg - if _dollar_dollar.HasField("target_id"): - _t1731 = _dollar_dollar.target_id - else: - _t1731 = None - fields1423 = (_dollar_dollar.column_path, _t1731, _dollar_dollar.types,) - assert fields1423 is not None - unwrapped_fields1424 = fields1423 - self.write("(column") - self.indent_sexp() - self.newline() - field1425 = unwrapped_fields1424[0] - self.pretty_gnf_column_path(field1425) - field1426 = unwrapped_fields1424[1] - if field1426 is not None: - self.newline() - assert field1426 is not None - opt_val1427 = field1426 - self.pretty_relation_id(opt_val1427) - self.newline() - self.write("[") - field1428 = unwrapped_fields1424[2] - for i1430, elem1429 in enumerate(field1428): - if (i1430 > 0): - self.newline() - self.pretty_type(elem1429) -======= - if not len(_dollar_dollar.attrs) == 0: - _t1797 = _dollar_dollar.attrs + if _dollar_dollar.name == "rel_primitive_add_monotype": + _t1783 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _t1797 = None - fields1364 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1797,) - assert fields1364 is not None - unwrapped_fields1365 = fields1364 - self.write("(monus") + _t1783 = None + fields1221 = _t1783 + assert fields1221 is not None + unwrapped_fields1222 = fields1221 + self.write("(+") self.indent_sexp() self.newline() - field1366 = unwrapped_fields1365[0] - self.pretty_monoid(field1366) + field1223 = unwrapped_fields1222[0] + self.pretty_term(field1223) self.newline() - field1367 = unwrapped_fields1365[1] - self.pretty_relation_id(field1367) + field1224 = unwrapped_fields1222[1] + self.pretty_term(field1224) self.newline() - field1368 = unwrapped_fields1365[2] - self.pretty_abstraction_with_arity(field1368) - field1369 = unwrapped_fields1365[3] - if field1369 is not None: - self.newline() - assert field1369 is not None - opt_val1370 = field1369 - self.pretty_attrs(opt_val1370) + field1225 = unwrapped_fields1222[2] + self.pretty_term(field1225) self.dedent() self.write(")") - def pretty_constraint(self, msg: logic_pb2.Constraint): - flat1378 = self._try_flat(msg, self.pretty_constraint) - if flat1378 is not None: - assert flat1378 is not None - self.write(flat1378) + 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) return None else: _dollar_dollar = msg - fields1372 = (_dollar_dollar.name, _dollar_dollar.functional_dependency.guard, _dollar_dollar.functional_dependency.keys, _dollar_dollar.functional_dependency.values,) - assert fields1372 is not None - unwrapped_fields1373 = fields1372 - self.write("(functional_dependency") + if _dollar_dollar.name == "rel_primitive_subtract_monotype": + _t1784 = (_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 + self.write("(-") self.indent_sexp() self.newline() - field1374 = unwrapped_fields1373[0] - self.pretty_relation_id(field1374) + field1229 = unwrapped_fields1228[0] + self.pretty_term(field1229) self.newline() - field1375 = unwrapped_fields1373[1] - self.pretty_abstraction(field1375) - self.newline() - field1376 = unwrapped_fields1373[2] - self.pretty_functional_dependency_keys(field1376) + field1230 = unwrapped_fields1228[1] + self.pretty_term(field1230) self.newline() - field1377 = unwrapped_fields1373[3] - self.pretty_functional_dependency_values(field1377) - self.dedent() - self.write(")") - - def pretty_functional_dependency_keys(self, msg: Sequence[logic_pb2.Var]): - flat1382 = self._try_flat(msg, self.pretty_functional_dependency_keys) - if flat1382 is not None: - assert flat1382 is not None - self.write(flat1382) - return None - else: - fields1379 = msg - self.write("(keys") - self.indent_sexp() - if not len(fields1379) == 0: - self.newline() - for i1381, elem1380 in enumerate(fields1379): - if (i1381 > 0): - self.newline() - self.pretty_var(elem1380) + field1231 = unwrapped_fields1228[2] + self.pretty_term(field1231) self.dedent() self.write(")") - def pretty_functional_dependency_values(self, msg: Sequence[logic_pb2.Var]): - flat1386 = self._try_flat(msg, self.pretty_functional_dependency_values) - if flat1386 is not None: - assert flat1386 is not None - self.write(flat1386) + 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) return None else: - fields1383 = msg - self.write("(values") + _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,) + else: + _t1785 = None + fields1233 = _t1785 + assert fields1233 is not None + unwrapped_fields1234 = fields1233 + self.write("(*") self.indent_sexp() - if not len(fields1383) == 0: - self.newline() - for i1385, elem1384 in enumerate(fields1383): - if (i1385 > 0): - self.newline() - self.pretty_var(elem1384) + self.newline() + field1235 = unwrapped_fields1234[0] + self.pretty_term(field1235) + self.newline() + field1236 = unwrapped_fields1234[1] + self.pretty_term(field1236) + self.newline() + field1237 = unwrapped_fields1234[2] + self.pretty_term(field1237) self.dedent() self.write(")") - def pretty_data(self, msg: logic_pb2.Data): - flat1395 = self._try_flat(msg, self.pretty_data) - if flat1395 is not None: - assert flat1395 is not None - self.write(flat1395) + 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) return None else: _dollar_dollar = msg - if _dollar_dollar.HasField("edb"): - _t1798 = _dollar_dollar.edb - else: - _t1798 = None - deconstruct_result1393 = _t1798 - if deconstruct_result1393 is not None: - assert deconstruct_result1393 is not None - unwrapped1394 = deconstruct_result1393 - self.pretty_edb(unwrapped1394) + if _dollar_dollar.name == "rel_primitive_divide_monotype": + _t1786 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) else: - _dollar_dollar = msg - if _dollar_dollar.HasField("betree_relation"): - _t1799 = _dollar_dollar.betree_relation - else: - _t1799 = None - deconstruct_result1391 = _t1799 - if deconstruct_result1391 is not None: - assert deconstruct_result1391 is not None - unwrapped1392 = deconstruct_result1391 - self.pretty_betree_relation(unwrapped1392) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("csv_data"): - _t1800 = _dollar_dollar.csv_data - else: - _t1800 = None - deconstruct_result1389 = _t1800 - if deconstruct_result1389 is not None: - assert deconstruct_result1389 is not None - unwrapped1390 = deconstruct_result1389 - self.pretty_csv_data(unwrapped1390) - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("iceberg_data"): - _t1801 = _dollar_dollar.iceberg_data - else: - _t1801 = None - deconstruct_result1387 = _t1801 - if deconstruct_result1387 is not None: - assert deconstruct_result1387 is not None - unwrapped1388 = deconstruct_result1387 - self.pretty_iceberg_data(unwrapped1388) - else: - raise ParseError("No matching rule for data") - - def pretty_edb(self, msg: logic_pb2.EDB): - flat1401 = self._try_flat(msg, self.pretty_edb) - if flat1401 is not None: - assert flat1401 is not None - self.write(flat1401) - return None - else: - _dollar_dollar = msg - fields1396 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - assert fields1396 is not None - unwrapped_fields1397 = fields1396 - self.write("(edb") + _t1786 = None + fields1239 = _t1786 + assert fields1239 is not None + unwrapped_fields1240 = fields1239 + self.write("(/") self.indent_sexp() self.newline() - field1398 = unwrapped_fields1397[0] - self.pretty_relation_id(field1398) + field1241 = unwrapped_fields1240[0] + self.pretty_term(field1241) self.newline() - field1399 = unwrapped_fields1397[1] - self.pretty_edb_path(field1399) + field1242 = unwrapped_fields1240[1] + self.pretty_term(field1242) self.newline() - field1400 = unwrapped_fields1397[2] - self.pretty_edb_types(field1400) + field1243 = unwrapped_fields1240[2] + self.pretty_term(field1243) self.dedent() self.write(")") - def pretty_edb_path(self, msg: Sequence[str]): - flat1405 = self._try_flat(msg, self.pretty_edb_path) - if flat1405 is not None: - assert flat1405 is not None - self.write(flat1405) - return None - else: - fields1402 = msg - self.write("[") - self.indent() - for i1404, elem1403 in enumerate(fields1402): - if (i1404 > 0): - self.newline() - self.write(self.format_string_value(elem1403)) - self.dedent() ->>>>>>> origin/main - self.write("]") - -<<<<<<< HEAD - def pretty_gnf_column_path(self, msg: Sequence[str]): - flat1438 = self._try_flat(msg, self.pretty_gnf_column_path) - if flat1438 is not None: - assert flat1438 is not None - self.write(flat1438) + 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) return None else: _dollar_dollar = msg - if len(_dollar_dollar) == 1: - _t1732 = _dollar_dollar[0] + if _dollar_dollar.HasField("specialized_value"): + _t1787 = _dollar_dollar.specialized_value else: - _t1732 = None - deconstruct_result1436 = _t1732 - if deconstruct_result1436 is not None: - assert deconstruct_result1436 is not None - unwrapped1437 = deconstruct_result1436 - self.write(self.format_string_value(unwrapped1437)) + _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) else: _dollar_dollar = msg - if len(_dollar_dollar) != 1: - _t1733 = _dollar_dollar + if _dollar_dollar.HasField("term"): + _t1788 = _dollar_dollar.term else: - _t1733 = None - deconstruct_result1432 = _t1733 - if deconstruct_result1432 is not None: - assert deconstruct_result1432 is not None - unwrapped1433 = deconstruct_result1432 - self.write("[") - self.indent() - for i1435, elem1434 in enumerate(unwrapped1433): - if (i1435 > 0): - self.newline() - self.write(self.format_string_value(elem1434)) - self.dedent() - self.write("]") + _t1788 = None + deconstruct_result1245 = _t1788 + if deconstruct_result1245 is not None: + assert deconstruct_result1245 is not None + unwrapped1246 = deconstruct_result1245 + self.pretty_term(unwrapped1246) else: - raise ParseError("No matching rule for gnf_column_path") + raise ParseError("No matching rule for rel_term") - def pretty_csv_asof(self, msg: str): - flat1440 = self._try_flat(msg, self.pretty_csv_asof) - if flat1440 is not None: - assert flat1440 is not None - self.write(flat1440) + 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) return None else: - fields1439 = msg - self.write("(asof") - self.indent_sexp() - self.newline() - self.write(self.format_string_value(fields1439)) - self.dedent() - self.write(")") + fields1250 = msg + self.write("#") + self.pretty_raw_value(fields1250) - def pretty_iceberg_data(self, msg: logic_pb2.IcebergData): - flat1451 = self._try_flat(msg, self.pretty_iceberg_data) - if flat1451 is not None: - assert flat1451 is not None - self.write(flat1451) + 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) return None else: _dollar_dollar = msg - _t1734 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1735 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1441 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1734, _t1735, _dollar_dollar.returns_delta,) - assert fields1441 is not None - unwrapped_fields1442 = fields1441 - self.write("(iceberg_data") + fields1252 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1252 is not None + unwrapped_fields1253 = fields1252 + self.write("(relatom") self.indent_sexp() self.newline() - field1443 = unwrapped_fields1442[0] - self.pretty_iceberg_locator(field1443) - self.newline() - field1444 = unwrapped_fields1442[1] - self.pretty_iceberg_catalog_config(field1444) - self.newline() - field1445 = unwrapped_fields1442[2] - self.pretty_gnf_columns(field1445) - field1446 = unwrapped_fields1442[3] - if field1446 is not None: + field1254 = unwrapped_fields1253[0] + self.pretty_name(field1254) + field1255 = unwrapped_fields1253[1] + if not len(field1255) == 0: self.newline() - assert field1446 is not None - opt_val1447 = field1446 - self.pretty_iceberg_from_snapshot(opt_val1447) - field1448 = unwrapped_fields1442[4] - if field1448 is not None: - self.newline() - assert field1448 is not None - opt_val1449 = field1448 - self.pretty_iceberg_to_snapshot(opt_val1449) - self.newline() - field1450 = unwrapped_fields1442[5] - self.pretty_boolean_value(field1450) + for i1257, elem1256 in enumerate(field1255): + if (i1257 > 0): + self.newline() + self.pretty_rel_term(elem1256) self.dedent() self.write(")") - def pretty_iceberg_locator(self, msg: logic_pb2.IcebergLocator): - flat1457 = self._try_flat(msg, self.pretty_iceberg_locator) - if flat1457 is not None: - assert flat1457 is not None - self.write(flat1457) + 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) return None else: _dollar_dollar = msg - fields1452 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - assert fields1452 is not None - unwrapped_fields1453 = fields1452 - self.write("(iceberg_locator") + fields1259 = (_dollar_dollar.input, _dollar_dollar.result,) + assert fields1259 is not None + unwrapped_fields1260 = fields1259 + self.write("(cast") self.indent_sexp() self.newline() - field1454 = unwrapped_fields1453[0] - self.pretty_iceberg_locator_table_name(field1454) + field1261 = unwrapped_fields1260[0] + self.pretty_term(field1261) self.newline() - field1455 = unwrapped_fields1453[1] - self.pretty_iceberg_locator_namespace(field1455) - self.newline() - field1456 = unwrapped_fields1453[2] - self.pretty_iceberg_locator_warehouse(field1456) + field1262 = unwrapped_fields1260[1] + self.pretty_term(field1262) self.dedent() self.write(")") - def pretty_iceberg_locator_table_name(self, msg: str): - flat1459 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) - if flat1459 is not None: - assert flat1459 is not None - self.write(flat1459) + 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) return None else: - fields1458 = msg - self.write("(table_name") + fields1264 = msg + self.write("(attrs") self.indent_sexp() - self.newline() - self.write(self.format_string_value(fields1458)) + if not len(fields1264) == 0: + self.newline() + for i1266, elem1265 in enumerate(fields1264): + if (i1266 > 0): + self.newline() + self.pretty_attribute(elem1265) self.dedent() self.write(")") - def pretty_iceberg_locator_namespace(self, msg: Sequence[str]): - flat1463 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) - if flat1463 is not None: - assert flat1463 is not None - self.write(flat1463) + 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) return None else: - fields1460 = msg - self.write("(namespace") + _dollar_dollar = msg + fields1268 = (_dollar_dollar.name, _dollar_dollar.args,) + assert fields1268 is not None + unwrapped_fields1269 = fields1268 + self.write("(attribute") self.indent_sexp() - if not len(fields1460) == 0: + self.newline() + field1270 = unwrapped_fields1269[0] + self.pretty_name(field1270) + field1271 = unwrapped_fields1269[1] + if not len(field1271) == 0: self.newline() - for i1462, elem1461 in enumerate(fields1460): - if (i1462 > 0): + for i1273, elem1272 in enumerate(field1271): + if (i1273 > 0): self.newline() - self.write(self.format_string_value(elem1461)) + self.pretty_raw_value(elem1272) self.dedent() self.write(")") - def pretty_iceberg_locator_warehouse(self, msg: str): - flat1465 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) - if flat1465 is not None: - assert flat1465 is not None - self.write(flat1465) + 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) return None else: - fields1464 = msg - self.write("(warehouse") + _dollar_dollar = msg + if not len(_dollar_dollar.attrs) == 0: + _t1789 = _dollar_dollar.attrs + else: + _t1789 = None + fields1275 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1789,) + assert fields1275 is not None + unwrapped_fields1276 = fields1275 + self.write("(algorithm") self.indent_sexp() + field1277 = unwrapped_fields1276[0] + if not len(field1277) == 0: + self.newline() + for i1279, elem1278 in enumerate(field1277): + if (i1279 > 0): + self.newline() + self.pretty_relation_id(elem1278) self.newline() - self.write(self.format_string_value(fields1464)) + field1280 = unwrapped_fields1276[1] + self.pretty_script(field1280) + field1281 = unwrapped_fields1276[2] + if field1281 is not None: + self.newline() + assert field1281 is not None + opt_val1282 = field1281 + self.pretty_attrs(opt_val1282) self.dedent() self.write(")") - def pretty_iceberg_catalog_config(self, msg: logic_pb2.IcebergCatalogConfig): - flat1473 = self._try_flat(msg, self.pretty_iceberg_catalog_config) - if flat1473 is not None: - assert flat1473 is not None - self.write(flat1473) + 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) return None else: _dollar_dollar = msg - _t1736 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1466 = (_dollar_dollar.catalog_uri, _t1736, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) - assert fields1466 is not None - unwrapped_fields1467 = fields1466 - self.write("(iceberg_catalog_config") + fields1284 = _dollar_dollar.constructs + assert fields1284 is not None + unwrapped_fields1285 = fields1284 + self.write("(script") self.indent_sexp() - self.newline() - field1468 = unwrapped_fields1467[0] - self.pretty_iceberg_catalog_uri(field1468) - field1469 = unwrapped_fields1467[1] - if field1469 is not None: + if not len(unwrapped_fields1285) == 0: self.newline() - assert field1469 is not None - opt_val1470 = field1469 - self.pretty_iceberg_catalog_config_scope(opt_val1470) - self.newline() - field1471 = unwrapped_fields1467[2] - self.pretty_iceberg_properties(field1471) - self.newline() - field1472 = unwrapped_fields1467[3] - self.pretty_iceberg_auth_properties(field1472) + for i1287, elem1286 in enumerate(unwrapped_fields1285): + if (i1287 > 0): + self.newline() + self.pretty_construct(elem1286) self.dedent() self.write(")") - def pretty_iceberg_catalog_uri(self, msg: str): - flat1475 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) - if flat1475 is not None: - assert flat1475 is not None - self.write(flat1475) + 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) return None else: - fields1474 = msg - self.write("(catalog_uri") + _dollar_dollar = msg + if _dollar_dollar.HasField("loop"): + _t1790 = _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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("instruction"): + _t1791 = _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) + 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) + return None + else: + _dollar_dollar = msg + if not len(_dollar_dollar.attrs) == 0: + _t1792 = _dollar_dollar.attrs + else: + _t1792 = None + fields1294 = (_dollar_dollar.init, _dollar_dollar.body, _t1792,) + assert fields1294 is not None + unwrapped_fields1295 = fields1294 + self.write("(loop") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1474)) + field1296 = unwrapped_fields1295[0] + self.pretty_init(field1296) + self.newline() + field1297 = unwrapped_fields1295[1] + self.pretty_script(field1297) + field1298 = unwrapped_fields1295[2] + if field1298 is not None: + self.newline() + assert field1298 is not None + opt_val1299 = field1298 + self.pretty_attrs(opt_val1299) self.dedent() self.write(")") - def pretty_iceberg_catalog_config_scope(self, msg: str): - flat1477 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) - if flat1477 is not None: - assert flat1477 is not None - self.write(flat1477) + 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) return None else: - fields1476 = msg - self.write("(scope") + fields1301 = msg + self.write("(init") self.indent_sexp() - self.newline() - self.write(self.format_string_value(fields1476)) + if not len(fields1301) == 0: + self.newline() + for i1303, elem1302 in enumerate(fields1301): + if (i1303 > 0): + self.newline() + self.pretty_instruction(elem1302) self.dedent() self.write(")") - def pretty_iceberg_properties(self, msg: Sequence[tuple[str, str]]): - flat1481 = self._try_flat(msg, self.pretty_iceberg_properties) - if flat1481 is not None: - assert flat1481 is not None - self.write(flat1481) + 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) return None else: - fields1478 = msg - self.write("(properties") + _dollar_dollar = msg + if _dollar_dollar.HasField("assign"): + _t1793 = _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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("upsert"): + _t1794 = _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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("break"): + _t1795 = 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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("monoid_def"): + _t1796 = _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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("monus_def"): + _t1797 = _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) + 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) + return None + else: + _dollar_dollar = msg + if not len(_dollar_dollar.attrs) == 0: + _t1798 = _dollar_dollar.attrs + else: + _t1798 = None + fields1316 = (_dollar_dollar.name, _dollar_dollar.body, _t1798,) + assert fields1316 is not None + unwrapped_fields1317 = fields1316 + self.write("(assign") self.indent_sexp() - if not len(fields1478) == 0: + self.newline() + field1318 = unwrapped_fields1317[0] + self.pretty_relation_id(field1318) + self.newline() + field1319 = unwrapped_fields1317[1] + self.pretty_abstraction(field1319) + field1320 = unwrapped_fields1317[2] + if field1320 is not None: self.newline() - for i1480, elem1479 in enumerate(fields1478): - if (i1480 > 0): - self.newline() - self.pretty_iceberg_property_entry(elem1479) + assert field1320 is not None + opt_val1321 = field1320 + self.pretty_attrs(opt_val1321) self.dedent() self.write(")") - def pretty_iceberg_property_entry(self, msg: tuple[str, str]): - flat1486 = self._try_flat(msg, self.pretty_iceberg_property_entry) - if flat1486 is not None: - assert flat1486 is not None - self.write(flat1486) + 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) return None else: _dollar_dollar = msg - fields1482 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields1482 is not None - unwrapped_fields1483 = fields1482 - self.write("(prop") + if not len(_dollar_dollar.attrs) == 0: + _t1799 = _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 + self.write("(upsert") self.indent_sexp() self.newline() - field1484 = unwrapped_fields1483[0] - self.write(self.format_string_value(field1484)) + field1325 = unwrapped_fields1324[0] + self.pretty_relation_id(field1325) self.newline() - field1485 = unwrapped_fields1483[1] - self.write(self.format_string_value(field1485)) + field1326 = unwrapped_fields1324[1] + self.pretty_abstraction_with_arity(field1326) + field1327 = unwrapped_fields1324[2] + if field1327 is not None: + self.newline() + assert field1327 is not None + opt_val1328 = field1327 + self.pretty_attrs(opt_val1328) self.dedent() self.write(")") - def pretty_iceberg_auth_properties(self, msg: Sequence[tuple[str, str]]): - flat1490 = self._try_flat(msg, self.pretty_iceberg_auth_properties) - if flat1490 is not None: - assert flat1490 is not None - self.write(flat1490) + 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) return None else: - fields1487 = msg - self.write("(auth_properties") + _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 + self.write("(") + self.indent() + field1332 = unwrapped_fields1331[0] + self.pretty_bindings(field1332) + self.newline() + field1333 = unwrapped_fields1331[1] + self.pretty_formula(field1333) + 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) + return None + else: + _dollar_dollar = msg + if not len(_dollar_dollar.attrs) == 0: + _t1801 = _dollar_dollar.attrs + else: + _t1801 = None + fields1335 = (_dollar_dollar.name, _dollar_dollar.body, _t1801,) + assert fields1335 is not None + unwrapped_fields1336 = fields1335 + self.write("(break") self.indent_sexp() - if not len(fields1487) == 0: + self.newline() + field1337 = unwrapped_fields1336[0] + self.pretty_relation_id(field1337) + self.newline() + field1338 = unwrapped_fields1336[1] + self.pretty_abstraction(field1338) + field1339 = unwrapped_fields1336[2] + if field1339 is not None: self.newline() - for i1489, elem1488 in enumerate(fields1487): - if (i1489 > 0): - self.newline() - self.pretty_iceberg_masked_property_entry(elem1488) + assert field1339 is not None + opt_val1340 = field1339 + self.pretty_attrs(opt_val1340) self.dedent() self.write(")") - def pretty_iceberg_masked_property_entry(self, msg: tuple[str, str]): - flat1495 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) - if flat1495 is not None: - assert flat1495 is not None - self.write(flat1495) + 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) return None else: _dollar_dollar = msg - _t1737 = self.mask_secret_value(_dollar_dollar) - fields1491 = (_dollar_dollar[0], _t1737,) - assert fields1491 is not None - unwrapped_fields1492 = fields1491 - self.write("(prop") + if not len(_dollar_dollar.attrs) == 0: + _t1802 = _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 + self.write("(monoid") self.indent_sexp() self.newline() - field1493 = unwrapped_fields1492[0] - self.write(self.format_string_value(field1493)) + field1344 = unwrapped_fields1343[0] + self.pretty_monoid(field1344) self.newline() - field1494 = unwrapped_fields1492[1] - self.write(self.format_string_value(field1494)) + field1345 = unwrapped_fields1343[1] + self.pretty_relation_id(field1345) + self.newline() + field1346 = unwrapped_fields1343[2] + self.pretty_abstraction_with_arity(field1346) + field1347 = unwrapped_fields1343[3] + if field1347 is not None: + self.newline() + assert field1347 is not None + opt_val1348 = field1347 + self.pretty_attrs(opt_val1348) self.dedent() self.write(")") - def pretty_iceberg_from_snapshot(self, msg: str): - flat1497 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) - if flat1497 is not None: - assert flat1497 is not None - self.write(flat1497) + 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) return None else: - fields1496 = msg - self.write("(from_snapshot") + _dollar_dollar = msg + if _dollar_dollar.HasField("or_monoid"): + _t1803 = _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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("min_monoid"): + _t1804 = _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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("max_monoid"): + _t1805 = _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) + else: + _dollar_dollar = msg + if _dollar_dollar.HasField("sum_monoid"): + _t1806 = _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) + else: + raise ParseError("No matching rule for monoid") + + def pretty_or_monoid(self, msg: logic_pb2.OrMonoid): + fields1359 = 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.write(self.format_string_value(fields1496)) + self.pretty_type(unwrapped_fields1361) self.dedent() self.write(")") - def pretty_iceberg_to_snapshot(self, msg: str): - flat1499 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) - if flat1499 is not None: - assert flat1499 is not None - self.write(flat1499) + def pretty_max_monoid(self, msg: logic_pb2.MaxMonoid): + flat1365 = self._try_flat(msg, self.pretty_max_monoid) + if flat1365 is not None: + assert flat1365 is not None + self.write(flat1365) return None else: - fields1498 = msg - self.write("(to_snapshot") + _dollar_dollar = msg + fields1363 = _dollar_dollar.type + assert fields1363 is not None + unwrapped_fields1364 = fields1363 + self.write("(max") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1498)) + self.pretty_type(unwrapped_fields1364) self.dedent() self.write(")") - def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1502 = self._try_flat(msg, self.pretty_undefine) - if flat1502 is not None: - assert flat1502 is not None - self.write(flat1502) + def pretty_sum_monoid(self, msg: logic_pb2.SumMonoid): + flat1368 = self._try_flat(msg, self.pretty_sum_monoid) + if flat1368 is not None: + assert flat1368 is not None + self.write(flat1368) return None else: _dollar_dollar = msg - fields1500 = _dollar_dollar.fragment_id - assert fields1500 is not None - unwrapped_fields1501 = fields1500 - self.write("(undefine") + fields1366 = _dollar_dollar.type + assert fields1366 is not None + unwrapped_fields1367 = fields1366 + self.write("(sum") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1501) + self.pretty_type(unwrapped_fields1367) self.dedent() self.write(")") - def pretty_context(self, msg: transactions_pb2.Context): - flat1507 = self._try_flat(msg, self.pretty_context) - if flat1507 is not None: - assert flat1507 is not None - self.write(flat1507) + 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) return None else: _dollar_dollar = msg - fields1503 = _dollar_dollar.relations - assert fields1503 is not None - unwrapped_fields1504 = fields1503 - self.write("(context") + if not len(_dollar_dollar.attrs) == 0: + _t1807 = _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 + self.write("(monus") self.indent_sexp() - if not len(unwrapped_fields1504) == 0: + self.newline() + field1371 = unwrapped_fields1370[0] + self.pretty_monoid(field1371) + self.newline() + field1372 = unwrapped_fields1370[1] + self.pretty_relation_id(field1372) + self.newline() + field1373 = unwrapped_fields1370[2] + self.pretty_abstraction_with_arity(field1373) + field1374 = unwrapped_fields1370[3] + if field1374 is not None: self.newline() - for i1506, elem1505 in enumerate(unwrapped_fields1504): - if (i1506 > 0): - self.newline() - self.pretty_relation_id(elem1505) + assert field1374 is not None + opt_val1375 = field1374 + self.pretty_attrs(opt_val1375) self.dedent() self.write(")") - def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1514 = self._try_flat(msg, self.pretty_snapshot) - if flat1514 is not None: - assert flat1514 is not None - self.write(flat1514) + 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) return None else: _dollar_dollar = msg - fields1508 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - assert fields1508 is not None - unwrapped_fields1509 = fields1508 - self.write("(snapshot") + 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 + self.write("(functional_dependency") self.indent_sexp() self.newline() - field1510 = unwrapped_fields1509[0] - self.pretty_edb_path(field1510) - field1511 = unwrapped_fields1509[1] - if not len(field1511) == 0: - self.newline() - for i1513, elem1512 in enumerate(field1511): - if (i1513 > 0): - self.newline() - self.pretty_snapshot_mapping(elem1512) + field1379 = unwrapped_fields1378[0] + self.pretty_relation_id(field1379) + self.newline() + field1380 = unwrapped_fields1378[1] + self.pretty_abstraction(field1380) + self.newline() + field1381 = unwrapped_fields1378[2] + self.pretty_functional_dependency_keys(field1381) + self.newline() + field1382 = unwrapped_fields1378[3] + self.pretty_functional_dependency_values(field1382) self.dedent() self.write(")") - def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping): - flat1519 = self._try_flat(msg, self.pretty_snapshot_mapping) - if flat1519 is not None: - assert flat1519 is not None - self.write(flat1519) + 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) return None else: - _dollar_dollar = msg - fields1515 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - assert fields1515 is not None - unwrapped_fields1516 = fields1515 - field1517 = unwrapped_fields1516[0] - self.pretty_edb_path(field1517) - self.write(" ") - field1518 = unwrapped_fields1516[1] - self.pretty_relation_id(field1518) + fields1384 = msg + self.write("(keys") + self.indent_sexp() + if not len(fields1384) == 0: + self.newline() + for i1386, elem1385 in enumerate(fields1384): + if (i1386 > 0): + self.newline() + self.pretty_var(elem1385) + self.dedent() + self.write(")") - def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1523 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1523 is not None: - assert flat1523 is not None - self.write(flat1523) + 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) return None else: - fields1520 = msg - self.write("(reads") + fields1388 = msg + self.write("(values") self.indent_sexp() - if not len(fields1520) == 0: + if not len(fields1388) == 0: self.newline() - for i1522, elem1521 in enumerate(fields1520): - if (i1522 > 0): + for i1390, elem1389 in enumerate(fields1388): + if (i1390 > 0): self.newline() - self.pretty_read(elem1521) + self.pretty_var(elem1389) self.dedent() self.write(")") - def pretty_read(self, msg: transactions_pb2.Read): - flat1534 = self._try_flat(msg, self.pretty_read) - if flat1534 is not None: - assert flat1534 is not None - self.write(flat1534) + 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) return None else: _dollar_dollar = msg - if _dollar_dollar.HasField("demand"): - _t1738 = _dollar_dollar.demand + if _dollar_dollar.HasField("edb"): + _t1808 = _dollar_dollar.edb else: - _t1738 = None - deconstruct_result1532 = _t1738 - if deconstruct_result1532 is not None: - assert deconstruct_result1532 is not None - unwrapped1533 = deconstruct_result1532 - self.pretty_demand(unwrapped1533) + _t1808 = None + deconstruct_result1398 = _t1808 + if deconstruct_result1398 is not None: + assert deconstruct_result1398 is not None + unwrapped1399 = deconstruct_result1398 + self.pretty_edb(unwrapped1399) else: _dollar_dollar = msg - if _dollar_dollar.HasField("output"): - _t1739 = _dollar_dollar.output + if _dollar_dollar.HasField("betree_relation"): + _t1809 = _dollar_dollar.betree_relation else: - _t1739 = None - deconstruct_result1530 = _t1739 - if deconstruct_result1530 is not None: - assert deconstruct_result1530 is not None - unwrapped1531 = deconstruct_result1530 - self.pretty_output(unwrapped1531) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("what_if"): - _t1740 = _dollar_dollar.what_if + if _dollar_dollar.HasField("csv_data"): + _t1810 = _dollar_dollar.csv_data else: - _t1740 = None - deconstruct_result1528 = _t1740 - if deconstruct_result1528 is not None: - assert deconstruct_result1528 is not None - unwrapped1529 = deconstruct_result1528 - self.pretty_what_if(unwrapped1529) + _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) else: _dollar_dollar = msg - if _dollar_dollar.HasField("abort"): - _t1741 = _dollar_dollar.abort + if _dollar_dollar.HasField("iceberg_data"): + _t1811 = _dollar_dollar.iceberg_data else: - _t1741 = None - deconstruct_result1526 = _t1741 - if deconstruct_result1526 is not None: - assert deconstruct_result1526 is not None - unwrapped1527 = deconstruct_result1526 - self.pretty_abort(unwrapped1527) + _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) else: - _dollar_dollar = msg - if _dollar_dollar.HasField("export"): - _t1742 = _dollar_dollar.export - else: - _t1742 = None - deconstruct_result1524 = _t1742 - if deconstruct_result1524 is not None: - assert deconstruct_result1524 is not None - unwrapped1525 = deconstruct_result1524 - self.pretty_export(unwrapped1525) - else: - raise ParseError("No matching rule for read") + raise ParseError("No matching rule for data") - def pretty_demand(self, msg: transactions_pb2.Demand): - flat1537 = self._try_flat(msg, self.pretty_demand) - if flat1537 is not None: - assert flat1537 is not None - self.write(flat1537) + 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) return None else: _dollar_dollar = msg - fields1535 = _dollar_dollar.relation_id - assert fields1535 is not None - unwrapped_fields1536 = fields1535 - self.write("(demand") + fields1401 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + assert fields1401 is not None + unwrapped_fields1402 = fields1401 + self.write("(edb") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1536) + field1403 = unwrapped_fields1402[0] + self.pretty_relation_id(field1403) + self.newline() + field1404 = unwrapped_fields1402[1] + self.pretty_edb_path(field1404) + self.newline() + field1405 = unwrapped_fields1402[2] + self.pretty_edb_types(field1405) self.dedent() self.write(")") - def pretty_output(self, msg: transactions_pb2.Output): - flat1542 = self._try_flat(msg, self.pretty_output) - if flat1542 is not None: - assert flat1542 is not None - self.write(flat1542) + 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) return None else: - _dollar_dollar = msg - fields1538 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - assert fields1538 is not None - unwrapped_fields1539 = fields1538 - self.write("(output") -======= + fields1407 = msg + self.write("[") + self.indent() + for i1409, elem1408 in enumerate(fields1407): + if (i1409 > 0): + self.newline() + self.write(self.format_string_value(elem1408)) + self.dedent() + self.write("]") + def pretty_edb_types(self, msg: Sequence[logic_pb2.Type]): - flat1409 = self._try_flat(msg, self.pretty_edb_types) - if flat1409 is not None: - assert flat1409 is not None - self.write(flat1409) + flat1414 = self._try_flat(msg, self.pretty_edb_types) + if flat1414 is not None: + assert flat1414 is not None + self.write(flat1414) return None else: - fields1406 = msg + fields1411 = msg self.write("[") self.indent() - for i1408, elem1407 in enumerate(fields1406): - if (i1408 > 0): + for i1413, elem1412 in enumerate(fields1411): + if (i1413 > 0): self.newline() - self.pretty_type(elem1407) + self.pretty_type(elem1412) self.dedent() self.write("]") def pretty_betree_relation(self, msg: logic_pb2.BeTreeRelation): - flat1414 = self._try_flat(msg, self.pretty_betree_relation) - if flat1414 is not None: - assert flat1414 is not None - self.write(flat1414) + flat1419 = self._try_flat(msg, self.pretty_betree_relation) + if flat1419 is not None: + assert flat1419 is not None + self.write(flat1419) return None else: _dollar_dollar = msg - fields1410 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - assert fields1410 is not None - unwrapped_fields1411 = fields1410 + fields1415 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + assert fields1415 is not None + unwrapped_fields1416 = fields1415 self.write("(betree_relation") self.indent_sexp() self.newline() - field1412 = unwrapped_fields1411[0] - self.pretty_relation_id(field1412) + field1417 = unwrapped_fields1416[0] + self.pretty_relation_id(field1417) self.newline() - field1413 = unwrapped_fields1411[1] - self.pretty_betree_info(field1413) + field1418 = unwrapped_fields1416[1] + self.pretty_betree_info(field1418) self.dedent() self.write(")") def pretty_betree_info(self, msg: logic_pb2.BeTreeInfo): - flat1420 = self._try_flat(msg, self.pretty_betree_info) - if flat1420 is not None: - assert flat1420 is not None - self.write(flat1420) + flat1425 = self._try_flat(msg, self.pretty_betree_info) + if flat1425 is not None: + assert flat1425 is not None + self.write(flat1425) return None else: _dollar_dollar = msg - _t1802 = self.deconstruct_betree_info_config(_dollar_dollar) - fields1415 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1802,) - assert fields1415 is not None - unwrapped_fields1416 = fields1415 + _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 self.write("(betree_info") self.indent_sexp() self.newline() - field1417 = unwrapped_fields1416[0] - self.pretty_betree_info_key_types(field1417) + field1422 = unwrapped_fields1421[0] + self.pretty_betree_info_key_types(field1422) self.newline() - field1418 = unwrapped_fields1416[1] - self.pretty_betree_info_value_types(field1418) + field1423 = unwrapped_fields1421[1] + self.pretty_betree_info_value_types(field1423) self.newline() - field1419 = unwrapped_fields1416[2] - self.pretty_config_dict(field1419) + field1424 = unwrapped_fields1421[2] + self.pretty_config_dict(field1424) self.dedent() self.write(")") def pretty_betree_info_key_types(self, msg: Sequence[logic_pb2.Type]): - flat1424 = self._try_flat(msg, self.pretty_betree_info_key_types) - if flat1424 is not None: - assert flat1424 is not None - self.write(flat1424) + flat1429 = self._try_flat(msg, self.pretty_betree_info_key_types) + if flat1429 is not None: + assert flat1429 is not None + self.write(flat1429) return None else: - fields1421 = msg + fields1426 = msg self.write("(key_types") self.indent_sexp() - if not len(fields1421) == 0: + if not len(fields1426) == 0: self.newline() - for i1423, elem1422 in enumerate(fields1421): - if (i1423 > 0): + for i1428, elem1427 in enumerate(fields1426): + if (i1428 > 0): self.newline() - self.pretty_type(elem1422) + self.pretty_type(elem1427) self.dedent() self.write(")") def pretty_betree_info_value_types(self, msg: Sequence[logic_pb2.Type]): - flat1428 = self._try_flat(msg, self.pretty_betree_info_value_types) - if flat1428 is not None: - assert flat1428 is not None - self.write(flat1428) + flat1433 = self._try_flat(msg, self.pretty_betree_info_value_types) + if flat1433 is not None: + assert flat1433 is not None + self.write(flat1433) return None else: - fields1425 = msg + fields1430 = msg self.write("(value_types") self.indent_sexp() - if not len(fields1425) == 0: + if not len(fields1430) == 0: self.newline() - for i1427, elem1426 in enumerate(fields1425): - if (i1427 > 0): + for i1432, elem1431 in enumerate(fields1430): + if (i1432 > 0): self.newline() - self.pretty_type(elem1426) + self.pretty_type(elem1431) self.dedent() self.write(")") def pretty_csv_data(self, msg: logic_pb2.CSVData): - flat1438 = self._try_flat(msg, self.pretty_csv_data) - if flat1438 is not None: - assert flat1438 is not None - self.write(flat1438) + flat1443 = self._try_flat(msg, self.pretty_csv_data) + if flat1443 is not None: + assert flat1443 is not None + self.write(flat1443) return None else: _dollar_dollar = msg - _t1803 = self.deconstruct_csv_data_columns_optional(_dollar_dollar) - _t1804 = self.deconstruct_csv_data_relations_optional(_dollar_dollar) - fields1429 = (_dollar_dollar.locator, _dollar_dollar.config, _t1803, _t1804, _dollar_dollar.asof,) - assert fields1429 is not None - unwrapped_fields1430 = fields1429 + _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 self.write("(csv_data") self.indent_sexp() self.newline() - field1431 = unwrapped_fields1430[0] - self.pretty_csvlocator(field1431) + field1436 = unwrapped_fields1435[0] + self.pretty_csvlocator(field1436) self.newline() - field1432 = unwrapped_fields1430[1] - self.pretty_csv_config(field1432) - field1433 = unwrapped_fields1430[2] - if field1433 is not None: + field1437 = unwrapped_fields1435[1] + self.pretty_csv_config(field1437) + field1438 = unwrapped_fields1435[2] + if field1438 is not None: self.newline() - assert field1433 is not None - opt_val1434 = field1433 - self.pretty_gnf_columns(opt_val1434) - field1435 = unwrapped_fields1430[3] - if field1435 is not None: + assert field1438 is not None + opt_val1439 = field1438 + self.pretty_gnf_columns(opt_val1439) + field1440 = unwrapped_fields1435[3] + if field1440 is not None: self.newline() - assert field1435 is not None - opt_val1436 = field1435 - self.pretty_target_relations(opt_val1436) + assert field1440 is not None + opt_val1441 = field1440 + self.pretty_target_relations(opt_val1441) self.newline() - field1437 = unwrapped_fields1430[4] - self.pretty_csv_asof(field1437) + field1442 = unwrapped_fields1435[4] + self.pretty_csv_asof(field1442) self.dedent() self.write(")") def pretty_csvlocator(self, msg: logic_pb2.CSVLocator): - flat1445 = self._try_flat(msg, self.pretty_csvlocator) - if flat1445 is not None: - assert flat1445 is not None - self.write(flat1445) + flat1450 = self._try_flat(msg, self.pretty_csvlocator) + if flat1450 is not None: + assert flat1450 is not None + self.write(flat1450) return None else: _dollar_dollar = msg if not len(_dollar_dollar.paths) == 0: - _t1805 = _dollar_dollar.paths + _t1815 = _dollar_dollar.paths else: - _t1805 = None + _t1815 = None if _dollar_dollar.inline_data.decode('utf-8') != "": - _t1806 = _dollar_dollar.inline_data.decode('utf-8') + _t1816 = _dollar_dollar.inline_data.decode('utf-8') else: - _t1806 = None - fields1439 = (_t1805, _t1806,) - assert fields1439 is not None - unwrapped_fields1440 = fields1439 + _t1816 = None + fields1444 = (_t1815, _t1816,) + assert fields1444 is not None + unwrapped_fields1445 = fields1444 self.write("(csv_locator") self.indent_sexp() - field1441 = unwrapped_fields1440[0] - if field1441 is not None: + field1446 = unwrapped_fields1445[0] + if field1446 is not None: self.newline() - assert field1441 is not None - opt_val1442 = field1441 - self.pretty_csv_locator_paths(opt_val1442) - field1443 = unwrapped_fields1440[1] - if field1443 is not None: + assert field1446 is not None + opt_val1447 = field1446 + self.pretty_csv_locator_paths(opt_val1447) + field1448 = unwrapped_fields1445[1] + if field1448 is not None: self.newline() - assert field1443 is not None - opt_val1444 = field1443 - self.pretty_csv_locator_inline_data(opt_val1444) + assert field1448 is not None + opt_val1449 = field1448 + self.pretty_csv_locator_inline_data(opt_val1449) self.dedent() self.write(")") def pretty_csv_locator_paths(self, msg: Sequence[str]): - flat1449 = self._try_flat(msg, self.pretty_csv_locator_paths) - if flat1449 is not None: - assert flat1449 is not None - self.write(flat1449) + flat1454 = self._try_flat(msg, self.pretty_csv_locator_paths) + if flat1454 is not None: + assert flat1454 is not None + self.write(flat1454) return None else: - fields1446 = msg + fields1451 = msg self.write("(paths") self.indent_sexp() - if not len(fields1446) == 0: + if not len(fields1451) == 0: self.newline() - for i1448, elem1447 in enumerate(fields1446): - if (i1448 > 0): + for i1453, elem1452 in enumerate(fields1451): + if (i1453 > 0): self.newline() - self.write(self.format_string_value(elem1447)) + self.write(self.format_string_value(elem1452)) self.dedent() self.write(")") def pretty_csv_locator_inline_data(self, msg: str): - flat1451 = self._try_flat(msg, self.pretty_csv_locator_inline_data) - if flat1451 is not None: - assert flat1451 is not None - self.write(flat1451) + flat1456 = self._try_flat(msg, self.pretty_csv_locator_inline_data) + if flat1456 is not None: + assert flat1456 is not None + self.write(flat1456) return None else: - fields1450 = msg + fields1455 = msg self.write("(inline_data") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1450)) + self.write(self.format_string_value(fields1455)) self.dedent() self.write(")") def pretty_csv_config(self, msg: logic_pb2.CSVConfig): - flat1457 = self._try_flat(msg, self.pretty_csv_config) - if flat1457 is not None: - assert flat1457 is not None - self.write(flat1457) + flat1462 = self._try_flat(msg, self.pretty_csv_config) + if flat1462 is not None: + assert flat1462 is not None + self.write(flat1462) return None else: _dollar_dollar = msg - _t1807 = self.deconstruct_csv_config(_dollar_dollar) - _t1808 = self.deconstruct_csv_storage_integration_optional(_dollar_dollar) - fields1452 = (_t1807, _t1808,) - assert fields1452 is not None - unwrapped_fields1453 = fields1452 + _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 self.write("(csv_config") self.indent_sexp() self.newline() - field1454 = unwrapped_fields1453[0] - self.pretty_config_dict(field1454) - field1455 = unwrapped_fields1453[1] - if field1455 is not None: + field1459 = unwrapped_fields1458[0] + self.pretty_config_dict(field1459) + field1460 = unwrapped_fields1458[1] + if field1460 is not None: self.newline() - assert field1455 is not None - opt_val1456 = field1455 - self.pretty__storage_integration(opt_val1456) + assert field1460 is not None + opt_val1461 = field1460 + self.pretty__storage_integration(opt_val1461) self.dedent() self.write(")") def pretty__storage_integration(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - flat1459 = self._try_flat(msg, self.pretty__storage_integration) - if flat1459 is not None: - assert flat1459 is not None - self.write(flat1459) + flat1464 = self._try_flat(msg, self.pretty__storage_integration) + if flat1464 is not None: + assert flat1464 is not None + self.write(flat1464) return None else: - fields1458 = msg + fields1463 = msg self.write("(storage_integration") self.indent_sexp() self.newline() - self.pretty_config_dict(fields1458) + self.pretty_config_dict(fields1463) self.dedent() self.write(")") def pretty_gnf_columns(self, msg: Sequence[logic_pb2.GNFColumn]): - flat1463 = self._try_flat(msg, self.pretty_gnf_columns) - if flat1463 is not None: - assert flat1463 is not None - self.write(flat1463) + flat1468 = self._try_flat(msg, self.pretty_gnf_columns) + if flat1468 is not None: + assert flat1468 is not None + self.write(flat1468) return None else: - fields1460 = msg + fields1465 = msg self.write("(columns") self.indent_sexp() - if not len(fields1460) == 0: + if not len(fields1465) == 0: self.newline() - for i1462, elem1461 in enumerate(fields1460): - if (i1462 > 0): + for i1467, elem1466 in enumerate(fields1465): + if (i1467 > 0): self.newline() - self.pretty_gnf_column(elem1461) + self.pretty_gnf_column(elem1466) self.dedent() self.write(")") def pretty_gnf_column(self, msg: logic_pb2.GNFColumn): - flat1472 = self._try_flat(msg, self.pretty_gnf_column) - if flat1472 is not None: - assert flat1472 is not None - self.write(flat1472) + flat1477 = self._try_flat(msg, self.pretty_gnf_column) + if flat1477 is not None: + assert flat1477 is not None + self.write(flat1477) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("target_id"): - _t1809 = _dollar_dollar.target_id + _t1819 = _dollar_dollar.target_id else: - _t1809 = None - fields1464 = (_dollar_dollar.column_path, _t1809, _dollar_dollar.types,) - assert fields1464 is not None - unwrapped_fields1465 = fields1464 + _t1819 = None + fields1469 = (_dollar_dollar.column_path, _t1819, _dollar_dollar.types,) + assert fields1469 is not None + unwrapped_fields1470 = fields1469 self.write("(column") self.indent_sexp() self.newline() - field1466 = unwrapped_fields1465[0] - self.pretty_gnf_column_path(field1466) - field1467 = unwrapped_fields1465[1] - if field1467 is not None: + field1471 = unwrapped_fields1470[0] + self.pretty_gnf_column_path(field1471) + field1472 = unwrapped_fields1470[1] + if field1472 is not None: self.newline() - assert field1467 is not None - opt_val1468 = field1467 - self.pretty_relation_id(opt_val1468) + assert field1472 is not None + opt_val1473 = field1472 + self.pretty_relation_id(opt_val1473) self.newline() self.write("[") - field1469 = unwrapped_fields1465[2] - for i1471, elem1470 in enumerate(field1469): - if (i1471 > 0): + field1474 = unwrapped_fields1470[2] + for i1476, elem1475 in enumerate(field1474): + if (i1476 > 0): self.newline() - self.pretty_type(elem1470) + self.pretty_type(elem1475) self.write("]") self.dedent() self.write(")") def pretty_gnf_column_path(self, msg: Sequence[str]): - flat1479 = self._try_flat(msg, self.pretty_gnf_column_path) - if flat1479 is not None: - assert flat1479 is not None - self.write(flat1479) + flat1484 = self._try_flat(msg, self.pretty_gnf_column_path) + if flat1484 is not None: + assert flat1484 is not None + self.write(flat1484) return None else: _dollar_dollar = msg if len(_dollar_dollar) == 1: - _t1810 = _dollar_dollar[0] + _t1820 = _dollar_dollar[0] else: - _t1810 = None - deconstruct_result1477 = _t1810 - if deconstruct_result1477 is not None: - assert deconstruct_result1477 is not None - unwrapped1478 = deconstruct_result1477 - self.write(self.format_string_value(unwrapped1478)) + _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)) else: _dollar_dollar = msg if len(_dollar_dollar) != 1: - _t1811 = _dollar_dollar + _t1821 = _dollar_dollar else: - _t1811 = None - deconstruct_result1473 = _t1811 - if deconstruct_result1473 is not None: - assert deconstruct_result1473 is not None - unwrapped1474 = deconstruct_result1473 + _t1821 = None + deconstruct_result1478 = _t1821 + if deconstruct_result1478 is not None: + assert deconstruct_result1478 is not None + unwrapped1479 = deconstruct_result1478 self.write("[") self.indent() - for i1476, elem1475 in enumerate(unwrapped1474): - if (i1476 > 0): + for i1481, elem1480 in enumerate(unwrapped1479): + if (i1481 > 0): self.newline() - self.write(self.format_string_value(elem1475)) + self.write(self.format_string_value(elem1480)) self.dedent() self.write("]") else: raise ParseError("No matching rule for gnf_column_path") def pretty_target_relations(self, msg: logic_pb2.TargetRelations): - flat1484 = self._try_flat(msg, self.pretty_target_relations) - if flat1484 is not None: - assert flat1484 is not None - self.write(flat1484) + flat1489 = self._try_flat(msg, self.pretty_target_relations) + if flat1489 is not None: + assert flat1489 is not None + self.write(flat1489) return None else: _dollar_dollar = msg - fields1480 = (_dollar_dollar.keys, _dollar_dollar,) - assert fields1480 is not None - unwrapped_fields1481 = fields1480 + fields1485 = (_dollar_dollar.keys, _dollar_dollar,) + assert fields1485 is not None + unwrapped_fields1486 = fields1485 self.write("(relations") self.indent_sexp() self.newline() - field1482 = unwrapped_fields1481[0] - self.pretty_relation_keys(field1482) + field1487 = unwrapped_fields1486[0] + self.pretty_relation_keys(field1487) self.newline() - field1483 = unwrapped_fields1481[1] - self.pretty_relation_body(field1483) + field1488 = unwrapped_fields1486[1] + self.pretty_relation_body(field1488) self.dedent() self.write(")") def pretty_relation_keys(self, msg: Sequence[logic_pb2.NamedColumn]): - flat1488 = self._try_flat(msg, self.pretty_relation_keys) - if flat1488 is not None: - assert flat1488 is not None - self.write(flat1488) + flat1493 = self._try_flat(msg, self.pretty_relation_keys) + if flat1493 is not None: + assert flat1493 is not None + self.write(flat1493) return None else: - fields1485 = msg + fields1490 = msg self.write("(keys") self.indent_sexp() - if not len(fields1485) == 0: + if not len(fields1490) == 0: self.newline() - for i1487, elem1486 in enumerate(fields1485): - if (i1487 > 0): + for i1492, elem1491 in enumerate(fields1490): + if (i1492 > 0): self.newline() - self.pretty_named_column(elem1486) + self.pretty_named_column(elem1491) self.dedent() self.write(")") def pretty_named_column(self, msg: logic_pb2.NamedColumn): - flat1493 = self._try_flat(msg, self.pretty_named_column) - if flat1493 is not None: - assert flat1493 is not None - self.write(flat1493) + flat1498 = self._try_flat(msg, self.pretty_named_column) + if flat1498 is not None: + assert flat1498 is not None + self.write(flat1498) return None else: _dollar_dollar = msg - fields1489 = (_dollar_dollar.name, _dollar_dollar.type,) - assert fields1489 is not None - unwrapped_fields1490 = fields1489 + fields1494 = (_dollar_dollar.name, _dollar_dollar.type,) + assert fields1494 is not None + unwrapped_fields1495 = fields1494 self.write("(column") self.indent_sexp() self.newline() - field1491 = unwrapped_fields1490[0] - self.write(self.format_string_value(field1491)) + field1496 = unwrapped_fields1495[0] + self.write(self.format_string_value(field1496)) self.newline() - field1492 = unwrapped_fields1490[1] - self.pretty_type(field1492) + field1497 = unwrapped_fields1495[1] + self.pretty_type(field1497) self.dedent() self.write(")") def pretty_relation_body(self, msg: logic_pb2.TargetRelations): - flat1500 = self._try_flat(msg, self.pretty_relation_body) - if flat1500 is not None: - assert flat1500 is not None - self.write(flat1500) + flat1505 = self._try_flat(msg, self.pretty_relation_body) + if flat1505 is not None: + assert flat1505 is not None + self.write(flat1505) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("plain"): - _t1812 = _dollar_dollar.plain.targets + _t1822 = _dollar_dollar.plain.targets else: - _t1812 = None - deconstruct_result1498 = _t1812 - if deconstruct_result1498 is not None: - assert deconstruct_result1498 is not None - unwrapped1499 = deconstruct_result1498 - self.pretty_non_cdc_relations(unwrapped1499) + _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) else: _dollar_dollar = msg if _dollar_dollar.HasField("cdc"): - _t1813 = (_dollar_dollar.cdc.inserts, _dollar_dollar.cdc.deletes,) + _t1823 = (_dollar_dollar.cdc.inserts, _dollar_dollar.cdc.deletes,) else: - _t1813 = None - deconstruct_result1494 = _t1813 - if deconstruct_result1494 is not None: - assert deconstruct_result1494 is not None - unwrapped1495 = deconstruct_result1494 - field1496 = unwrapped1495[0] - self.pretty_cdc_inserts(field1496) + _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) self.write(" ") - field1497 = unwrapped1495[1] - self.pretty_cdc_deletes(field1497) + field1502 = unwrapped1500[1] + self.pretty_cdc_deletes(field1502) else: raise ParseError("No matching rule for relation_body") def pretty_non_cdc_relations(self, msg: Sequence[logic_pb2.TargetRelation]): - flat1504 = self._try_flat(msg, self.pretty_non_cdc_relations) - if flat1504 is not None: - assert flat1504 is not None - self.write(flat1504) + flat1509 = self._try_flat(msg, self.pretty_non_cdc_relations) + if flat1509 is not None: + assert flat1509 is not None + self.write(flat1509) return None else: - fields1501 = msg - for i1503, elem1502 in enumerate(fields1501): - if (i1503 > 0): + fields1506 = msg + for i1508, elem1507 in enumerate(fields1506): + if (i1508 > 0): self.newline() - self.pretty_target_relation(elem1502) + self.pretty_target_relation(elem1507) def pretty_target_relation(self, msg: logic_pb2.TargetRelation): - flat1511 = self._try_flat(msg, self.pretty_target_relation) - if flat1511 is not None: - assert flat1511 is not None - self.write(flat1511) + flat1516 = self._try_flat(msg, self.pretty_target_relation) + if flat1516 is not None: + assert flat1516 is not None + self.write(flat1516) return None else: _dollar_dollar = msg - fields1505 = (_dollar_dollar.target_id, _dollar_dollar.values,) - assert fields1505 is not None - unwrapped_fields1506 = fields1505 + fields1510 = (_dollar_dollar.target_id, _dollar_dollar.values,) + assert fields1510 is not None + unwrapped_fields1511 = fields1510 self.write("(relation") self.indent_sexp() self.newline() - field1507 = unwrapped_fields1506[0] - self.pretty_relation_id(field1507) - field1508 = unwrapped_fields1506[1] - if not len(field1508) == 0: + field1512 = unwrapped_fields1511[0] + self.pretty_relation_id(field1512) + field1513 = unwrapped_fields1511[1] + if not len(field1513) == 0: self.newline() - for i1510, elem1509 in enumerate(field1508): - if (i1510 > 0): + for i1515, elem1514 in enumerate(field1513): + if (i1515 > 0): self.newline() - self.pretty_named_column(elem1509) + self.pretty_named_column(elem1514) self.dedent() self.write(")") def pretty_cdc_inserts(self, msg: Sequence[logic_pb2.TargetRelation]): - flat1515 = self._try_flat(msg, self.pretty_cdc_inserts) - if flat1515 is not None: - assert flat1515 is not None - self.write(flat1515) + flat1520 = self._try_flat(msg, self.pretty_cdc_inserts) + if flat1520 is not None: + assert flat1520 is not None + self.write(flat1520) return None else: - fields1512 = msg + fields1517 = msg self.write("(inserts") self.indent_sexp() - if not len(fields1512) == 0: + if not len(fields1517) == 0: self.newline() - for i1514, elem1513 in enumerate(fields1512): - if (i1514 > 0): + for i1519, elem1518 in enumerate(fields1517): + if (i1519 > 0): self.newline() - self.pretty_target_relation(elem1513) + self.pretty_target_relation(elem1518) self.dedent() self.write(")") def pretty_cdc_deletes(self, msg: Sequence[logic_pb2.TargetRelation]): - flat1519 = self._try_flat(msg, self.pretty_cdc_deletes) - if flat1519 is not None: - assert flat1519 is not None - self.write(flat1519) + flat1524 = self._try_flat(msg, self.pretty_cdc_deletes) + if flat1524 is not None: + assert flat1524 is not None + self.write(flat1524) return None else: - fields1516 = msg + fields1521 = msg self.write("(deletes") self.indent_sexp() - if not len(fields1516) == 0: + if not len(fields1521) == 0: self.newline() - for i1518, elem1517 in enumerate(fields1516): - if (i1518 > 0): + for i1523, elem1522 in enumerate(fields1521): + if (i1523 > 0): self.newline() - self.pretty_target_relation(elem1517) + self.pretty_target_relation(elem1522) self.dedent() self.write(")") def pretty_csv_asof(self, msg: str): - flat1521 = self._try_flat(msg, self.pretty_csv_asof) - if flat1521 is not None: - assert flat1521 is not None - self.write(flat1521) + flat1526 = self._try_flat(msg, self.pretty_csv_asof) + if flat1526 is not None: + assert flat1526 is not None + self.write(flat1526) return None else: - fields1520 = msg + fields1525 = msg self.write("(asof") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1520)) + self.write(self.format_string_value(fields1525)) self.dedent() self.write(")") def pretty_iceberg_data(self, msg: logic_pb2.IcebergData): - flat1532 = self._try_flat(msg, self.pretty_iceberg_data) - if flat1532 is not None: - assert flat1532 is not None - self.write(flat1532) + flat1537 = self._try_flat(msg, self.pretty_iceberg_data) + if flat1537 is not None: + assert flat1537 is not None + self.write(flat1537) return None else: _dollar_dollar = msg - _t1814 = self.deconstruct_iceberg_data_from_snapshot_optional(_dollar_dollar) - _t1815 = self.deconstruct_iceberg_data_to_snapshot_optional(_dollar_dollar) - fields1522 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1814, _t1815, _dollar_dollar.returns_delta,) - assert fields1522 is not None - unwrapped_fields1523 = fields1522 + _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 self.write("(iceberg_data") self.indent_sexp() self.newline() - field1524 = unwrapped_fields1523[0] - self.pretty_iceberg_locator(field1524) + field1529 = unwrapped_fields1528[0] + self.pretty_iceberg_locator(field1529) self.newline() - field1525 = unwrapped_fields1523[1] - self.pretty_iceberg_catalog_config(field1525) + field1530 = unwrapped_fields1528[1] + self.pretty_iceberg_catalog_config(field1530) self.newline() - field1526 = unwrapped_fields1523[2] - self.pretty_gnf_columns(field1526) - field1527 = unwrapped_fields1523[3] - if field1527 is not None: + field1531 = unwrapped_fields1528[2] + self.pretty_gnf_columns(field1531) + field1532 = unwrapped_fields1528[3] + if field1532 is not None: self.newline() - assert field1527 is not None - opt_val1528 = field1527 - self.pretty_iceberg_from_snapshot(opt_val1528) - field1529 = unwrapped_fields1523[4] - if field1529 is not None: + assert field1532 is not None + opt_val1533 = field1532 + self.pretty_iceberg_from_snapshot(opt_val1533) + field1534 = unwrapped_fields1528[4] + if field1534 is not None: self.newline() - assert field1529 is not None - opt_val1530 = field1529 - self.pretty_iceberg_to_snapshot(opt_val1530) + assert field1534 is not None + opt_val1535 = field1534 + self.pretty_iceberg_to_snapshot(opt_val1535) self.newline() - field1531 = unwrapped_fields1523[5] - self.pretty_boolean_value(field1531) + field1536 = unwrapped_fields1528[5] + self.pretty_boolean_value(field1536) self.dedent() self.write(")") def pretty_iceberg_locator(self, msg: logic_pb2.IcebergLocator): - flat1538 = self._try_flat(msg, self.pretty_iceberg_locator) - if flat1538 is not None: - assert flat1538 is not None - self.write(flat1538) + flat1543 = self._try_flat(msg, self.pretty_iceberg_locator) + if flat1543 is not None: + assert flat1543 is not None + self.write(flat1543) return None else: _dollar_dollar = msg - fields1533 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - assert fields1533 is not None - unwrapped_fields1534 = fields1533 + fields1538 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + assert fields1538 is not None + unwrapped_fields1539 = fields1538 self.write("(iceberg_locator") self.indent_sexp() self.newline() - field1535 = unwrapped_fields1534[0] - self.pretty_iceberg_locator_table_name(field1535) + field1540 = unwrapped_fields1539[0] + self.pretty_iceberg_locator_table_name(field1540) self.newline() - field1536 = unwrapped_fields1534[1] - self.pretty_iceberg_locator_namespace(field1536) + field1541 = unwrapped_fields1539[1] + self.pretty_iceberg_locator_namespace(field1541) self.newline() - field1537 = unwrapped_fields1534[2] - self.pretty_iceberg_locator_warehouse(field1537) + field1542 = unwrapped_fields1539[2] + self.pretty_iceberg_locator_warehouse(field1542) self.dedent() self.write(")") def pretty_iceberg_locator_table_name(self, msg: str): - flat1540 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) - if flat1540 is not None: - assert flat1540 is not None - self.write(flat1540) + flat1545 = self._try_flat(msg, self.pretty_iceberg_locator_table_name) + if flat1545 is not None: + assert flat1545 is not None + self.write(flat1545) return None else: - fields1539 = msg + fields1544 = msg self.write("(table_name") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1539)) + self.write(self.format_string_value(fields1544)) self.dedent() self.write(")") def pretty_iceberg_locator_namespace(self, msg: Sequence[str]): - flat1544 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) - if flat1544 is not None: - assert flat1544 is not None - self.write(flat1544) + flat1549 = self._try_flat(msg, self.pretty_iceberg_locator_namespace) + if flat1549 is not None: + assert flat1549 is not None + self.write(flat1549) return None else: - fields1541 = msg + fields1546 = msg self.write("(namespace") self.indent_sexp() - if not len(fields1541) == 0: + if not len(fields1546) == 0: self.newline() - for i1543, elem1542 in enumerate(fields1541): - if (i1543 > 0): + for i1548, elem1547 in enumerate(fields1546): + if (i1548 > 0): self.newline() - self.write(self.format_string_value(elem1542)) + self.write(self.format_string_value(elem1547)) self.dedent() self.write(")") def pretty_iceberg_locator_warehouse(self, msg: str): - flat1546 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) - if flat1546 is not None: - assert flat1546 is not None - self.write(flat1546) + flat1551 = self._try_flat(msg, self.pretty_iceberg_locator_warehouse) + if flat1551 is not None: + assert flat1551 is not None + self.write(flat1551) return None else: - fields1545 = msg + fields1550 = msg self.write("(warehouse") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1545)) + self.write(self.format_string_value(fields1550)) self.dedent() self.write(")") def pretty_iceberg_catalog_config(self, msg: logic_pb2.IcebergCatalogConfig): - flat1554 = self._try_flat(msg, self.pretty_iceberg_catalog_config) - if flat1554 is not None: - assert flat1554 is not None - self.write(flat1554) + flat1559 = self._try_flat(msg, self.pretty_iceberg_catalog_config) + if flat1559 is not None: + assert flat1559 is not None + self.write(flat1559) return None else: _dollar_dollar = msg - _t1816 = self.deconstruct_iceberg_catalog_config_scope_optional(_dollar_dollar) - fields1547 = (_dollar_dollar.catalog_uri, _t1816, sorted(_dollar_dollar.properties.items()), sorted(_dollar_dollar.auth_properties.items()),) - assert fields1547 is not None - unwrapped_fields1548 = fields1547 + _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 self.write("(iceberg_catalog_config") self.indent_sexp() self.newline() - field1549 = unwrapped_fields1548[0] - self.pretty_iceberg_catalog_uri(field1549) - field1550 = unwrapped_fields1548[1] - if field1550 is not None: + field1554 = unwrapped_fields1553[0] + self.pretty_iceberg_catalog_uri(field1554) + field1555 = unwrapped_fields1553[1] + if field1555 is not None: self.newline() - assert field1550 is not None - opt_val1551 = field1550 - self.pretty_iceberg_catalog_config_scope(opt_val1551) + assert field1555 is not None + opt_val1556 = field1555 + self.pretty_iceberg_catalog_config_scope(opt_val1556) self.newline() - field1552 = unwrapped_fields1548[2] - self.pretty_iceberg_properties(field1552) + field1557 = unwrapped_fields1553[2] + self.pretty_iceberg_properties(field1557) self.newline() - field1553 = unwrapped_fields1548[3] - self.pretty_iceberg_auth_properties(field1553) + field1558 = unwrapped_fields1553[3] + self.pretty_iceberg_auth_properties(field1558) self.dedent() self.write(")") def pretty_iceberg_catalog_uri(self, msg: str): - flat1556 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) - if flat1556 is not None: - assert flat1556 is not None - self.write(flat1556) + flat1561 = self._try_flat(msg, self.pretty_iceberg_catalog_uri) + if flat1561 is not None: + assert flat1561 is not None + self.write(flat1561) return None else: - fields1555 = msg + fields1560 = msg self.write("(catalog_uri") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1555)) + self.write(self.format_string_value(fields1560)) self.dedent() self.write(")") def pretty_iceberg_catalog_config_scope(self, msg: str): - flat1558 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) - if flat1558 is not None: - assert flat1558 is not None - self.write(flat1558) + flat1563 = self._try_flat(msg, self.pretty_iceberg_catalog_config_scope) + if flat1563 is not None: + assert flat1563 is not None + self.write(flat1563) return None else: - fields1557 = msg + fields1562 = msg self.write("(scope") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1557)) + self.write(self.format_string_value(fields1562)) self.dedent() self.write(")") def pretty_iceberg_properties(self, msg: Sequence[tuple[str, str]]): - flat1562 = self._try_flat(msg, self.pretty_iceberg_properties) - if flat1562 is not None: - assert flat1562 is not None - self.write(flat1562) + flat1567 = self._try_flat(msg, self.pretty_iceberg_properties) + if flat1567 is not None: + assert flat1567 is not None + self.write(flat1567) return None else: - fields1559 = msg + fields1564 = msg self.write("(properties") self.indent_sexp() - if not len(fields1559) == 0: + if not len(fields1564) == 0: self.newline() - for i1561, elem1560 in enumerate(fields1559): - if (i1561 > 0): + for i1566, elem1565 in enumerate(fields1564): + if (i1566 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1560) + self.pretty_iceberg_property_entry(elem1565) self.dedent() self.write(")") def pretty_iceberg_property_entry(self, msg: tuple[str, str]): - flat1567 = self._try_flat(msg, self.pretty_iceberg_property_entry) - if flat1567 is not None: - assert flat1567 is not None - self.write(flat1567) + flat1572 = self._try_flat(msg, self.pretty_iceberg_property_entry) + if flat1572 is not None: + assert flat1572 is not None + self.write(flat1572) return None else: _dollar_dollar = msg - fields1563 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields1563 is not None - unwrapped_fields1564 = fields1563 + fields1568 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields1568 is not None + unwrapped_fields1569 = fields1568 self.write("(prop") self.indent_sexp() self.newline() - field1565 = unwrapped_fields1564[0] - self.write(self.format_string_value(field1565)) + field1570 = unwrapped_fields1569[0] + self.write(self.format_string_value(field1570)) self.newline() - field1566 = unwrapped_fields1564[1] - self.write(self.format_string_value(field1566)) + field1571 = unwrapped_fields1569[1] + self.write(self.format_string_value(field1571)) self.dedent() self.write(")") def pretty_iceberg_auth_properties(self, msg: Sequence[tuple[str, str]]): - flat1571 = self._try_flat(msg, self.pretty_iceberg_auth_properties) - if flat1571 is not None: - assert flat1571 is not None - self.write(flat1571) + flat1576 = self._try_flat(msg, self.pretty_iceberg_auth_properties) + if flat1576 is not None: + assert flat1576 is not None + self.write(flat1576) return None else: - fields1568 = msg + fields1573 = msg self.write("(auth_properties") self.indent_sexp() - if not len(fields1568) == 0: + if not len(fields1573) == 0: self.newline() - for i1570, elem1569 in enumerate(fields1568): - if (i1570 > 0): + for i1575, elem1574 in enumerate(fields1573): + if (i1575 > 0): self.newline() - self.pretty_iceberg_masked_property_entry(elem1569) + self.pretty_iceberg_masked_property_entry(elem1574) self.dedent() self.write(")") def pretty_iceberg_masked_property_entry(self, msg: tuple[str, str]): - flat1576 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) - if flat1576 is not None: - assert flat1576 is not None - self.write(flat1576) + flat1581 = self._try_flat(msg, self.pretty_iceberg_masked_property_entry) + if flat1581 is not None: + assert flat1581 is not None + self.write(flat1581) return None else: _dollar_dollar = msg - _t1817 = self.mask_secret_value(_dollar_dollar) - fields1572 = (_dollar_dollar[0], _t1817,) - assert fields1572 is not None - unwrapped_fields1573 = fields1572 + _t1827 = self.mask_secret_value(_dollar_dollar) + fields1577 = (_dollar_dollar[0], _t1827,) + assert fields1577 is not None + unwrapped_fields1578 = fields1577 self.write("(prop") self.indent_sexp() self.newline() - field1574 = unwrapped_fields1573[0] - self.write(self.format_string_value(field1574)) + field1579 = unwrapped_fields1578[0] + self.write(self.format_string_value(field1579)) self.newline() - field1575 = unwrapped_fields1573[1] - self.write(self.format_string_value(field1575)) + field1580 = unwrapped_fields1578[1] + self.write(self.format_string_value(field1580)) self.dedent() self.write(")") def pretty_iceberg_from_snapshot(self, msg: str): - flat1578 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) - if flat1578 is not None: - assert flat1578 is not None - self.write(flat1578) + flat1583 = self._try_flat(msg, self.pretty_iceberg_from_snapshot) + if flat1583 is not None: + assert flat1583 is not None + self.write(flat1583) return None else: - fields1577 = msg + fields1582 = msg self.write("(from_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1577)) + self.write(self.format_string_value(fields1582)) self.dedent() self.write(")") def pretty_iceberg_to_snapshot(self, msg: str): - flat1580 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) - if flat1580 is not None: - assert flat1580 is not None - self.write(flat1580) + flat1585 = self._try_flat(msg, self.pretty_iceberg_to_snapshot) + if flat1585 is not None: + assert flat1585 is not None + self.write(flat1585) return None else: - fields1579 = msg + fields1584 = msg self.write("(to_snapshot") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1579)) + self.write(self.format_string_value(fields1584)) self.dedent() self.write(")") def pretty_undefine(self, msg: transactions_pb2.Undefine): - flat1583 = self._try_flat(msg, self.pretty_undefine) - if flat1583 is not None: - assert flat1583 is not None - self.write(flat1583) + flat1588 = self._try_flat(msg, self.pretty_undefine) + if flat1588 is not None: + assert flat1588 is not None + self.write(flat1588) return None else: _dollar_dollar = msg - fields1581 = _dollar_dollar.fragment_id - assert fields1581 is not None - unwrapped_fields1582 = fields1581 + fields1586 = _dollar_dollar.fragment_id + assert fields1586 is not None + unwrapped_fields1587 = fields1586 self.write("(undefine") self.indent_sexp() self.newline() - self.pretty_fragment_id(unwrapped_fields1582) + self.pretty_fragment_id(unwrapped_fields1587) self.dedent() self.write(")") def pretty_context(self, msg: transactions_pb2.Context): - flat1588 = self._try_flat(msg, self.pretty_context) - if flat1588 is not None: - assert flat1588 is not None - self.write(flat1588) + flat1593 = self._try_flat(msg, self.pretty_context) + if flat1593 is not None: + assert flat1593 is not None + self.write(flat1593) return None else: _dollar_dollar = msg - fields1584 = _dollar_dollar.relations - assert fields1584 is not None - unwrapped_fields1585 = fields1584 + fields1589 = _dollar_dollar.relations + assert fields1589 is not None + unwrapped_fields1590 = fields1589 self.write("(context") self.indent_sexp() - if not len(unwrapped_fields1585) == 0: + if not len(unwrapped_fields1590) == 0: self.newline() - for i1587, elem1586 in enumerate(unwrapped_fields1585): - if (i1587 > 0): + for i1592, elem1591 in enumerate(unwrapped_fields1590): + if (i1592 > 0): self.newline() - self.pretty_relation_id(elem1586) + self.pretty_relation_id(elem1591) self.dedent() self.write(")") def pretty_snapshot(self, msg: transactions_pb2.Snapshot): - flat1595 = self._try_flat(msg, self.pretty_snapshot) - if flat1595 is not None: - assert flat1595 is not None - self.write(flat1595) + flat1600 = self._try_flat(msg, self.pretty_snapshot) + if flat1600 is not None: + assert flat1600 is not None + self.write(flat1600) return None else: _dollar_dollar = msg - fields1589 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - assert fields1589 is not None - unwrapped_fields1590 = fields1589 + fields1594 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + assert fields1594 is not None + unwrapped_fields1595 = fields1594 self.write("(snapshot") self.indent_sexp() self.newline() - field1591 = unwrapped_fields1590[0] - self.pretty_edb_path(field1591) - field1592 = unwrapped_fields1590[1] - if not len(field1592) == 0: + field1596 = unwrapped_fields1595[0] + self.pretty_edb_path(field1596) + field1597 = unwrapped_fields1595[1] + if not len(field1597) == 0: self.newline() - for i1594, elem1593 in enumerate(field1592): - if (i1594 > 0): + for i1599, elem1598 in enumerate(field1597): + if (i1599 > 0): self.newline() - self.pretty_snapshot_mapping(elem1593) + self.pretty_snapshot_mapping(elem1598) self.dedent() self.write(")") def pretty_snapshot_mapping(self, msg: transactions_pb2.SnapshotMapping): - flat1600 = self._try_flat(msg, self.pretty_snapshot_mapping) - if flat1600 is not None: - assert flat1600 is not None - self.write(flat1600) + flat1605 = self._try_flat(msg, self.pretty_snapshot_mapping) + if flat1605 is not None: + assert flat1605 is not None + self.write(flat1605) return None else: _dollar_dollar = msg - fields1596 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - assert fields1596 is not None - unwrapped_fields1597 = fields1596 - field1598 = unwrapped_fields1597[0] - self.pretty_edb_path(field1598) + 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) self.write(" ") - field1599 = unwrapped_fields1597[1] - self.pretty_relation_id(field1599) + field1604 = unwrapped_fields1602[1] + self.pretty_relation_id(field1604) def pretty_epoch_reads(self, msg: Sequence[transactions_pb2.Read]): - flat1604 = self._try_flat(msg, self.pretty_epoch_reads) - if flat1604 is not None: - assert flat1604 is not None - self.write(flat1604) + flat1609 = self._try_flat(msg, self.pretty_epoch_reads) + if flat1609 is not None: + assert flat1609 is not None + self.write(flat1609) return None else: - fields1601 = msg + fields1606 = msg self.write("(reads") self.indent_sexp() - if not len(fields1601) == 0: + if not len(fields1606) == 0: self.newline() - for i1603, elem1602 in enumerate(fields1601): - if (i1603 > 0): + for i1608, elem1607 in enumerate(fields1606): + if (i1608 > 0): self.newline() - self.pretty_read(elem1602) + self.pretty_read(elem1607) self.dedent() self.write(")") def pretty_read(self, msg: transactions_pb2.Read): - flat1615 = self._try_flat(msg, self.pretty_read) - if flat1615 is not None: - assert flat1615 is not None - self.write(flat1615) + flat1620 = self._try_flat(msg, self.pretty_read) + if flat1620 is not None: + assert flat1620 is not None + self.write(flat1620) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("demand"): - _t1818 = _dollar_dollar.demand + _t1828 = _dollar_dollar.demand else: - _t1818 = None - deconstruct_result1613 = _t1818 - if deconstruct_result1613 is not None: - assert deconstruct_result1613 is not None - unwrapped1614 = deconstruct_result1613 - self.pretty_demand(unwrapped1614) + _t1828 = None + deconstruct_result1618 = _t1828 + if deconstruct_result1618 is not None: + assert deconstruct_result1618 is not None + unwrapped1619 = deconstruct_result1618 + self.pretty_demand(unwrapped1619) else: _dollar_dollar = msg if _dollar_dollar.HasField("output"): - _t1819 = _dollar_dollar.output + _t1829 = _dollar_dollar.output else: - _t1819 = None - deconstruct_result1611 = _t1819 - if deconstruct_result1611 is not None: - assert deconstruct_result1611 is not None - unwrapped1612 = deconstruct_result1611 - self.pretty_output(unwrapped1612) + _t1829 = None + deconstruct_result1616 = _t1829 + if deconstruct_result1616 is not None: + assert deconstruct_result1616 is not None + unwrapped1617 = deconstruct_result1616 + self.pretty_output(unwrapped1617) else: _dollar_dollar = msg if _dollar_dollar.HasField("what_if"): - _t1820 = _dollar_dollar.what_if + _t1830 = _dollar_dollar.what_if else: - _t1820 = None - deconstruct_result1609 = _t1820 - if deconstruct_result1609 is not None: - assert deconstruct_result1609 is not None - unwrapped1610 = deconstruct_result1609 - self.pretty_what_if(unwrapped1610) + _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) else: _dollar_dollar = msg if _dollar_dollar.HasField("abort"): - _t1821 = _dollar_dollar.abort + _t1831 = _dollar_dollar.abort else: - _t1821 = None - deconstruct_result1607 = _t1821 - if deconstruct_result1607 is not None: - assert deconstruct_result1607 is not None - unwrapped1608 = deconstruct_result1607 - self.pretty_abort(unwrapped1608) + _t1831 = None + deconstruct_result1612 = _t1831 + if deconstruct_result1612 is not None: + assert deconstruct_result1612 is not None + unwrapped1613 = deconstruct_result1612 + self.pretty_abort(unwrapped1613) else: _dollar_dollar = msg if _dollar_dollar.HasField("export"): - _t1822 = _dollar_dollar.export + _t1832 = _dollar_dollar.export else: - _t1822 = None - deconstruct_result1605 = _t1822 - if deconstruct_result1605 is not None: - assert deconstruct_result1605 is not None - unwrapped1606 = deconstruct_result1605 - self.pretty_export(unwrapped1606) + _t1832 = None + deconstruct_result1610 = _t1832 + if deconstruct_result1610 is not None: + assert deconstruct_result1610 is not None + unwrapped1611 = deconstruct_result1610 + self.pretty_export(unwrapped1611) else: raise ParseError("No matching rule for read") def pretty_demand(self, msg: transactions_pb2.Demand): - flat1618 = self._try_flat(msg, self.pretty_demand) - if flat1618 is not None: - assert flat1618 is not None - self.write(flat1618) - return None - else: - _dollar_dollar = msg - fields1616 = _dollar_dollar.relation_id - assert fields1616 is not None - unwrapped_fields1617 = fields1616 - self.write("(demand") - self.indent_sexp() - self.newline() - self.pretty_relation_id(unwrapped_fields1617) - self.dedent() - self.write(")") - - def pretty_output(self, msg: transactions_pb2.Output): - flat1623 = self._try_flat(msg, self.pretty_output) + flat1623 = self._try_flat(msg, self.pretty_demand) if flat1623 is not None: assert flat1623 is not None self.write(flat1623) return None else: _dollar_dollar = msg - fields1619 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - assert fields1619 is not None - unwrapped_fields1620 = fields1619 - self.write("(output") + fields1621 = _dollar_dollar.relation_id + assert fields1621 is not None + unwrapped_fields1622 = fields1621 + self.write("(demand") self.indent_sexp() self.newline() - field1621 = unwrapped_fields1620[0] - self.pretty_name(field1621) - self.newline() - field1622 = unwrapped_fields1620[1] - self.pretty_relation_id(field1622) + self.pretty_relation_id(unwrapped_fields1622) self.dedent() self.write(")") - def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1628 = self._try_flat(msg, self.pretty_what_if) + 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) return None else: _dollar_dollar = msg - fields1624 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + fields1624 = (_dollar_dollar.name, _dollar_dollar.relation_id,) assert fields1624 is not None unwrapped_fields1625 = fields1624 - self.write("(what_if") ->>>>>>> origin/main + self.write("(output") self.indent_sexp() self.newline() field1626 = unwrapped_fields1625[0] self.pretty_name(field1626) self.newline() -<<<<<<< HEAD - field1541 = unwrapped_fields1539[1] - self.pretty_relation_id(field1541) + field1627 = unwrapped_fields1625[1] + self.pretty_relation_id(field1627) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1547 = self._try_flat(msg, self.pretty_what_if) - if flat1547 is not None: - assert flat1547 is not None - self.write(flat1547) + flat1633 = self._try_flat(msg, self.pretty_what_if) + if flat1633 is not None: + assert flat1633 is not None + self.write(flat1633) return None else: _dollar_dollar = msg - fields1543 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - assert fields1543 is not None - unwrapped_fields1544 = fields1543 + fields1629 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + assert fields1629 is not None + unwrapped_fields1630 = fields1629 self.write("(what_if") self.indent_sexp() self.newline() - field1545 = unwrapped_fields1544[0] - self.pretty_name(field1545) + field1631 = unwrapped_fields1630[0] + self.pretty_name(field1631) self.newline() - field1546 = unwrapped_fields1544[1] - self.pretty_epoch(field1546) -======= - field1627 = unwrapped_fields1625[1] - self.pretty_epoch(field1627) ->>>>>>> origin/main + field1632 = unwrapped_fields1630[1] + self.pretty_epoch(field1632) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): -<<<<<<< HEAD - flat1553 = self._try_flat(msg, self.pretty_abort) - if flat1553 is not None: - assert flat1553 is not None - self.write(flat1553) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.name != "abort": - _t1743 = _dollar_dollar.name - else: - _t1743 = None - fields1548 = (_t1743, _dollar_dollar.relation_id,) - assert fields1548 is not None - unwrapped_fields1549 = fields1548 - self.write("(abort") - self.indent_sexp() - field1550 = unwrapped_fields1549[0] - if field1550 is not None: - self.newline() - assert field1550 is not None - opt_val1551 = field1550 - self.pretty_name(opt_val1551) - self.newline() - field1552 = unwrapped_fields1549[1] - self.pretty_relation_id(field1552) - self.dedent() - self.write(")") - - def pretty_export(self, msg: transactions_pb2.Export): - flat1558 = self._try_flat(msg, self.pretty_export) - if flat1558 is not None: - assert flat1558 is not None - self.write(flat1558) - return None - else: - _dollar_dollar = msg - if _dollar_dollar.HasField("csv_config"): - _t1744 = _dollar_dollar.csv_config - else: - _t1744 = None - deconstruct_result1556 = _t1744 - if deconstruct_result1556 is not None: - assert deconstruct_result1556 is not None - unwrapped1557 = deconstruct_result1556 - self.write("(export") - self.indent_sexp() - self.newline() - self.pretty_export_csv_config(unwrapped1557) -======= - flat1634 = self._try_flat(msg, self.pretty_abort) - if flat1634 is not None: - assert flat1634 is not None - self.write(flat1634) + flat1639 = self._try_flat(msg, self.pretty_abort) + if flat1639 is not None: + assert flat1639 is not None + self.write(flat1639) return None else: _dollar_dollar = msg if _dollar_dollar.name != "abort": - _t1823 = _dollar_dollar.name + _t1833 = _dollar_dollar.name else: - _t1823 = None - fields1629 = (_t1823, _dollar_dollar.relation_id,) - assert fields1629 is not None - unwrapped_fields1630 = fields1629 + _t1833 = None + fields1634 = (_t1833, _dollar_dollar.relation_id,) + assert fields1634 is not None + unwrapped_fields1635 = fields1634 self.write("(abort") self.indent_sexp() - field1631 = unwrapped_fields1630[0] - if field1631 is not None: + field1636 = unwrapped_fields1635[0] + if field1636 is not None: self.newline() - assert field1631 is not None - opt_val1632 = field1631 - self.pretty_name(opt_val1632) + assert field1636 is not None + opt_val1637 = field1636 + self.pretty_name(opt_val1637) self.newline() - field1633 = unwrapped_fields1630[1] - self.pretty_relation_id(field1633) + field1638 = unwrapped_fields1635[1] + self.pretty_relation_id(field1638) self.dedent() self.write(")") def pretty_export(self, msg: transactions_pb2.Export): - flat1639 = self._try_flat(msg, self.pretty_export) - if flat1639 is not None: - assert flat1639 is not None - self.write(flat1639) + flat1644 = self._try_flat(msg, self.pretty_export) + if flat1644 is not None: + assert flat1644 is not None + self.write(flat1644) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("csv_config"): - _t1824 = _dollar_dollar.csv_config + _t1834 = _dollar_dollar.csv_config else: - _t1824 = None - deconstruct_result1637 = _t1824 - if deconstruct_result1637 is not None: - assert deconstruct_result1637 is not None - unwrapped1638 = deconstruct_result1637 + _t1834 = None + deconstruct_result1642 = _t1834 + if deconstruct_result1642 is not None: + assert deconstruct_result1642 is not None + unwrapped1643 = deconstruct_result1642 self.write("(export") self.indent_sexp() self.newline() - self.pretty_export_csv_config(unwrapped1638) ->>>>>>> origin/main + self.pretty_export_csv_config(unwrapped1643) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_config"): -<<<<<<< HEAD - _t1745 = _dollar_dollar.iceberg_config - else: - _t1745 = None - deconstruct_result1554 = _t1745 - if deconstruct_result1554 is not None: - assert deconstruct_result1554 is not None - unwrapped1555 = deconstruct_result1554 - self.write("(export_iceberg") - self.indent_sexp() - self.newline() - self.pretty_export_iceberg_config(unwrapped1555) -======= - _t1825 = _dollar_dollar.iceberg_config + _t1835 = _dollar_dollar.iceberg_config else: - _t1825 = None - deconstruct_result1635 = _t1825 - if deconstruct_result1635 is not None: - assert deconstruct_result1635 is not None - unwrapped1636 = deconstruct_result1635 + _t1835 = None + deconstruct_result1640 = _t1835 + if deconstruct_result1640 is not None: + assert deconstruct_result1640 is not None + unwrapped1641 = deconstruct_result1640 self.write("(export_iceberg") self.indent_sexp() self.newline() - self.pretty_export_iceberg_config(unwrapped1636) ->>>>>>> origin/main + self.pretty_export_iceberg_config(unwrapped1641) self.dedent() self.write(")") else: raise ParseError("No matching rule for export") def pretty_export_csv_config(self, msg: transactions_pb2.ExportCSVConfig): -<<<<<<< HEAD - flat1569 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1569 is not None: - assert flat1569 is not None - self.write(flat1569) -======= - flat1650 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1650 is not None: - assert flat1650 is not None - self.write(flat1650) ->>>>>>> origin/main + flat1655 = self._try_flat(msg, self.pretty_export_csv_config) + if flat1655 is not None: + assert flat1655 is not None + self.write(flat1655) return None else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) == 0: -<<<<<<< HEAD - _t1747 = self.deconstruct_export_csv_output_location(_dollar_dollar) - _t1746 = (_t1747, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) - else: - _t1746 = None - deconstruct_result1564 = _t1746 - if deconstruct_result1564 is not None: - assert deconstruct_result1564 is not None - unwrapped1565 = deconstruct_result1564 - self.write("(export_csv_config_v2") - self.indent_sexp() - self.newline() - field1566 = unwrapped1565[0] - self.pretty_export_csv_output_location(field1566) - self.newline() - field1567 = unwrapped1565[1] - self.pretty_export_csv_source(field1567) - self.newline() - field1568 = unwrapped1565[2] - self.pretty_csv_config(field1568) -======= - _t1826 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) - else: - _t1826 = None - deconstruct_result1645 = _t1826 - if deconstruct_result1645 is not None: - assert deconstruct_result1645 is not None - unwrapped1646 = deconstruct_result1645 + _t1837 = self.deconstruct_export_csv_output_location(_dollar_dollar) + _t1836 = (_t1837, _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 self.write("(export_csv_config_v2") self.indent_sexp() self.newline() - field1647 = unwrapped1646[0] - self.pretty_export_csv_path(field1647) + field1652 = unwrapped1651[0] + self.pretty_export_csv_output_location(field1652) self.newline() - field1648 = unwrapped1646[1] - self.pretty_export_csv_source(field1648) + field1653 = unwrapped1651[1] + self.pretty_export_csv_source(field1653) self.newline() - field1649 = unwrapped1646[2] - self.pretty_csv_config(field1649) ->>>>>>> origin/main + field1654 = unwrapped1651[2] + self.pretty_csv_config(field1654) self.dedent() self.write(")") else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) != 0: -<<<<<<< HEAD - _t1749 = self.deconstruct_export_csv_config(_dollar_dollar) - _t1748 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1749,) - else: - _t1748 = None - deconstruct_result1559 = _t1748 - if deconstruct_result1559 is not None: - assert deconstruct_result1559 is not None - unwrapped1560 = deconstruct_result1559 - self.write("(export_csv_config") - self.indent_sexp() - self.newline() - field1561 = unwrapped1560[0] - self.pretty_export_csv_path(field1561) - self.newline() - field1562 = unwrapped1560[1] - self.pretty_export_csv_columns_list(field1562) - self.newline() - field1563 = unwrapped1560[2] - self.pretty_config_dict(field1563) -======= - _t1828 = self.deconstruct_export_csv_config(_dollar_dollar) - _t1827 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1828,) + _t1839 = self.deconstruct_export_csv_config(_dollar_dollar) + _t1838 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1839,) else: - _t1827 = None - deconstruct_result1640 = _t1827 - if deconstruct_result1640 is not None: - assert deconstruct_result1640 is not None - unwrapped1641 = deconstruct_result1640 + _t1838 = None + deconstruct_result1645 = _t1838 + if deconstruct_result1645 is not None: + assert deconstruct_result1645 is not None + unwrapped1646 = deconstruct_result1645 self.write("(export_csv_config") self.indent_sexp() self.newline() - field1642 = unwrapped1641[0] - self.pretty_export_csv_path(field1642) + field1647 = unwrapped1646[0] + self.pretty_export_csv_path(field1647) self.newline() - field1643 = unwrapped1641[1] - self.pretty_export_csv_columns_list(field1643) + field1648 = unwrapped1646[1] + self.pretty_export_csv_columns_list(field1648) self.newline() - field1644 = unwrapped1641[2] - self.pretty_config_dict(field1644) ->>>>>>> origin/main + field1649 = unwrapped1646[2] + self.pretty_config_dict(field1649) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_config") -<<<<<<< HEAD def pretty_export_csv_output_location(self, msg: tuple[str, str]): - flat1574 = self._try_flat(msg, self.pretty_export_csv_output_location) - if flat1574 is not None: - assert flat1574 is not None - self.write(flat1574) + flat1660 = self._try_flat(msg, self.pretty_export_csv_output_location) + if flat1660 is not None: + assert flat1660 is not None + self.write(flat1660) return None else: _dollar_dollar = msg if _dollar_dollar[0] != "": - _t1750 = _dollar_dollar[0] + _t1840 = _dollar_dollar[0] else: - _t1750 = None - deconstruct_result1572 = _t1750 - if deconstruct_result1572 is not None: - assert deconstruct_result1572 is not None - unwrapped1573 = deconstruct_result1572 + _t1840 = None + deconstruct_result1658 = _t1840 + if deconstruct_result1658 is not None: + assert deconstruct_result1658 is not None + unwrapped1659 = deconstruct_result1658 self.write("(path") self.indent_sexp() self.newline() - self.write(self.format_string_value(unwrapped1573)) + self.write(self.format_string_value(unwrapped1659)) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar[1] != "": - _t1751 = _dollar_dollar[1] + _t1841 = _dollar_dollar[1] else: - _t1751 = None - deconstruct_result1570 = _t1751 - if deconstruct_result1570 is not None: - assert deconstruct_result1570 is not None - unwrapped1571 = deconstruct_result1570 + _t1841 = None + deconstruct_result1656 = _t1841 + if deconstruct_result1656 is not None: + assert deconstruct_result1656 is not None + unwrapped1657 = deconstruct_result1656 self.write("(transaction_output_name") self.indent_sexp() self.newline() - self.pretty_name(unwrapped1571) + self.pretty_name(unwrapped1657) 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): - flat1581 = self._try_flat(msg, self.pretty_export_csv_source) - if flat1581 is not None: - assert flat1581 is not None - self.write(flat1581) -======= - def pretty_export_csv_path(self, msg: str): - flat1652 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1652 is not None: - assert flat1652 is not None - self.write(flat1652) - return None - else: - fields1651 = msg - self.write("(path") - self.indent_sexp() - self.newline() - self.write(self.format_string_value(fields1651)) - self.dedent() - self.write(")") - - def pretty_export_csv_source(self, msg: transactions_pb2.ExportCSVSource): - flat1659 = self._try_flat(msg, self.pretty_export_csv_source) - if flat1659 is not None: - assert flat1659 is not None - self.write(flat1659) ->>>>>>> origin/main + flat1667 = self._try_flat(msg, self.pretty_export_csv_source) + if flat1667 is not None: + assert flat1667 is not None + self.write(flat1667) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("gnf_columns"): -<<<<<<< HEAD - _t1752 = _dollar_dollar.gnf_columns.columns - else: - _t1752 = None - deconstruct_result1577 = _t1752 - if deconstruct_result1577 is not None: - assert deconstruct_result1577 is not None - unwrapped1578 = deconstruct_result1577 - self.write("(gnf_columns") - self.indent_sexp() - if not len(unwrapped1578) == 0: - self.newline() - for i1580, elem1579 in enumerate(unwrapped1578): - if (i1580 > 0): - self.newline() - self.pretty_export_csv_column(elem1579) -======= - _t1829 = _dollar_dollar.gnf_columns.columns + _t1842 = _dollar_dollar.gnf_columns.columns else: - _t1829 = None - deconstruct_result1655 = _t1829 - if deconstruct_result1655 is not None: - assert deconstruct_result1655 is not None - unwrapped1656 = deconstruct_result1655 + _t1842 = None + deconstruct_result1663 = _t1842 + if deconstruct_result1663 is not None: + assert deconstruct_result1663 is not None + unwrapped1664 = deconstruct_result1663 self.write("(gnf_columns") self.indent_sexp() - if not len(unwrapped1656) == 0: + if not len(unwrapped1664) == 0: self.newline() - for i1658, elem1657 in enumerate(unwrapped1656): - if (i1658 > 0): + for i1666, elem1665 in enumerate(unwrapped1664): + if (i1666 > 0): self.newline() - self.pretty_export_csv_column(elem1657) ->>>>>>> origin/main + self.pretty_export_csv_column(elem1665) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("table_def"): -<<<<<<< HEAD - _t1753 = _dollar_dollar.table_def - else: - _t1753 = None - deconstruct_result1575 = _t1753 - if deconstruct_result1575 is not None: - assert deconstruct_result1575 is not None - unwrapped1576 = deconstruct_result1575 - self.write("(table_def") - self.indent_sexp() - self.newline() - self.pretty_relation_id(unwrapped1576) -======= - _t1830 = _dollar_dollar.table_def + _t1843 = _dollar_dollar.table_def else: - _t1830 = None - deconstruct_result1653 = _t1830 - if deconstruct_result1653 is not None: - assert deconstruct_result1653 is not None - unwrapped1654 = deconstruct_result1653 + _t1843 = None + deconstruct_result1661 = _t1843 + if deconstruct_result1661 is not None: + assert deconstruct_result1661 is not None + unwrapped1662 = deconstruct_result1661 self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped1654) ->>>>>>> origin/main + self.pretty_relation_id(unwrapped1662) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_source") def pretty_export_csv_column(self, msg: transactions_pb2.ExportCSVColumn): -<<<<<<< HEAD - flat1586 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1586 is not None: - assert flat1586 is not None - self.write(flat1586) + flat1672 = self._try_flat(msg, self.pretty_export_csv_column) + if flat1672 is not None: + assert flat1672 is not None + self.write(flat1672) return None else: _dollar_dollar = msg - fields1582 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - assert fields1582 is not None - unwrapped_fields1583 = fields1582 + fields1668 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + assert fields1668 is not None + unwrapped_fields1669 = fields1668 self.write("(column") self.indent_sexp() self.newline() - field1584 = unwrapped_fields1583[0] - self.write(self.format_string_value(field1584)) + field1670 = unwrapped_fields1669[0] + self.write(self.format_string_value(field1670)) self.newline() - field1585 = unwrapped_fields1583[1] - self.pretty_relation_id(field1585) + field1671 = unwrapped_fields1669[1] + self.pretty_relation_id(field1671) self.dedent() self.write(")") def pretty_export_csv_path(self, msg: str): - flat1588 = self._try_flat(msg, self.pretty_export_csv_path) - if flat1588 is not None: - assert flat1588 is not None - self.write(flat1588) + flat1674 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1674 is not None: + assert flat1674 is not None + self.write(flat1674) return None else: - fields1587 = msg + fields1673 = msg self.write("(path") self.indent_sexp() self.newline() - self.write(self.format_string_value(fields1587)) -======= - flat1664 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1664 is not None: - assert flat1664 is not None - self.write(flat1664) - return None - else: - _dollar_dollar = msg - fields1660 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - assert fields1660 is not None - unwrapped_fields1661 = fields1660 - self.write("(column") - self.indent_sexp() - self.newline() - field1662 = unwrapped_fields1661[0] - self.write(self.format_string_value(field1662)) - self.newline() - field1663 = unwrapped_fields1661[1] - self.pretty_relation_id(field1663) ->>>>>>> origin/main + self.write(self.format_string_value(fields1673)) self.dedent() self.write(")") def pretty_export_csv_columns_list(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): -<<<<<<< HEAD - flat1592 = self._try_flat(msg, self.pretty_export_csv_columns_list) - if flat1592 is not None: - assert flat1592 is not None - self.write(flat1592) - return None - else: - fields1589 = msg - self.write("(columns") - self.indent_sexp() - if not len(fields1589) == 0: - self.newline() - for i1591, elem1590 in enumerate(fields1589): - if (i1591 > 0): - self.newline() - self.pretty_export_csv_column(elem1590) -======= - flat1668 = self._try_flat(msg, self.pretty_export_csv_columns_list) - if flat1668 is not None: - assert flat1668 is not None - self.write(flat1668) + flat1678 = self._try_flat(msg, self.pretty_export_csv_columns_list) + if flat1678 is not None: + assert flat1678 is not None + self.write(flat1678) return None else: - fields1665 = msg + fields1675 = msg self.write("(columns") self.indent_sexp() - if not len(fields1665) == 0: + if not len(fields1675) == 0: self.newline() - for i1667, elem1666 in enumerate(fields1665): - if (i1667 > 0): + for i1677, elem1676 in enumerate(fields1675): + if (i1677 > 0): self.newline() - self.pretty_export_csv_column(elem1666) ->>>>>>> origin/main + self.pretty_export_csv_column(elem1676) self.dedent() self.write(")") def pretty_export_iceberg_config(self, msg: transactions_pb2.ExportIcebergConfig): -<<<<<<< HEAD - flat1601 = self._try_flat(msg, self.pretty_export_iceberg_config) - if flat1601 is not None: - assert flat1601 is not None - self.write(flat1601) - return None - else: - _dollar_dollar = msg - _t1754 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1593 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1754,) - assert fields1593 is not None - unwrapped_fields1594 = fields1593 - self.write("(export_iceberg_config") - self.indent_sexp() - self.newline() - field1595 = unwrapped_fields1594[0] - self.pretty_iceberg_locator(field1595) - self.newline() - field1596 = unwrapped_fields1594[1] - self.pretty_iceberg_catalog_config(field1596) - self.newline() - field1597 = unwrapped_fields1594[2] - self.pretty_export_iceberg_table_def(field1597) - self.newline() - field1598 = unwrapped_fields1594[3] - self.pretty_iceberg_table_properties(field1598) - field1599 = unwrapped_fields1594[4] - if field1599 is not None: - self.newline() - assert field1599 is not None - opt_val1600 = field1599 - self.pretty_config_dict(opt_val1600) -======= - flat1677 = self._try_flat(msg, self.pretty_export_iceberg_config) - if flat1677 is not None: - assert flat1677 is not None - self.write(flat1677) + flat1687 = self._try_flat(msg, self.pretty_export_iceberg_config) + if flat1687 is not None: + assert flat1687 is not None + self.write(flat1687) return None else: _dollar_dollar = msg - _t1831 = self.deconstruct_export_iceberg_config_optional(_dollar_dollar) - fields1669 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sorted(_dollar_dollar.table_properties.items()), _t1831,) - assert fields1669 is not None - unwrapped_fields1670 = fields1669 + _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 self.write("(export_iceberg_config") self.indent_sexp() self.newline() - field1671 = unwrapped_fields1670[0] - self.pretty_iceberg_locator(field1671) + field1681 = unwrapped_fields1680[0] + self.pretty_iceberg_locator(field1681) self.newline() - field1672 = unwrapped_fields1670[1] - self.pretty_iceberg_catalog_config(field1672) + field1682 = unwrapped_fields1680[1] + self.pretty_iceberg_catalog_config(field1682) self.newline() - field1673 = unwrapped_fields1670[2] - self.pretty_export_iceberg_table_def(field1673) + field1683 = unwrapped_fields1680[2] + self.pretty_export_iceberg_table_def(field1683) self.newline() - field1674 = unwrapped_fields1670[3] - self.pretty_iceberg_table_properties(field1674) - field1675 = unwrapped_fields1670[4] - if field1675 is not None: + field1684 = unwrapped_fields1680[3] + self.pretty_iceberg_table_properties(field1684) + field1685 = unwrapped_fields1680[4] + if field1685 is not None: self.newline() - assert field1675 is not None - opt_val1676 = field1675 - self.pretty_config_dict(opt_val1676) ->>>>>>> origin/main + assert field1685 is not None + opt_val1686 = field1685 + self.pretty_config_dict(opt_val1686) self.dedent() self.write(")") def pretty_export_iceberg_table_def(self, msg: logic_pb2.RelationId): -<<<<<<< HEAD - flat1603 = self._try_flat(msg, self.pretty_export_iceberg_table_def) - if flat1603 is not None: - assert flat1603 is not None - self.write(flat1603) - return None - else: - fields1602 = msg - self.write("(table_def") - self.indent_sexp() - self.newline() - self.pretty_relation_id(fields1602) -======= - flat1679 = self._try_flat(msg, self.pretty_export_iceberg_table_def) - if flat1679 is not None: - assert flat1679 is not None - self.write(flat1679) + flat1689 = self._try_flat(msg, self.pretty_export_iceberg_table_def) + if flat1689 is not None: + assert flat1689 is not None + self.write(flat1689) return None else: - fields1678 = msg + fields1688 = msg self.write("(table_def") self.indent_sexp() self.newline() - self.pretty_relation_id(fields1678) ->>>>>>> origin/main + self.pretty_relation_id(fields1688) self.dedent() self.write(")") def pretty_iceberg_table_properties(self, msg: Sequence[tuple[str, str]]): -<<<<<<< HEAD - flat1607 = self._try_flat(msg, self.pretty_iceberg_table_properties) - if flat1607 is not None: - assert flat1607 is not None - self.write(flat1607) - return None - else: - fields1604 = msg - self.write("(table_properties") - self.indent_sexp() - if not len(fields1604) == 0: - self.newline() - for i1606, elem1605 in enumerate(fields1604): - if (i1606 > 0): - self.newline() - self.pretty_iceberg_property_entry(elem1605) -======= - flat1683 = self._try_flat(msg, self.pretty_iceberg_table_properties) - if flat1683 is not None: - assert flat1683 is not None - self.write(flat1683) + flat1693 = self._try_flat(msg, self.pretty_iceberg_table_properties) + if flat1693 is not None: + assert flat1693 is not None + self.write(flat1693) return None else: - fields1680 = msg + fields1690 = msg self.write("(table_properties") self.indent_sexp() - if not len(fields1680) == 0: + if not len(fields1690) == 0: self.newline() - for i1682, elem1681 in enumerate(fields1680): - if (i1682 > 0): + for i1692, elem1691 in enumerate(fields1690): + if (i1692 > 0): self.newline() - self.pretty_iceberg_property_entry(elem1681) ->>>>>>> origin/main + self.pretty_iceberg_property_entry(elem1691) self.dedent() self.write(")") @@ -8650,13 +4636,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") -<<<<<<< HEAD - _t1806 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1806) -======= - _t1885 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1885) ->>>>>>> origin/main + _t1898 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) + self.pprint_dispatch(_t1898) self.write(" ") self.write(self.format_string_value(msg.orig_names[_idx])) self.write(")")