diff --git a/meta/src/meta/grammar.y b/meta/src/meta/grammar.y index c0230b51..e59d3a38 100644 --- a/meta/src/meta/grammar.y +++ b/meta/src/meta/grammar.y @@ -123,6 +123,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 @@ -1384,10 +1385,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 ")" @@ -1397,6 +1398,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 ")" @@ -1719,13 +1730,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/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 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; 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 636d9b96..dc0ac259 100644 --- a/sdks/go/src/parser.go +++ b/sdks/go/src/parser.go @@ -655,206 +655,206 @@ func toPascalCase(s string) string { // --- Helper functions --- func (p *Parser) _extract_value_int32(value *pb.Value, default_ int64) int32 { - var _t2200 interface{} + var _t2212 interface{} if (value != nil && hasProtoField(value, "int32_value")) { return value.GetInt32Value() } - _ = _t2200 + _ = _t2212 return int32(default_) } func (p *Parser) _extract_value_int64(value *pb.Value, default_ int64) int64 { - var _t2201 interface{} + var _t2213 interface{} if (value != nil && hasProtoField(value, "int_value")) { return value.GetIntValue() } - _ = _t2201 + _ = _t2213 return default_ } func (p *Parser) _extract_value_string(value *pb.Value, default_ string) string { - var _t2202 interface{} + var _t2214 interface{} if (value != nil && hasProtoField(value, "string_value")) { return value.GetStringValue() } - _ = _t2202 + _ = _t2214 return default_ } func (p *Parser) _extract_value_boolean(value *pb.Value, default_ bool) bool { - var _t2203 interface{} + var _t2215 interface{} if (value != nil && hasProtoField(value, "boolean_value")) { return value.GetBooleanValue() } - _ = _t2203 + _ = _t2215 return default_ } func (p *Parser) _extract_value_string_list(value *pb.Value, default_ []string) []string { - var _t2204 interface{} + var _t2216 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []string{value.GetStringValue()} } - _ = _t2204 + _ = _t2216 return default_ } func (p *Parser) _try_extract_value_int64(value *pb.Value) *int64 { - var _t2205 interface{} + var _t2217 interface{} if (value != nil && hasProtoField(value, "int_value")) { return ptr(value.GetIntValue()) } - _ = _t2205 + _ = _t2217 return nil } func (p *Parser) _try_extract_value_float64(value *pb.Value) *float64 { - var _t2206 interface{} + var _t2218 interface{} if (value != nil && hasProtoField(value, "float_value")) { return ptr(value.GetFloatValue()) } - _ = _t2206 + _ = _t2218 return nil } func (p *Parser) _try_extract_value_bytes(value *pb.Value) []byte { - var _t2207 interface{} + var _t2219 interface{} if (value != nil && hasProtoField(value, "string_value")) { return []byte(value.GetStringValue()) } - _ = _t2207 + _ = _t2219 return nil } func (p *Parser) _try_extract_value_uint128(value *pb.Value) *pb.UInt128Value { - var _t2208 interface{} + var _t2220 interface{} if (value != nil && hasProtoField(value, "uint128_value")) { return value.GetUint128Value() } - _ = _t2208 + _ = _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) - _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 + _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) - _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 + _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 { @@ -876,4441 +876,4485 @@ func (p *Parser) construct_configure(config_dict [][]interface{}) *pb.Configure } } } - _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 + _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) - _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 + _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 { + _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) - _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 + _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 { - 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 + _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(")") - _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 + _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 + _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("{") - 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 + 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_values718 + return config_key_values721 } func (p *Parser) parse_config_key_value() []interface{} { p.consumeLiteral(":") - 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 + 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(")") - _t1473 := &pb.Sync{Fragments: fragment_ids754} - result756 := _t1473 - p.recordSpan(int(span_start755), "Sync") - return result756 + _t1479 := &pb.Sync{Fragments: fragment_ids757} + result759 := _t1479 + p.recordSpan(int(span_start758), "Sync") + return result759 } func (p *Parser) parse_fragment_id() *pb.FragmentId { - span_start758 := int64(p.spanStart()) + span_start761 := int64(p.spanStart()) p.consumeLiteral(":") - symbol757 := p.consumeTerminal("SYMBOL").Value.str - result759 := &pb.FragmentId{Id: []byte(symbol757)} - p.recordSpan(int(span_start758), "FragmentId") - return result759 + 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 { - 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 + _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") - 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 + 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 writes767 + return writes770 } func (p *Parser) parse_write() *pb.Write { - span_start773 := int64(p.spanStart()) - var _t1482 int64 + span_start776 := int64(p.spanStart()) + var _t1488 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1483 int64 + var _t1489 int64 if p.matchLookaheadLiteral("undefine", 1) { - _t1483 = 1 + _t1489 = 1 } else { - var _t1484 int64 + var _t1490 int64 if p.matchLookaheadLiteral("snapshot", 1) { - _t1484 = 3 + _t1490 = 3 } else { - var _t1485 int64 + var _t1491 int64 if p.matchLookaheadLiteral("define", 1) { - _t1485 = 0 + _t1491 = 0 } else { - var _t1486 int64 + var _t1492 int64 if p.matchLookaheadLiteral("context", 1) { - _t1486 = 2 + _t1492 = 2 } else { - _t1486 = -1 + _t1492 = -1 } - _t1485 = _t1486 + _t1491 = _t1492 } - _t1484 = _t1485 + _t1490 = _t1491 } - _t1483 = _t1484 + _t1489 = _t1490 } - _t1482 = _t1483 + _t1488 = _t1489 } 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 + _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 _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 _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 _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 _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 _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 _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)}) } - _t1493 = _t1496 + _t1499 = _t1502 } - _t1490 = _t1493 + _t1496 = _t1499 } - _t1487 = _t1490 + _t1493 = _t1496 } - result774 := _t1487 - p.recordSpan(int(span_start773), "Write") - return result774 + result777 := _t1493 + p.recordSpan(int(span_start776), "Write") + return result777 } func (p *Parser) parse_define() *pb.Define { - span_start776 := int64(p.spanStart()) + span_start779 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("define") - _t1499 := p.parse_fragment() - fragment775 := _t1499 + _t1505 := p.parse_fragment() + fragment778 := _t1505 p.consumeLiteral(")") - _t1500 := &pb.Define{Fragment: fragment775} - result777 := _t1500 - p.recordSpan(int(span_start776), "Define") - return result777 + _t1506 := &pb.Define{Fragment: fragment778} + result780 := _t1506 + p.recordSpan(int(span_start779), "Define") + return result780 } func (p *Parser) parse_fragment() *pb.Fragment { - span_start783 := int64(p.spanStart()) + span_start786 := 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 + _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(")") - result784 := p.constructFragment(new_fragment_id778, declarations782) - p.recordSpan(int(span_start783), "Fragment") - return result784 + result787 := p.constructFragment(new_fragment_id781, declarations785) + p.recordSpan(int(span_start786), "Fragment") + return result787 } 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 + 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_start793 := int64(p.spanStart()) - var _t1504 int64 + span_start796 := int64(p.spanStart()) + var _t1510 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1505 int64 + var _t1511 int64 if p.matchLookaheadLiteral("iceberg_data", 1) { - _t1505 = 3 + _t1511 = 3 } else { - var _t1506 int64 + var _t1512 int64 if p.matchLookaheadLiteral("functional_dependency", 1) { - _t1506 = 2 + _t1512 = 2 } else { - var _t1507 int64 + var _t1513 int64 if p.matchLookaheadLiteral("edb", 1) { - _t1507 = 3 + _t1513 = 3 } else { - var _t1508 int64 + var _t1514 int64 if p.matchLookaheadLiteral("def", 1) { - _t1508 = 0 + _t1514 = 0 } else { - var _t1509 int64 + var _t1515 int64 if p.matchLookaheadLiteral("csv_data", 1) { - _t1509 = 3 + _t1515 = 3 } else { - var _t1510 int64 + var _t1516 int64 if p.matchLookaheadLiteral("betree_relation", 1) { - _t1510 = 3 + _t1516 = 3 } else { - var _t1511 int64 + var _t1517 int64 if p.matchLookaheadLiteral("algorithm", 1) { - _t1511 = 1 + _t1517 = 1 } else { - _t1511 = -1 + _t1517 = -1 } - _t1510 = _t1511 + _t1516 = _t1517 } - _t1509 = _t1510 + _t1515 = _t1516 } - _t1508 = _t1509 + _t1514 = _t1515 } - _t1507 = _t1508 + _t1513 = _t1514 } - _t1506 = _t1507 + _t1512 = _t1513 } - _t1505 = _t1506 + _t1511 = _t1512 } - _t1504 = _t1505 + _t1510 = _t1511 } 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 + _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 _t1515 *pb.Declaration - if prediction788 == 2 { - _t1516 := p.parse_constraint() - constraint791 := _t1516 - _t1517 := &pb.Declaration{} - _t1517.DeclarationType = &pb.Declaration_Constraint{Constraint: constraint791} - _t1515 = _t1517 + 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 _t1518 *pb.Declaration - if prediction788 == 1 { - _t1519 := p.parse_algorithm() - algorithm790 := _t1519 - _t1520 := &pb.Declaration{} - _t1520.DeclarationType = &pb.Declaration_Algorithm{Algorithm: algorithm790} - _t1518 = _t1520 + 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 _t1521 *pb.Declaration - if prediction788 == 0 { - _t1522 := p.parse_def() - def789 := _t1522 - _t1523 := &pb.Declaration{} - _t1523.DeclarationType = &pb.Declaration_Def{Def: def789} - _t1521 = _t1523 + 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 declaration", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1518 = _t1521 + _t1524 = _t1527 } - _t1515 = _t1518 + _t1521 = _t1524 } - _t1512 = _t1515 + _t1518 = _t1521 } - result794 := _t1512 - p.recordSpan(int(span_start793), "Declaration") - return result794 + result797 := _t1518 + p.recordSpan(int(span_start796), "Declaration") + return result797 } func (p *Parser) parse_def() *pb.Def { - span_start798 := int64(p.spanStart()) + span_start801 := 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 + _t1530 := p.parse_relation_id() + relation_id798 := _t1530 + _t1531 := p.parse_abstraction() + abstraction799 := _t1531 + var _t1532 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1527 := p.parse_attrs() - _t1526 = _t1527 + _t1533 := p.parse_attrs() + _t1532 = _t1533 } - attrs797 := _t1526 + attrs800 := _t1532 p.consumeLiteral(")") - _t1528 := attrs797 - if attrs797 == nil { - _t1528 = []*pb.Attribute{} + _t1534 := attrs800 + if attrs800 == nil { + _t1534 = []*pb.Attribute{} } - _t1529 := &pb.Def{Name: relation_id795, Body: abstraction796, Attrs: _t1528} - result799 := _t1529 - p.recordSpan(int(span_start798), "Def") - return result799 + _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 + _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("[") - 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 + 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) { - _t1539 := p.parse_value_bindings() - _t1538 = _t1539 + _t1545 := p.parse_value_bindings() + _t1544 = _t1545 } - value_bindings813 := _t1538 + value_bindings816 := _t1544 p.consumeLiteral("]") - _t1540 := value_bindings813 - if value_bindings813 == nil { - _t1540 = []*pb.Binding{} + _t1546 := value_bindings816 + if value_bindings816 == nil { + _t1546 = []*pb.Binding{} } - return []interface{}{bindings812, _t1540} + return []interface{}{bindings815, _t1546} } func (p *Parser) parse_binding() *pb.Binding { - span_start816 := int64(p.spanStart()) - symbol814 := p.consumeTerminal("SYMBOL").Value.str + span_start819 := int64(p.spanStart()) + symbol817 := 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 + _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_start833 := int64(p.spanStart()) - var _t1544 int64 + span_start836 := int64(p.spanStart()) + var _t1550 int64 if p.matchLookaheadLiteral("UNKNOWN", 0) { - _t1544 = 0 + _t1550 = 0 } else { - var _t1545 int64 + var _t1551 int64 if p.matchLookaheadLiteral("UINT32", 0) { - _t1545 = 13 + _t1551 = 13 } else { - var _t1546 int64 + var _t1552 int64 if p.matchLookaheadLiteral("UINT128", 0) { - _t1546 = 4 + _t1552 = 4 } else { - var _t1547 int64 + var _t1553 int64 if p.matchLookaheadLiteral("STRING", 0) { - _t1547 = 1 + _t1553 = 1 } else { - var _t1548 int64 + var _t1554 int64 if p.matchLookaheadLiteral("MISSING", 0) { - _t1548 = 8 + _t1554 = 8 } else { - var _t1549 int64 + var _t1555 int64 if p.matchLookaheadLiteral("INT32", 0) { - _t1549 = 11 + _t1555 = 11 } else { - var _t1550 int64 + var _t1556 int64 if p.matchLookaheadLiteral("INT128", 0) { - _t1550 = 5 + _t1556 = 5 } else { - var _t1551 int64 + var _t1557 int64 if p.matchLookaheadLiteral("INT", 0) { - _t1551 = 2 + _t1557 = 2 } else { - var _t1552 int64 + var _t1558 int64 if p.matchLookaheadLiteral("FLOAT32", 0) { - _t1552 = 12 + _t1558 = 12 } else { - var _t1553 int64 + var _t1559 int64 if p.matchLookaheadLiteral("FLOAT", 0) { - _t1553 = 3 + _t1559 = 3 } else { - var _t1554 int64 + var _t1560 int64 if p.matchLookaheadLiteral("DATETIME", 0) { - _t1554 = 7 + _t1560 = 7 } else { - var _t1555 int64 + var _t1561 int64 if p.matchLookaheadLiteral("DATE", 0) { - _t1555 = 6 + _t1561 = 6 } else { - var _t1556 int64 + var _t1562 int64 if p.matchLookaheadLiteral("BOOLEAN", 0) { - _t1556 = 10 + _t1562 = 10 } else { - var _t1557 int64 + var _t1563 int64 if p.matchLookaheadLiteral("(", 0) { - _t1557 = 9 + _t1563 = 9 } else { - _t1557 = -1 + _t1563 = -1 } - _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 - } - 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 + _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 + 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)}) } - _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 } - _t1561 = _t1564 + _t1567 = _t1570 } - _t1558 = _t1561 + _t1564 = _t1567 } - result834 := _t1558 - p.recordSpan(int(span_start833), "Type") - return result834 + result837 := _t1564 + p.recordSpan(int(span_start836), "Type") + return result837 } func (p *Parser) parse_unspecified_type() *pb.UnspecifiedType { - span_start835 := int64(p.spanStart()) + span_start838 := int64(p.spanStart()) p.consumeLiteral("UNKNOWN") - _t1600 := &pb.UnspecifiedType{} - result836 := _t1600 - p.recordSpan(int(span_start835), "UnspecifiedType") - return result836 + _t1606 := &pb.UnspecifiedType{} + result839 := _t1606 + p.recordSpan(int(span_start838), "UnspecifiedType") + return result839 } func (p *Parser) parse_string_type() *pb.StringType { - span_start837 := int64(p.spanStart()) + span_start840 := int64(p.spanStart()) p.consumeLiteral("STRING") - _t1601 := &pb.StringType{} - result838 := _t1601 - p.recordSpan(int(span_start837), "StringType") - return result838 + _t1607 := &pb.StringType{} + result841 := _t1607 + p.recordSpan(int(span_start840), "StringType") + return result841 } func (p *Parser) parse_int_type() *pb.IntType { - span_start839 := int64(p.spanStart()) + span_start842 := int64(p.spanStart()) p.consumeLiteral("INT") - _t1602 := &pb.IntType{} - result840 := _t1602 - p.recordSpan(int(span_start839), "IntType") - return result840 + _t1608 := &pb.IntType{} + result843 := _t1608 + p.recordSpan(int(span_start842), "IntType") + return result843 } func (p *Parser) parse_float_type() *pb.FloatType { - span_start841 := int64(p.spanStart()) + span_start844 := int64(p.spanStart()) p.consumeLiteral("FLOAT") - _t1603 := &pb.FloatType{} - result842 := _t1603 - p.recordSpan(int(span_start841), "FloatType") - return result842 + _t1609 := &pb.FloatType{} + result845 := _t1609 + p.recordSpan(int(span_start844), "FloatType") + return result845 } func (p *Parser) parse_uint128_type() *pb.UInt128Type { - span_start843 := int64(p.spanStart()) + span_start846 := int64(p.spanStart()) p.consumeLiteral("UINT128") - _t1604 := &pb.UInt128Type{} - result844 := _t1604 - p.recordSpan(int(span_start843), "UInt128Type") - return result844 + _t1610 := &pb.UInt128Type{} + result847 := _t1610 + p.recordSpan(int(span_start846), "UInt128Type") + return result847 } func (p *Parser) parse_int128_type() *pb.Int128Type { - span_start845 := int64(p.spanStart()) + span_start848 := int64(p.spanStart()) p.consumeLiteral("INT128") - _t1605 := &pb.Int128Type{} - result846 := _t1605 - p.recordSpan(int(span_start845), "Int128Type") - return result846 + _t1611 := &pb.Int128Type{} + result849 := _t1611 + p.recordSpan(int(span_start848), "Int128Type") + return result849 } func (p *Parser) parse_date_type() *pb.DateType { - span_start847 := int64(p.spanStart()) + span_start850 := int64(p.spanStart()) p.consumeLiteral("DATE") - _t1606 := &pb.DateType{} - result848 := _t1606 - p.recordSpan(int(span_start847), "DateType") - return result848 + _t1612 := &pb.DateType{} + result851 := _t1612 + p.recordSpan(int(span_start850), "DateType") + return result851 } func (p *Parser) parse_datetime_type() *pb.DateTimeType { - span_start849 := int64(p.spanStart()) + span_start852 := int64(p.spanStart()) p.consumeLiteral("DATETIME") - _t1607 := &pb.DateTimeType{} - result850 := _t1607 - p.recordSpan(int(span_start849), "DateTimeType") - return result850 + _t1613 := &pb.DateTimeType{} + result853 := _t1613 + p.recordSpan(int(span_start852), "DateTimeType") + return result853 } func (p *Parser) parse_missing_type() *pb.MissingType { - span_start851 := int64(p.spanStart()) + span_start854 := int64(p.spanStart()) p.consumeLiteral("MISSING") - _t1608 := &pb.MissingType{} - result852 := _t1608 - p.recordSpan(int(span_start851), "MissingType") - return result852 + _t1614 := &pb.MissingType{} + result855 := _t1614 + p.recordSpan(int(span_start854), "MissingType") + return result855 } func (p *Parser) parse_decimal_type() *pb.DecimalType { - span_start855 := int64(p.spanStart()) + span_start858 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("DECIMAL") - int853 := p.consumeTerminal("INT").Value.i64 - int_3854 := p.consumeTerminal("INT").Value.i64 + int856 := p.consumeTerminal("INT").Value.i64 + int_3857 := p.consumeTerminal("INT").Value.i64 p.consumeLiteral(")") - _t1609 := &pb.DecimalType{Precision: int32(int853), Scale: int32(int_3854)} - result856 := _t1609 - p.recordSpan(int(span_start855), "DecimalType") - return result856 + _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_start857 := int64(p.spanStart()) + span_start860 := int64(p.spanStart()) p.consumeLiteral("BOOLEAN") - _t1610 := &pb.BooleanType{} - result858 := _t1610 - p.recordSpan(int(span_start857), "BooleanType") - return result858 + _t1616 := &pb.BooleanType{} + result861 := _t1616 + p.recordSpan(int(span_start860), "BooleanType") + return result861 } func (p *Parser) parse_int32_type() *pb.Int32Type { - span_start859 := int64(p.spanStart()) + span_start862 := int64(p.spanStart()) p.consumeLiteral("INT32") - _t1611 := &pb.Int32Type{} - result860 := _t1611 - p.recordSpan(int(span_start859), "Int32Type") - return result860 + _t1617 := &pb.Int32Type{} + result863 := _t1617 + p.recordSpan(int(span_start862), "Int32Type") + return result863 } func (p *Parser) parse_float32_type() *pb.Float32Type { - span_start861 := int64(p.spanStart()) + span_start864 := int64(p.spanStart()) p.consumeLiteral("FLOAT32") - _t1612 := &pb.Float32Type{} - result862 := _t1612 - p.recordSpan(int(span_start861), "Float32Type") - return result862 + _t1618 := &pb.Float32Type{} + result865 := _t1618 + p.recordSpan(int(span_start864), "Float32Type") + return result865 } func (p *Parser) parse_uint32_type() *pb.UInt32Type { - span_start863 := int64(p.spanStart()) + span_start866 := int64(p.spanStart()) p.consumeLiteral("UINT32") - _t1613 := &pb.UInt32Type{} - result864 := _t1613 - p.recordSpan(int(span_start863), "UInt32Type") - return result864 + _t1619 := &pb.UInt32Type{} + result867 := _t1619 + p.recordSpan(int(span_start866), "UInt32Type") + return result867 } func (p *Parser) parse_value_bindings() []*pb.Binding { p.consumeLiteral("|") - 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) + 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) } - bindings868 := xs865 - return bindings868 + bindings871 := xs868 + return bindings871 } func (p *Parser) parse_formula() *pb.Formula { - span_start883 := int64(p.spanStart()) - var _t1615 int64 + span_start886 := int64(p.spanStart()) + var _t1621 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1616 int64 + var _t1622 int64 if p.matchLookaheadLiteral("true", 1) { - _t1616 = 0 + _t1622 = 0 } else { - var _t1617 int64 + var _t1623 int64 if p.matchLookaheadLiteral("relatom", 1) { - _t1617 = 11 + _t1623 = 11 } else { - var _t1618 int64 + var _t1624 int64 if p.matchLookaheadLiteral("reduce", 1) { - _t1618 = 3 + _t1624 = 3 } else { - var _t1619 int64 + var _t1625 int64 if p.matchLookaheadLiteral("primitive", 1) { - _t1619 = 10 + _t1625 = 10 } else { - var _t1620 int64 + var _t1626 int64 if p.matchLookaheadLiteral("pragma", 1) { - _t1620 = 9 + _t1626 = 9 } else { - var _t1621 int64 + var _t1627 int64 if p.matchLookaheadLiteral("or", 1) { - _t1621 = 5 + _t1627 = 5 } else { - var _t1622 int64 + var _t1628 int64 if p.matchLookaheadLiteral("not", 1) { - _t1622 = 6 + _t1628 = 6 } else { - var _t1623 int64 + var _t1629 int64 if p.matchLookaheadLiteral("ffi", 1) { - _t1623 = 7 + _t1629 = 7 } else { - var _t1624 int64 + var _t1630 int64 if p.matchLookaheadLiteral("false", 1) { - _t1624 = 1 + _t1630 = 1 } else { - var _t1625 int64 + var _t1631 int64 if p.matchLookaheadLiteral("exists", 1) { - _t1625 = 2 + _t1631 = 2 } else { - var _t1626 int64 + var _t1632 int64 if p.matchLookaheadLiteral("cast", 1) { - _t1626 = 12 + _t1632 = 12 } else { - var _t1627 int64 + var _t1633 int64 if p.matchLookaheadLiteral("atom", 1) { - _t1627 = 8 + _t1633 = 8 } else { - var _t1628 int64 + var _t1634 int64 if p.matchLookaheadLiteral("and", 1) { - _t1628 = 4 + _t1634 = 4 } else { - var _t1629 int64 + var _t1635 int64 if p.matchLookaheadLiteral(">=", 1) { - _t1629 = 10 + _t1635 = 10 } else { - var _t1630 int64 + var _t1636 int64 if p.matchLookaheadLiteral(">", 1) { - _t1630 = 10 + _t1636 = 10 } else { - var _t1631 int64 + var _t1637 int64 if p.matchLookaheadLiteral("=", 1) { - _t1631 = 10 + _t1637 = 10 } else { - var _t1632 int64 + var _t1638 int64 if p.matchLookaheadLiteral("<=", 1) { - _t1632 = 10 + _t1638 = 10 } else { - var _t1633 int64 + var _t1639 int64 if p.matchLookaheadLiteral("<", 1) { - _t1633 = 10 + _t1639 = 10 } else { - var _t1634 int64 + var _t1640 int64 if p.matchLookaheadLiteral("/", 1) { - _t1634 = 10 + _t1640 = 10 } else { - var _t1635 int64 + var _t1641 int64 if p.matchLookaheadLiteral("-", 1) { - _t1635 = 10 + _t1641 = 10 } else { - var _t1636 int64 + var _t1642 int64 if p.matchLookaheadLiteral("+", 1) { - _t1636 = 10 + _t1642 = 10 } else { - var _t1637 int64 + var _t1643 int64 if p.matchLookaheadLiteral("*", 1) { - _t1637 = 10 + _t1643 = 10 } else { - _t1637 = -1 + _t1643 = -1 } - _t1636 = _t1637 + _t1642 = _t1643 } - _t1635 = _t1636 + _t1641 = _t1642 } - _t1634 = _t1635 + _t1640 = _t1641 } - _t1633 = _t1634 + _t1639 = _t1640 } - _t1632 = _t1633 + _t1638 = _t1639 } - _t1631 = _t1632 + _t1637 = _t1638 } - _t1630 = _t1631 + _t1636 = _t1637 } - _t1629 = _t1630 + _t1635 = _t1636 } - _t1628 = _t1629 + _t1634 = _t1635 } - _t1627 = _t1628 + _t1633 = _t1634 } - _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 } 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 + _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 _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 + 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 _t1644 *pb.Formula - if prediction869 == 10 { - _t1645 := p.parse_primitive() - primitive880 := _t1645 - _t1646 := &pb.Formula{} - _t1646.FormulaType = &pb.Formula_Primitive{Primitive: primitive880} - _t1644 = _t1646 + 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 _t1647 *pb.Formula - if prediction869 == 9 { - _t1648 := p.parse_pragma() - pragma879 := _t1648 - _t1649 := &pb.Formula{} - _t1649.FormulaType = &pb.Formula_Pragma{Pragma: pragma879} - _t1647 = _t1649 + 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 _t1650 *pb.Formula - if prediction869 == 8 { - _t1651 := p.parse_atom() - atom878 := _t1651 - _t1652 := &pb.Formula{} - _t1652.FormulaType = &pb.Formula_Atom{Atom: atom878} - _t1650 = _t1652 + 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 _t1653 *pb.Formula - if prediction869 == 7 { - _t1654 := p.parse_ffi() - ffi877 := _t1654 - _t1655 := &pb.Formula{} - _t1655.FormulaType = &pb.Formula_Ffi{Ffi: ffi877} - _t1653 = _t1655 + 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 _t1656 *pb.Formula - if prediction869 == 6 { - _t1657 := p.parse_not() - not876 := _t1657 - _t1658 := &pb.Formula{} - _t1658.FormulaType = &pb.Formula_Not{Not: not876} - _t1656 = _t1658 + 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 _t1659 *pb.Formula - if prediction869 == 5 { - _t1660 := p.parse_disjunction() - disjunction875 := _t1660 - _t1661 := &pb.Formula{} - _t1661.FormulaType = &pb.Formula_Disjunction{Disjunction: disjunction875} - _t1659 = _t1661 + 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 _t1662 *pb.Formula - if prediction869 == 4 { - _t1663 := p.parse_conjunction() - conjunction874 := _t1663 - _t1664 := &pb.Formula{} - _t1664.FormulaType = &pb.Formula_Conjunction{Conjunction: conjunction874} - _t1662 = _t1664 + 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 _t1665 *pb.Formula - if prediction869 == 3 { - _t1666 := p.parse_reduce() - reduce873 := _t1666 - _t1667 := &pb.Formula{} - _t1667.FormulaType = &pb.Formula_Reduce{Reduce: reduce873} - _t1665 = _t1667 + 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 _t1668 *pb.Formula - if prediction869 == 2 { - _t1669 := p.parse_exists() - exists872 := _t1669 - _t1670 := &pb.Formula{} - _t1670.FormulaType = &pb.Formula_Exists{Exists: exists872} - _t1668 = _t1670 + 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 _t1671 *pb.Formula - if prediction869 == 1 { - _t1672 := p.parse_false() - false871 := _t1672 - _t1673 := &pb.Formula{} - _t1673.FormulaType = &pb.Formula_Disjunction{Disjunction: false871} - _t1671 = _t1673 + 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 _t1674 *pb.Formula - if prediction869 == 0 { - _t1675 := p.parse_true() - true870 := _t1675 - _t1676 := &pb.Formula{} - _t1676.FormulaType = &pb.Formula_Conjunction{Conjunction: true870} - _t1674 = _t1676 + 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 { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in formula", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1671 = _t1674 + _t1677 = _t1680 } - _t1668 = _t1671 + _t1674 = _t1677 } - _t1665 = _t1668 + _t1671 = _t1674 } - _t1662 = _t1665 + _t1668 = _t1671 } - _t1659 = _t1662 + _t1665 = _t1668 } - _t1656 = _t1659 + _t1662 = _t1665 } - _t1653 = _t1656 + _t1659 = _t1662 } - _t1650 = _t1653 + _t1656 = _t1659 } - _t1647 = _t1650 + _t1653 = _t1656 } - _t1644 = _t1647 + _t1650 = _t1653 } - _t1641 = _t1644 + _t1647 = _t1650 } - _t1638 = _t1641 + _t1644 = _t1647 } - result884 := _t1638 - p.recordSpan(int(span_start883), "Formula") - return result884 + result887 := _t1644 + p.recordSpan(int(span_start886), "Formula") + return result887 } func (p *Parser) parse_true() *pb.Conjunction { - span_start885 := int64(p.spanStart()) + span_start888 := 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 + _t1683 := &pb.Conjunction{Args: []*pb.Formula{}} + result889 := _t1683 + p.recordSpan(int(span_start888), "Conjunction") + return result889 } func (p *Parser) parse_false() *pb.Disjunction { - span_start887 := int64(p.spanStart()) + span_start890 := 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 + _t1684 := &pb.Disjunction{Args: []*pb.Formula{}} + result891 := _t1684 + p.recordSpan(int(span_start890), "Disjunction") + return result891 } func (p *Parser) parse_exists() *pb.Exists { - span_start891 := int64(p.spanStart()) + span_start894 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("exists") - _t1679 := p.parse_bindings() - bindings889 := _t1679 - _t1680 := p.parse_formula() - formula890 := _t1680 + _t1685 := p.parse_bindings() + bindings892 := _t1685 + _t1686 := p.parse_formula() + formula893 := _t1686 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 + _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_reduce() *pb.Reduce { - span_start896 := int64(p.spanStart()) + span_start899 := 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 + _t1689 := p.parse_abstraction() + abstraction896 := _t1689 + _t1690 := p.parse_abstraction() + abstraction_3897 := _t1690 + _t1691 := p.parse_terms() + terms898 := _t1691 p.consumeLiteral(")") - _t1686 := &pb.Reduce{Op: abstraction893, Body: abstraction_3894, Terms: terms895} - result897 := _t1686 - p.recordSpan(int(span_start896), "Reduce") - return result897 + _t1692 := &pb.Reduce{Op: abstraction896, Body: abstraction_3897, Terms: terms898} + result900 := _t1692 + p.recordSpan(int(span_start899), "Reduce") + return result900 } func (p *Parser) parse_terms() []*pb.Term { p.consumeLiteral("(") p.consumeLiteral("terms") - 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 + 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 terms901 + 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 + result909 := _t1708 + p.recordSpan(int(span_start908), "Term") + return result909 } 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") - return result909 + 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 { - 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 + _t1752 = _t1754 } - _t1744 = _t1746 + _t1750 = _t1752 } - _t1742 = _t1744 + _t1748 = _t1750 } - _t1740 = _t1742 + _t1746 = _t1748 } - _t1738 = _t1740 + _t1744 = _t1746 } - _t1736 = _t1738 + _t1742 = _t1744 } - _t1734 = _t1736 + _t1740 = _t1742 } - _t1732 = _t1734 + _t1738 = _t1740 } - _t1730 = _t1732 + _t1736 = _t1738 } - _t1727 = _t1730 + _t1733 = _t1736 } - _t1724 = _t1727 + _t1730 = _t1733 } - result924 := _t1724 - p.recordSpan(int(span_start923), "Value") - return result924 + result927 := _t1730 + p.recordSpan(int(span_start926), "Value") + return result927 } func (p *Parser) parse_date() *pb.DateValue { - span_start928 := int64(p.spanStart()) + span_start931 := 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 + 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(")") - _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 + _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_datetime() *pb.DateTimeValue { - span_start937 := int64(p.spanStart()) + span_start940 := 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 + 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) { - _t1755 = ptr(p.consumeTerminal("INT").Value.i64) + _t1761 = ptr(p.consumeTerminal("INT").Value.i64) } - formatted_int_8936 := _t1755 + formatted_int_8939 := _t1761 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 + _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_conjunction() *pb.Conjunction { - span_start943 := int64(p.spanStart()) + span_start946 := 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 + 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(")") - _t1758 := &pb.Conjunction{Args: formulas942} - result944 := _t1758 - p.recordSpan(int(span_start943), "Conjunction") - return result944 + _t1764 := &pb.Conjunction{Args: formulas945} + result947 := _t1764 + p.recordSpan(int(span_start946), "Conjunction") + return result947 } func (p *Parser) parse_disjunction() *pb.Disjunction { - span_start949 := int64(p.spanStart()) + span_start952 := 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 + 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(")") - _t1760 := &pb.Disjunction{Args: formulas948} - result950 := _t1760 - p.recordSpan(int(span_start949), "Disjunction") - return result950 + _t1766 := &pb.Disjunction{Args: formulas951} + result953 := _t1766 + p.recordSpan(int(span_start952), "Disjunction") + return result953 } func (p *Parser) parse_not() *pb.Not { - span_start952 := int64(p.spanStart()) + span_start955 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("not") - _t1761 := p.parse_formula() - formula951 := _t1761 + _t1767 := p.parse_formula() + formula954 := _t1767 p.consumeLiteral(")") - _t1762 := &pb.Not{Arg: formula951} - result953 := _t1762 - p.recordSpan(int(span_start952), "Not") - return result953 + _t1768 := &pb.Not{Arg: formula954} + result956 := _t1768 + p.recordSpan(int(span_start955), "Not") + return result956 } func (p *Parser) parse_ffi() *pb.FFI { - span_start957 := int64(p.spanStart()) + span_start960 := 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 + _t1769 := p.parse_name() + name957 := _t1769 + _t1770 := p.parse_ffi_args() + ffi_args958 := _t1770 + _t1771 := p.parse_terms() + terms959 := _t1771 p.consumeLiteral(")") - _t1766 := &pb.FFI{Name: name954, Args: ffi_args955, Terms: terms956} - result958 := _t1766 - p.recordSpan(int(span_start957), "FFI") - return result958 + _t1772 := &pb.FFI{Name: name957, Args: ffi_args958, Terms: terms959} + result961 := _t1772 + p.recordSpan(int(span_start960), "FFI") + return result961 } func (p *Parser) parse_name() string { p.consumeLiteral(":") - symbol959 := p.consumeTerminal("SYMBOL").Value.str - return symbol959 + symbol962 := p.consumeTerminal("SYMBOL").Value.str + return symbol962 } func (p *Parser) parse_ffi_args() []*pb.Abstraction { p.consumeLiteral("(") p.consumeLiteral("args") - 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 + xs963 := []*pb.Abstraction{} + cond964 := p.matchLookaheadLiteral("(", 0) + for cond964 { + _t1773 := p.parse_abstraction() + item965 := _t1773 + xs963 = append(xs963, item965) + cond964 = p.matchLookaheadLiteral("(", 0) + } + abstractions966 := xs963 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 + _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(")") - _t1773 := &pb.Pragma{Name: name971, Terms: terms975} - result977 := _t1773 - p.recordSpan(int(span_start976), "Pragma") - return result977 + _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 + result1042 := _t1881 + p.recordSpan(int(span_start1041), "RelTerm") + return result1042 } func (p *Parser) parse_specialized_value() *pb.Value { - span_start1041 := int64(p.spanStart()) + span_start1044 := int64(p.spanStart()) p.consumeLiteral("#") - _t1881 := p.parse_raw_value() - raw_value1040 := _t1881 - result1042 := raw_value1040 - p.recordSpan(int(span_start1041), "Value") - return result1042 + _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 { - span_start1048 := int64(p.spanStart()) + span_start1051 := 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 + _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") - 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 + xs1057 := []*pb.Attribute{} + cond1058 := p.matchLookaheadLiteral("(", 0) + for cond1058 { + _t1894 := p.parse_attribute() + item1059 := _t1894 + xs1057 = append(xs1057, item1059) + cond1058 = p.matchLookaheadLiteral("(", 0) + } + attributes1060 := xs1057 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 + 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) { - _t1895 := p.parse_attrs() - _t1894 = _t1895 + _t1901 := p.parse_attrs() + _t1900 = _t1901 } - attrs1070 := _t1894 + attrs1073 := _t1900 p.consumeLiteral(")") - _t1896 := attrs1070 - if attrs1070 == nil { - _t1896 = []*pb.Attribute{} + _t1902 := attrs1073 + if attrs1073 == nil { + _t1902 = []*pb.Attribute{} } - _t1897 := &pb.Algorithm{Global: relation_ids1068, Body: script1069, Attrs: _t1896} - result1072 := _t1897 - p.recordSpan(int(span_start1071), "Algorithm") - return result1072 + _t1903 := &pb.Algorithm{Global: relation_ids1071, Body: script1072, Attrs: _t1902} + result1075 := _t1903 + p.recordSpan(int(span_start1074), "Algorithm") + return result1075 } func (p *Parser) parse_script() *pb.Script { - span_start1077 := int64(p.spanStart()) + span_start1080 := 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 + 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(")") - _t1899 := &pb.Script{Constructs: constructs1076} - result1078 := _t1899 - p.recordSpan(int(span_start1077), "Script") - return result1078 + _t1905 := &pb.Script{Constructs: constructs1079} + result1081 := _t1905 + p.recordSpan(int(span_start1080), "Script") + return result1081 } func (p *Parser) parse_construct() *pb.Construct { - span_start1082 := int64(p.spanStart()) - var _t1900 int64 + span_start1085 := int64(p.spanStart()) + var _t1906 int64 if p.matchLookaheadLiteral("(", 0) { - var _t1901 int64 + var _t1907 int64 if p.matchLookaheadLiteral("upsert", 1) { - _t1901 = 1 + _t1907 = 1 } else { - var _t1902 int64 + var _t1908 int64 if p.matchLookaheadLiteral("monus", 1) { - _t1902 = 1 + _t1908 = 1 } else { - var _t1903 int64 + var _t1909 int64 if p.matchLookaheadLiteral("monoid", 1) { - _t1903 = 1 + _t1909 = 1 } else { - var _t1904 int64 + var _t1910 int64 if p.matchLookaheadLiteral("loop", 1) { - _t1904 = 0 + _t1910 = 0 } else { - var _t1905 int64 + var _t1911 int64 if p.matchLookaheadLiteral("break", 1) { - _t1905 = 1 + _t1911 = 1 } else { - var _t1906 int64 + var _t1912 int64 if p.matchLookaheadLiteral("assign", 1) { - _t1906 = 1 + _t1912 = 1 } else { - _t1906 = -1 + _t1912 = -1 } - _t1905 = _t1906 + _t1911 = _t1912 } - _t1904 = _t1905 + _t1910 = _t1911 } - _t1903 = _t1904 + _t1909 = _t1910 } - _t1902 = _t1903 + _t1908 = _t1909 } - _t1901 = _t1902 + _t1907 = _t1908 } - _t1900 = _t1901 + _t1906 = _t1907 } 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 + _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 _t1910 *pb.Construct - if prediction1079 == 0 { - _t1911 := p.parse_loop() - loop1080 := _t1911 - _t1912 := &pb.Construct{} - _t1912.ConstructType = &pb.Construct_Loop{Loop: loop1080} - _t1910 = _t1912 + 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 { panic(ParseError{msg: fmt.Sprintf("%s: %s=`%v`", "Unexpected token in construct", p.lookahead(0).Type, p.lookahead(0).Value)}) } - _t1907 = _t1910 + _t1913 = _t1916 } - result1083 := _t1907 - p.recordSpan(int(span_start1082), "Construct") - return result1083 + result1086 := _t1913 + p.recordSpan(int(span_start1085), "Construct") + return result1086 } func (p *Parser) parse_loop() *pb.Loop { - span_start1087 := int64(p.spanStart()) + span_start1090 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("loop") - _t1913 := p.parse_init() - init1084 := _t1913 - _t1914 := p.parse_script() - script1085 := _t1914 - var _t1915 []*pb.Attribute + _t1919 := p.parse_init() + init1087 := _t1919 + _t1920 := p.parse_script() + script1088 := _t1920 + var _t1921 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1916 := p.parse_attrs() - _t1915 = _t1916 + _t1922 := p.parse_attrs() + _t1921 = _t1922 } - attrs1086 := _t1915 + attrs1089 := _t1921 p.consumeLiteral(")") - _t1917 := attrs1086 - if attrs1086 == nil { - _t1917 = []*pb.Attribute{} + _t1923 := attrs1089 + if attrs1089 == nil { + _t1923 = []*pb.Attribute{} } - _t1918 := &pb.Loop{Init: init1084, Body: script1085, Attrs: _t1917} - result1088 := _t1918 - p.recordSpan(int(span_start1087), "Loop") - return result1088 + _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") - 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 + 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 + _t1947 := p.parse_relation_id() + relation_id1104 := _t1947 + _t1948 := p.parse_abstraction() + abstraction1105 := _t1948 + var _t1949 []*pb.Attribute if p.matchLookaheadLiteral("(", 0) { - _t1944 := p.parse_attrs() - _t1943 = _t1944 + _t1950 := p.parse_attrs() + _t1949 = _t1950 } - attrs1103 := _t1943 + attrs1106 := _t1949 p.consumeLiteral(")") - _t1945 := attrs1103 - if attrs1103 == nil { - _t1945 = []*pb.Attribute{} + _t1951 := attrs1106 + if attrs1106 == nil { + _t1951 = []*pb.Attribute{} } - _t1946 := &pb.Assign{Name: relation_id1101, Body: abstraction1102, Attrs: _t1945} - result1105 := _t1946 - p.recordSpan(int(span_start1104), "Assign") - return result1105 + _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_start1109 := int64(p.spanStart()) + span_start1112 := 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 - var _t1949 []*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) { - _t1950 := p.parse_attrs() - _t1949 = _t1950 + _t1956 := p.parse_attrs() + _t1955 = _t1956 } - 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 + _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("(") - _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()) + span_start1134 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("or") p.consumeLiteral(")") - _t1986 := &pb.OrMonoid{} - result1132 := _t1986 - p.recordSpan(int(span_start1131), "OrMonoid") - return result1132 + _t1992 := &pb.OrMonoid{} + result1135 := _t1992 + p.recordSpan(int(span_start1134), "OrMonoid") + return result1135 } func (p *Parser) parse_min_monoid() *pb.MinMonoid { - span_start1134 := int64(p.spanStart()) + span_start1137 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("min") - _t1987 := p.parse_type() - type1133 := _t1987 + _t1993 := p.parse_type() + type1136 := _t1993 p.consumeLiteral(")") - _t1988 := &pb.MinMonoid{Type: type1133} - result1135 := _t1988 - p.recordSpan(int(span_start1134), "MinMonoid") - return result1135 + _t1994 := &pb.MinMonoid{Type: type1136} + result1138 := _t1994 + p.recordSpan(int(span_start1137), "MinMonoid") + return result1138 } func (p *Parser) parse_max_monoid() *pb.MaxMonoid { - span_start1137 := int64(p.spanStart()) + span_start1140 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("max") - _t1989 := p.parse_type() - type1136 := _t1989 + _t1995 := p.parse_type() + type1139 := _t1995 p.consumeLiteral(")") - _t1990 := &pb.MaxMonoid{Type: type1136} - result1138 := _t1990 - p.recordSpan(int(span_start1137), "MaxMonoid") - return result1138 + _t1996 := &pb.MaxMonoid{Type: type1139} + result1141 := _t1996 + p.recordSpan(int(span_start1140), "MaxMonoid") + return result1141 } func (p *Parser) parse_sum_monoid() *pb.SumMonoid { - span_start1140 := int64(p.spanStart()) + span_start1143 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("sum") - _t1991 := p.parse_type() - type1139 := _t1991 + _t1997 := p.parse_type() + type1142 := _t1997 p.consumeLiteral(")") - _t1992 := &pb.SumMonoid{Type: type1139} - result1141 := _t1992 - p.recordSpan(int(span_start1140), "SumMonoid") - return result1141 + _t1998 := &pb.SumMonoid{Type: type1142} + result1144 := _t1998 + p.recordSpan(int(span_start1143), "SumMonoid") + return result1144 } func (p *Parser) parse_monus_def() *pb.MonusDef { - 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 + _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(")") - _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 + _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") - 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 + return vars1160 } func (p *Parser) parse_functional_dependency_values() []*pb.Var { p.consumeLiteral("(") p.consumeLiteral("values") - 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 + xs1161 := []*pb.Var{} + cond1162 := p.matchLookaheadTerminal("SYMBOL", 0) + for cond1162 { + _t2013 := p.parse_var() + item1163 := _t2013 + xs1161 = append(xs1161, item1163) + cond1162 = p.matchLookaheadTerminal("SYMBOL", 0) + } + vars1164 := xs1161 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 + _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("[") - 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 + return strings1180 } func (p *Parser) parse_edb_types() []*pb.Type { p.consumeLiteral("[") - 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 + _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") - 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 + xs1194 := []*pb.Type{} + cond1195 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1195 { + _t2043 := p.parse_type() + item1196 := _t2043 + xs1194 = append(xs1194, item1196) + cond1195 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1197 := xs1194 p.consumeLiteral(")") - return types1194 + return types1197 } func (p *Parser) parse_betree_info_value_types() []*pb.Type { p.consumeLiteral("(") p.consumeLiteral("value_types") - 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 + xs1198 := []*pb.Type{} + cond1199 := (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + for cond1199 { + _t2044 := p.parse_type() + item1200 := _t2044 + xs1198 = append(xs1198, item1200) + cond1199 = (((((((((((((p.matchLookaheadLiteral("(", 0) || p.matchLookaheadLiteral("BOOLEAN", 0)) || p.matchLookaheadLiteral("DATE", 0)) || p.matchLookaheadLiteral("DATETIME", 0)) || p.matchLookaheadLiteral("FLOAT", 0)) || p.matchLookaheadLiteral("FLOAT32", 0)) || p.matchLookaheadLiteral("INT", 0)) || p.matchLookaheadLiteral("INT128", 0)) || p.matchLookaheadLiteral("INT32", 0)) || p.matchLookaheadLiteral("MISSING", 0)) || p.matchLookaheadLiteral("STRING", 0)) || p.matchLookaheadLiteral("UINT128", 0)) || p.matchLookaheadLiteral("UINT32", 0)) || p.matchLookaheadLiteral("UNKNOWN", 0)) + } + types1201 := xs1198 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 + _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") - 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 + return strings1216 } func (p *Parser) parse_csv_locator_inline_data() string { p.consumeLiteral("(") p.consumeLiteral("inline_data") - formatted_string1214 := p.consumeTerminal("STRING").Value.str + formatted_string1217 := 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 + _storage_integration1219 := _t2060 p.consumeLiteral(")") - _t2056 := p.construct_csv_config(config_dict1215, _storage_integration1216) - result1218 := _t2056 - p.recordSpan(int(span_start1217), "CSVConfig") - return result1218 + _t2062 := p.construct_csv_config(config_dict1218, _storage_integration1219) + result1221 := _t2062 + p.recordSpan(int(span_start1220), "CSVConfig") + return result1221 } func (p *Parser) parse__storage_integration() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("storage_integration") - _t2057 := p.parse_config_dict() - config_dict1219 := _t2057 + _t2063 := p.parse_config_dict() + config_dict1222 := _t2063 p.consumeLiteral(")") - return config_dict1219 + return config_dict1222 } func (p *Parser) parse_gnf_columns() []*pb.GNFColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - 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 + xs1223 := []*pb.GNFColumn{} + cond1224 := p.matchLookaheadLiteral("(", 0) + for cond1224 { + _t2064 := p.parse_gnf_column() + item1225 := _t2064 + xs1223 = append(xs1223, item1225) + cond1224 = p.matchLookaheadLiteral("(", 0) + } + gnf_columns1226 := xs1223 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 + return target_relations1276 } func (p *Parser) parse_csv_asof() string { p.consumeLiteral("(") p.consumeLiteral("asof") - 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 + _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") - string1288 := p.consumeTerminal("STRING").Value.str + string1291 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1288 + return string1291 } func (p *Parser) parse_iceberg_locator_namespace() []string { p.consumeLiteral("(") p.consumeLiteral("namespace") - 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 + return strings1295 } func (p *Parser) parse_iceberg_locator_warehouse() string { p.consumeLiteral("(") p.consumeLiteral("warehouse") - string1293 := p.consumeTerminal("STRING").Value.str + string1296 := 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 + _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") - string1300 := p.consumeTerminal("STRING").Value.str + string1303 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1300 + return string1303 } func (p *Parser) parse_iceberg_catalog_config_scope() string { p.consumeLiteral("(") p.consumeLiteral("scope") - string1301 := p.consumeTerminal("STRING").Value.str + string1304 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1301 + return string1304 } func (p *Parser) parse_iceberg_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("properties") - 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 + return iceberg_property_entrys1308 } func (p *Parser) parse_iceberg_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - string1306 := p.consumeTerminal("STRING").Value.str - string_31307 := p.consumeTerminal("STRING").Value.str + string1309 := p.consumeTerminal("STRING").Value.str + string_31310 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return []interface{}{string1306, string_31307} + return []interface{}{string1309, string_31310} } func (p *Parser) parse_iceberg_auth_properties() [][]interface{} { p.consumeLiteral("(") p.consumeLiteral("auth_properties") - 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 + return iceberg_masked_property_entrys1314 } func (p *Parser) parse_iceberg_masked_property_entry() []interface{} { p.consumeLiteral("(") p.consumeLiteral("prop") - 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} + return []interface{}{string1315, string_31316} } func (p *Parser) parse_iceberg_from_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("from_snapshot") - string1314 := p.consumeTerminal("STRING").Value.str + string1317 := p.consumeTerminal("STRING").Value.str p.consumeLiteral(")") - return string1314 + return string1317 } func (p *Parser) parse_iceberg_to_snapshot() string { p.consumeLiteral("(") p.consumeLiteral("to_snapshot") - 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 + 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") - 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 + result1350 := _t2135 + p.recordSpan(int(span_start1349), "Read") + return result1350 } func (p *Parser) parse_demand() *pb.Demand { - span_start1349 := int64(p.spanStart()) + span_start1352 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("demand") - _t2144 := p.parse_relation_id() - relation_id1348 := _t2144 + _t2150 := p.parse_relation_id() + relation_id1351 := _t2150 p.consumeLiteral(")") - _t2145 := &pb.Demand{RelationId: relation_id1348} - result1350 := _t2145 - p.recordSpan(int(span_start1349), "Demand") - return result1350 + _t2151 := &pb.Demand{RelationId: relation_id1351} + result1353 := _t2151 + p.recordSpan(int(span_start1352), "Demand") + return result1353 } func (p *Parser) parse_output() *pb.Output { - span_start1353 := int64(p.spanStart()) + span_start1356 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("output") - _t2146 := p.parse_name() - name1351 := _t2146 - _t2147 := p.parse_relation_id() - relation_id1352 := _t2147 + _t2152 := p.parse_name() + name1354 := _t2152 + _t2153 := p.parse_relation_id() + relation_id1355 := _t2153 p.consumeLiteral(")") - _t2148 := &pb.Output{Name: name1351, RelationId: relation_id1352} - result1354 := _t2148 - p.recordSpan(int(span_start1353), "Output") - return result1354 + _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_start1357 := int64(p.spanStart()) + span_start1360 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("what_if") - _t2149 := p.parse_name() - name1355 := _t2149 - _t2150 := p.parse_epoch() - epoch1356 := _t2150 + _t2155 := p.parse_name() + name1358 := _t2155 + _t2156 := p.parse_epoch() + epoch1359 := _t2156 p.consumeLiteral(")") - _t2151 := &pb.WhatIf{Branch: name1355, Epoch: epoch1356} - result1358 := _t2151 - p.recordSpan(int(span_start1357), "WhatIf") - return result1358 + _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_start1361 := int64(p.spanStart()) + span_start1364 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("abort") - var _t2152 *string + var _t2158 *string if (p.matchLookaheadLiteral(":", 0) && p.matchLookaheadTerminal("SYMBOL", 1)) { - _t2153 := p.parse_name() - _t2152 = ptr(_t2153) + _t2159 := p.parse_name() + _t2158 = ptr(_t2159) } - name1359 := _t2152 - _t2154 := p.parse_relation_id() - relation_id1360 := _t2154 + name1362 := _t2158 + _t2160 := p.parse_relation_id() + relation_id1363 := _t2160 p.consumeLiteral(")") - _t2155 := &pb.Abort{Name: deref(name1359, "abort"), RelationId: relation_id1360} - result1362 := _t2155 - p.recordSpan(int(span_start1361), "Abort") - return result1362 + _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_start1366 := int64(p.spanStart()) - var _t2156 int64 + span_start1369 := int64(p.spanStart()) + var _t2162 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2157 int64 + var _t2163 int64 if p.matchLookaheadLiteral("export_iceberg", 1) { - _t2157 = 1 + _t2163 = 1 } else { - var _t2158 int64 + var _t2164 int64 if p.matchLookaheadLiteral("export", 1) { - _t2158 = 0 + _t2164 = 0 } else { - _t2158 = -1 + _t2164 = -1 } - _t2157 = _t2158 + _t2163 = _t2164 } - _t2156 = _t2157 + _t2162 = _t2163 } else { - _t2156 = -1 + _t2162 = -1 } - prediction1363 := _t2156 - var _t2159 *pb.Export - if prediction1363 == 1 { + prediction1366 := _t2162 + var _t2165 *pb.Export + if prediction1366 == 1 { p.consumeLiteral("(") p.consumeLiteral("export_iceberg") - _t2160 := p.parse_export_iceberg_config() - export_iceberg_config1365 := _t2160 + _t2166 := p.parse_export_iceberg_config() + export_iceberg_config1368 := _t2166 p.consumeLiteral(")") - _t2161 := &pb.Export{} - _t2161.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1365} - _t2159 = _t2161 + _t2167 := &pb.Export{} + _t2167.ExportConfig = &pb.Export_IcebergConfig{IcebergConfig: export_iceberg_config1368} + _t2165 = _t2167 } else { - var _t2162 *pb.Export - if prediction1363 == 0 { + var _t2168 *pb.Export + if prediction1366 == 0 { p.consumeLiteral("(") p.consumeLiteral("export") - _t2163 := p.parse_export_csv_config() - export_csv_config1364 := _t2163 + _t2169 := p.parse_export_csv_config() + export_csv_config1367 := _t2169 p.consumeLiteral(")") - _t2164 := &pb.Export{} - _t2164.ExportConfig = &pb.Export_CsvConfig{CsvConfig: export_csv_config1364} - _t2162 = _t2164 + _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)}) } - _t2159 = _t2162 + _t2165 = _t2168 } - result1367 := _t2159 - p.recordSpan(int(span_start1366), "Export") - return result1367 + result1370 := _t2165 + p.recordSpan(int(span_start1369), "Export") + return result1370 } func (p *Parser) parse_export_csv_config() *pb.ExportCSVConfig { - span_start1375 := int64(p.spanStart()) - var _t2165 int64 + span_start1378 := int64(p.spanStart()) + var _t2171 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2166 int64 + var _t2172 int64 if p.matchLookaheadLiteral("export_csv_config_v2", 1) { - _t2166 = 0 + _t2172 = 0 } else { - var _t2167 int64 + var _t2173 int64 if p.matchLookaheadLiteral("export_csv_config", 1) { - _t2167 = 1 + _t2173 = 1 } else { - _t2167 = -1 + _t2173 = -1 } - _t2166 = _t2167 + _t2172 = _t2173 } - _t2165 = _t2166 + _t2171 = _t2172 } else { - _t2165 = -1 + _t2171 = -1 } - prediction1368 := _t2165 - var _t2168 *pb.ExportCSVConfig - if prediction1368 == 1 { + prediction1371 := _t2171 + var _t2174 *pb.ExportCSVConfig + if prediction1371 == 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 + _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(")") - _t2172 := p.construct_export_csv_config(export_csv_path1372, export_csv_columns_list1373, config_dict1374) - _t2168 = _t2172 + _t2178 := p.construct_export_csv_config(export_csv_path1375, export_csv_columns_list1376, config_dict1377) + _t2174 = _t2178 } else { - var _t2173 *pb.ExportCSVConfig - if prediction1368 == 0 { + var _t2179 *pb.ExportCSVConfig + if prediction1371 == 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 + _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(")") - _t2177 := p.construct_export_csv_config_with_source(export_csv_path1369, export_csv_source1370, csv_config1371) - _t2173 = _t2177 + _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)}) } - _t2168 = _t2173 + _t2174 = _t2179 } - result1376 := _t2168 - p.recordSpan(int(span_start1375), "ExportCSVConfig") - return result1376 + result1379 := _t2174 + p.recordSpan(int(span_start1378), "ExportCSVConfig") + return result1379 } -func (p *Parser) parse_export_csv_path() string { - p.consumeLiteral("(") - p.consumeLiteral("path") - string1377 := p.consumeTerminal("STRING").Value.str - p.consumeLiteral(")") - return string1377 +func (p *Parser) parse_export_csv_output_location() []interface{} { + var _t2184 int64 + if p.matchLookaheadLiteral("(", 0) { + var _t2185 int64 + if p.matchLookaheadLiteral("transaction_output_name", 1) { + _t2185 = 1 + } else { + var _t2186 int64 + if p.matchLookaheadLiteral("path", 1) { + _t2186 = 0 + } else { + _t2186 = -1 + } + _t2185 = _t2186 + } + _t2184 = _t2185 + } else { + _t2184 = -1 + } + prediction1380 := _t2184 + var _t2187 []interface{} + if prediction1380 == 1 { + p.consumeLiteral("(") + p.consumeLiteral("transaction_output_name") + _t2188 := p.parse_name() + name1382 := _t2188 + p.consumeLiteral(")") + _t2187 = []interface{}{"", name1382} + } else { + var _t2189 []interface{} + if prediction1380 == 0 { + p.consumeLiteral("(") + p.consumeLiteral("path") + string1381 := p.consumeTerminal("STRING").Value.str + p.consumeLiteral(")") + _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)}) + } + _t2187 = _t2189 + } + return _t2187 } func (p *Parser) parse_export_csv_source() *pb.ExportCSVSource { - span_start1384 := int64(p.spanStart()) - var _t2178 int64 + span_start1389 := int64(p.spanStart()) + var _t2190 int64 if p.matchLookaheadLiteral("(", 0) { - var _t2179 int64 + var _t2191 int64 if p.matchLookaheadLiteral("table_def", 1) { - _t2179 = 1 + _t2191 = 1 } else { - var _t2180 int64 + var _t2192 int64 if p.matchLookaheadLiteral("gnf_columns", 1) { - _t2180 = 0 + _t2192 = 0 } else { - _t2180 = -1 + _t2192 = -1 } - _t2179 = _t2180 + _t2191 = _t2192 } - _t2178 = _t2179 + _t2190 = _t2191 } else { - _t2178 = -1 + _t2190 = -1 } - prediction1378 := _t2178 - var _t2181 *pb.ExportCSVSource - if prediction1378 == 1 { + prediction1383 := _t2190 + var _t2193 *pb.ExportCSVSource + if prediction1383 == 1 { p.consumeLiteral("(") p.consumeLiteral("table_def") - _t2182 := p.parse_relation_id() - relation_id1383 := _t2182 + _t2194 := p.parse_relation_id() + relation_id1388 := _t2194 p.consumeLiteral(")") - _t2183 := &pb.ExportCSVSource{} - _t2183.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1383} - _t2181 = _t2183 + _t2195 := &pb.ExportCSVSource{} + _t2195.CsvSource = &pb.ExportCSVSource_TableDef{TableDef: relation_id1388} + _t2193 = _t2195 } else { - var _t2184 *pb.ExportCSVSource - if prediction1378 == 0 { + var _t2196 *pb.ExportCSVSource + if prediction1383 == 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) + 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_columns1382 := xs1379 + export_csv_columns1387 := xs1384 p.consumeLiteral(")") - _t2186 := &pb.ExportCSVColumns{Columns: export_csv_columns1382} - _t2187 := &pb.ExportCSVSource{} - _t2187.CsvSource = &pb.ExportCSVSource_GnfColumns{GnfColumns: _t2186} - _t2184 = _t2187 + _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)}) } - _t2181 = _t2184 + _t2193 = _t2196 } - result1385 := _t2181 - p.recordSpan(int(span_start1384), "ExportCSVSource") - return result1385 + result1390 := _t2193 + p.recordSpan(int(span_start1389), "ExportCSVSource") + return result1390 } func (p *Parser) parse_export_csv_column() *pb.ExportCSVColumn { - span_start1388 := int64(p.spanStart()) + span_start1393 := int64(p.spanStart()) p.consumeLiteral("(") p.consumeLiteral("column") - string1386 := p.consumeTerminal("STRING").Value.str - _t2188 := p.parse_relation_id() - relation_id1387 := _t2188 + string1391 := p.consumeTerminal("STRING").Value.str + _t2200 := p.parse_relation_id() + relation_id1392 := _t2200 + p.consumeLiteral(")") + _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") + 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 + return string1395 } func (p *Parser) parse_export_csv_columns_list() []*pb.ExportCSVColumn { p.consumeLiteral("(") p.consumeLiteral("columns") - 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 + xs1396 := []*pb.ExportCSVColumn{} + cond1397 := p.matchLookaheadLiteral("(", 0) + for cond1397 { + _t2202 := p.parse_export_csv_column() + item1398 := _t2202 + xs1396 = append(xs1396, item1398) + cond1397 = p.matchLookaheadLiteral("(", 0) + } + export_csv_columns1399 := xs1396 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 + 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") - 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 + return iceberg_property_entrys1413 } diff --git a/sdks/go/src/pretty.go b/sdks/go/src/pretty.go index e5be23a1..f9018ec0 100644 --- a/sdks/go/src/pretty.go +++ b/sdks/go/src/pretty.go @@ -343,206 +343,210 @@ func formatBool(b bool) string { // --- Helper functions --- 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 + _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 { - _t1840 := p._make_value_string("auto") - result = append(result, []interface{}{"ivm.maintenance_level", _t1840}) + _t1853 := p._make_value_string("auto") + result = append(result, []interface{}{"ivm.maintenance_level", _t1853}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_ALL { - _t1841 := p._make_value_string("all") - result = append(result, []interface{}{"ivm.maintenance_level", _t1841}) + _t1854 := p._make_value_string("all") + result = append(result, []interface{}{"ivm.maintenance_level", _t1854}) } else { if msg.GetIvmConfig().GetLevel() == pb.MaintenanceLevel_MAINTENANCE_LEVEL_OFF { - _t1842 := p._make_value_string("off") - result = append(result, []interface{}{"ivm.maintenance_level", _t1842}) + _t1855 := p._make_value_string("off") + result = append(result, []interface{}{"ivm.maintenance_level", _t1855}) } } } - _t1843 := p._make_value_int64(msg.GetSemanticsVersion()) - result = append(result, []interface{}{"semantics_version", _t1843}) + _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{}{} - _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}) + _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{} { - 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}) + _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{}{} - _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}) + _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 { - _t1867 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) - result = append(result, []interface{}{"betree_locator_inline_data", _t1867}) + _t1880 := p._make_value_string(string(msg.GetRelationLocator().GetInlineData())) + result = append(result, []interface{}{"betree_locator_inline_data", _t1880}) } } - _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}) + _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 { - _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}) + _t1889 := p._make_value_string(*msg.SyntaxEscapechar) + result = append(result, []interface{}{"syntax_escapechar", _t1889}) } return listSort(result) } @@ -552,51 +556,51 @@ func (p *PrettyPrinter) mask_secret_value(pair []interface{}) string { } func (p *PrettyPrinter) deconstruct_iceberg_catalog_config_scope_optional(msg *pb.IcebergCatalogConfig) *string { - var _t1877 interface{} + var _t1890 interface{} if *msg.Scope != "" { return ptr(*msg.Scope) } - _ = _t1877 + _ = _t1890 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_from_snapshot_optional(msg *pb.IcebergData) *string { - var _t1878 interface{} + var _t1891 interface{} if *msg.FromSnapshot != "" { return ptr(*msg.FromSnapshot) } - _ = _t1878 + _ = _t1891 return nil } func (p *PrettyPrinter) deconstruct_iceberg_data_to_snapshot_optional(msg *pb.IcebergData) *string { - var _t1879 interface{} + var _t1892 interface{} if *msg.ToSnapshot != "" { return ptr(*msg.ToSnapshot) } - _ = _t1879 + _ = _t1892 return nil } func (p *PrettyPrinter) deconstruct_export_iceberg_config_optional(msg *pb.ExportIcebergConfig) [][]interface{} { result := [][]interface{}{} if *msg.Prefix != "" { - _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 + _ = _t1896 return listSort(result) } @@ -607,11 +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) - var _t1884 interface{} + var _t1897 interface{} if name == nil { return p.relationIdToUint128(msg) } - _ = _t1884 + _ = _t1897 return nil } @@ -629,45 +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{} { - 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) + p.pretty_epoch(elem854) } } p.dedent() @@ -677,20 +681,20 @@ func (p *PrettyPrinter) pretty_transaction(msg *pb.Transaction) interface{} { } func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { - 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 + _t1696 := p.deconstruct_configure(_dollar_dollar) + fields857 := _t1696 + unwrapped_fields858 := fields857 p.write("(") p.write("configure") p.indentSexp() p.newline() - p.pretty_config_dict(unwrapped_fields853) + p.pretty_config_dict(unwrapped_fields858) p.dedent() p.write(")") } @@ -698,21 +702,21 @@ func (p *PrettyPrinter) pretty_configure(msg *pb.Configure) interface{} { } func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { - 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) + p.pretty_config_key_value(elem861) } } p.dedent() @@ -722,152 +726,152 @@ func (p *PrettyPrinter) pretty_config_dict(msg [][]interface{}) interface{} { } func (p *PrettyPrinter) pretty_config_key_value(msg []interface{}) interface{} { - 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) + field867 := unwrapped_fields865[1].(*pb.Value) + p.pretty_raw_value(field867) } return nil } func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { - 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 + fields869 := msg + _ = fields869 p.write("missing") } } @@ -886,26 +890,26 @@ func (p *PrettyPrinter) pretty_raw_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { - 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 + 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() - field892 := unwrapped_fields891[0].(int64) - p.write(fmt.Sprintf("%d", field892)) + field897 := unwrapped_fields896[0].(int64) + p.write(fmt.Sprintf("%d", field897)) 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)) + field899 := unwrapped_fields896[2].(int64) + p.write(fmt.Sprintf("%d", field899)) p.dedent() p.write(")") } @@ -913,40 +917,40 @@ func (p *PrettyPrinter) pretty_raw_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { - 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 + 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() - 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)) + opt_val910 := *field909 + p.write(fmt.Sprintf("%d", opt_val910)) } p.dedent() p.write(")") @@ -956,25 +960,25 @@ func (p *PrettyPrinter) pretty_raw_datetime(msg *pb.DateTimeValue) interface{} { func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { _dollar_dollar := msg - 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 + deconstruct_result912 := _t1710 + if deconstruct_result912 != nil { + unwrapped913 := deconstruct_result912 + _ = unwrapped913 p.write("false") } else { panic(ParseError{msg: "No matching rule for boolean_value"}) @@ -984,24 +988,24 @@ func (p *PrettyPrinter) pretty_boolean_value(msg bool) interface{} { } func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { - 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) + p.pretty_fragment_id(elem918) } } p.dedent() @@ -1011,51 +1015,51 @@ func (p *PrettyPrinter) pretty_sync(msg *pb.Sync) interface{} { } func (p *PrettyPrinter) pretty_fragment_id(msg *pb.FragmentId) interface{} { - 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) + p.write(unwrapped_fields922) } return nil } func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { - 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) + opt_val929 := field928 + p.pretty_epoch_reads(opt_val929) } p.dedent() p.write(")") @@ -1064,22 +1068,22 @@ func (p *PrettyPrinter) pretty_epoch(msg *pb.Epoch) interface{} { } func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { - 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) + p.pretty_write(elem932) } } p.dedent() @@ -1089,50 +1093,50 @@ func (p *PrettyPrinter) pretty_epoch_writes(msg []*pb.Write) interface{} { } func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { - flat938 := p.tryFlat(msg, func() { p.pretty_write(msg) }) - if flat938 != nil { - p.write(*flat938) + flat943 := p.tryFlat(msg, func() { p.pretty_write(msg) }) + if flat943 != nil { + p.write(*flat943) return nil } else { _dollar_dollar := msg - var _t1703 *pb.Define + var _t1713 *pb.Define if hasProtoField(_dollar_dollar, "define") { - _t1703 = _dollar_dollar.GetDefine() + _t1713 = _dollar_dollar.GetDefine() } - deconstruct_result936 := _t1703 - if deconstruct_result936 != nil { - unwrapped937 := deconstruct_result936 - p.pretty_define(unwrapped937) + deconstruct_result941 := _t1713 + if deconstruct_result941 != nil { + unwrapped942 := deconstruct_result941 + p.pretty_define(unwrapped942) } else { _dollar_dollar := msg - var _t1704 *pb.Undefine + var _t1714 *pb.Undefine if hasProtoField(_dollar_dollar, "undefine") { - _t1704 = _dollar_dollar.GetUndefine() + _t1714 = _dollar_dollar.GetUndefine() } - deconstruct_result934 := _t1704 - if deconstruct_result934 != nil { - unwrapped935 := deconstruct_result934 - p.pretty_undefine(unwrapped935) + deconstruct_result939 := _t1714 + if deconstruct_result939 != nil { + unwrapped940 := deconstruct_result939 + p.pretty_undefine(unwrapped940) } else { _dollar_dollar := msg - var _t1705 *pb.Context + var _t1715 *pb.Context if hasProtoField(_dollar_dollar, "context") { - _t1705 = _dollar_dollar.GetContext() + _t1715 = _dollar_dollar.GetContext() } - deconstruct_result932 := _t1705 - if deconstruct_result932 != nil { - unwrapped933 := deconstruct_result932 - p.pretty_context(unwrapped933) + deconstruct_result937 := _t1715 + if deconstruct_result937 != nil { + unwrapped938 := deconstruct_result937 + p.pretty_context(unwrapped938) } else { _dollar_dollar := msg - var _t1706 *pb.Snapshot + var _t1716 *pb.Snapshot if hasProtoField(_dollar_dollar, "snapshot") { - _t1706 = _dollar_dollar.GetSnapshot() + _t1716 = _dollar_dollar.GetSnapshot() } - deconstruct_result930 := _t1706 - if deconstruct_result930 != nil { - unwrapped931 := deconstruct_result930 - p.pretty_snapshot(unwrapped931) + deconstruct_result935 := _t1716 + if deconstruct_result935 != nil { + unwrapped936 := deconstruct_result935 + p.pretty_snapshot(unwrapped936) } else { panic(ParseError{msg: "No matching rule for write"}) } @@ -1144,19 +1148,19 @@ func (p *PrettyPrinter) pretty_write(msg *pb.Write) interface{} { } func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { - 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 + fields944 := _dollar_dollar.GetFragment() + unwrapped_fields945 := fields944 p.write("(") p.write("define") p.indentSexp() p.newline() - p.pretty_fragment(unwrapped_fields940) + p.pretty_fragment(unwrapped_fields945) p.dedent() p.write(")") } @@ -1164,29 +1168,29 @@ func (p *PrettyPrinter) pretty_define(msg *pb.Define) interface{} { } func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { - flat948 := p.tryFlat(msg, func() { p.pretty_fragment(msg) }) - if flat948 != nil { - p.write(*flat948) + 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) - fields942 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} - unwrapped_fields943 := fields942 + fields947 := []interface{}{_dollar_dollar.GetId(), _dollar_dollar.GetDeclarations()} + unwrapped_fields948 := fields947 p.write("(") p.write("fragment") p.indentSexp() p.newline() - 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) + p.pretty_declaration(elem951) } } p.dedent() @@ -1196,62 +1200,62 @@ func (p *PrettyPrinter) pretty_fragment(msg *pb.Fragment) interface{} { } func (p *PrettyPrinter) pretty_new_fragment_id(msg *pb.FragmentId) interface{} { - 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) + fields954 := msg + p.pretty_fragment_id(fields954) } return nil } func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { - 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) + deconstruct_result956 := _t1720 + if deconstruct_result956 != nil { + unwrapped957 := deconstruct_result956 + p.pretty_data(unwrapped957) } else { panic(ParseError{msg: "No matching rule for declaration"}) } @@ -1263,32 +1267,32 @@ func (p *PrettyPrinter) pretty_declaration(msg *pb.Declaration) interface{} { } func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { - 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 + fields965 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1721} + unwrapped_fields966 := fields965 p.write("(") p.write("def") p.indentSexp() p.newline() - field962 := unwrapped_fields961[0].(*pb.RelationId) - p.pretty_relation_id(field962) + field967 := unwrapped_fields966[0].(*pb.RelationId) + p.pretty_relation_id(field967) 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) + opt_val970 := field969 + p.pretty_attrs(opt_val970) } p.dedent() p.write(")") @@ -1297,29 +1301,29 @@ func (p *PrettyPrinter) pretty_def(msg *pb.Def) interface{} { } func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { - 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)) + _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"}) } @@ -1329,22 +1333,22 @@ func (p *PrettyPrinter) pretty_relation_id(msg *pb.RelationId) interface{} { } func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { - 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) + field980 := unwrapped_fields978[1].(*pb.Formula) + p.pretty_formula(field980) p.dedent() p.write(")") } @@ -1352,32 +1356,32 @@ func (p *PrettyPrinter) pretty_abstraction(msg *pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { - 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) + opt_val988 := field987 + p.pretty_value_bindings(opt_val988) } p.dedent() p.write("]") @@ -1386,168 +1390,168 @@ func (p *PrettyPrinter) pretty_bindings(msg []interface{}) interface{} { } func (p *PrettyPrinter) pretty_binding(msg *pb.Binding) interface{} { - 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) + field993 := unwrapped_fields991[1].(*pb.Type) + p.pretty_type(field993) } return nil } func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { - 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) + deconstruct_result995 := _t1740 + if deconstruct_result995 != nil { + unwrapped996 := deconstruct_result995 + p.pretty_uint32_type(unwrapped996) } else { panic(ParseError{msg: "No matching rule for type"}) } @@ -1569,86 +1573,86 @@ func (p *PrettyPrinter) pretty_type(msg *pb.Type) interface{} { } func (p *PrettyPrinter) pretty_unspecified_type(msg *pb.UnspecifiedType) interface{} { - fields1019 := msg - _ = fields1019 + fields1024 := msg + _ = fields1024 p.write("UNKNOWN") return nil } func (p *PrettyPrinter) pretty_string_type(msg *pb.StringType) interface{} { - fields1020 := msg - _ = fields1020 + fields1025 := msg + _ = fields1025 p.write("STRING") return nil } func (p *PrettyPrinter) pretty_int_type(msg *pb.IntType) interface{} { - fields1021 := msg - _ = fields1021 + fields1026 := msg + _ = fields1026 p.write("INT") return nil } func (p *PrettyPrinter) pretty_float_type(msg *pb.FloatType) interface{} { - fields1022 := msg - _ = fields1022 + fields1027 := msg + _ = fields1027 p.write("FLOAT") return nil } func (p *PrettyPrinter) pretty_uint128_type(msg *pb.UInt128Type) interface{} { - fields1023 := msg - _ = fields1023 + fields1028 := msg + _ = fields1028 p.write("UINT128") return nil } func (p *PrettyPrinter) pretty_int128_type(msg *pb.Int128Type) interface{} { - fields1024 := msg - _ = fields1024 + fields1029 := msg + _ = fields1029 p.write("INT128") return nil } func (p *PrettyPrinter) pretty_date_type(msg *pb.DateType) interface{} { - fields1025 := msg - _ = fields1025 + fields1030 := msg + _ = fields1030 p.write("DATE") return nil } func (p *PrettyPrinter) pretty_datetime_type(msg *pb.DateTimeType) interface{} { - fields1026 := msg - _ = fields1026 + fields1031 := msg + _ = fields1031 p.write("DATETIME") return nil } func (p *PrettyPrinter) pretty_missing_type(msg *pb.MissingType) interface{} { - fields1027 := msg - _ = fields1027 + fields1032 := msg + _ = fields1032 p.write("MISSING") return nil } func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { - 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 + fields1033 := []interface{}{int64(_dollar_dollar.GetPrecision()), int64(_dollar_dollar.GetScale())} + unwrapped_fields1034 := fields1033 p.write("(") p.write("DECIMAL") p.indentSexp() p.newline() - 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)) + field1036 := unwrapped_fields1034[1].(int64) + p.write(fmt.Sprintf("%d", field1036)) p.dedent() p.write(")") } @@ -1656,48 +1660,48 @@ func (p *PrettyPrinter) pretty_decimal_type(msg *pb.DecimalType) interface{} { } func (p *PrettyPrinter) pretty_boolean_type(msg *pb.BooleanType) interface{} { - fields1033 := msg - _ = fields1033 + fields1038 := msg + _ = fields1038 p.write("BOOLEAN") return nil } func (p *PrettyPrinter) pretty_int32_type(msg *pb.Int32Type) interface{} { - fields1034 := msg - _ = fields1034 + fields1039 := msg + _ = fields1039 p.write("INT32") return nil } func (p *PrettyPrinter) pretty_float32_type(msg *pb.Float32Type) interface{} { - fields1035 := msg - _ = fields1035 + fields1040 := msg + _ = fields1040 p.write("FLOAT32") return nil } func (p *PrettyPrinter) pretty_uint32_type(msg *pb.UInt32Type) interface{} { - fields1036 := msg - _ = fields1036 + fields1041 := msg + _ = fields1041 p.write("UINT32") return nil } func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { - 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) + p.pretty_binding(elem1043) } } } @@ -1705,140 +1709,140 @@ func (p *PrettyPrinter) pretty_value_bindings(msg []*pb.Binding) interface{} { } func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { - 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) + deconstruct_result1046 := _t1753 + if deconstruct_result1046 != nil { + unwrapped1047 := deconstruct_result1046 + p.pretty_cast(unwrapped1047) } else { panic(ParseError{msg: "No matching rule for formula"}) } @@ -1859,8 +1863,8 @@ func (p *PrettyPrinter) pretty_formula(msg *pb.Formula) interface{} { } func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { - fields1068 := msg - _ = fields1068 + fields1073 := msg + _ = fields1073 p.write("(") p.write("true") p.write(")") @@ -1868,8 +1872,8 @@ func (p *PrettyPrinter) pretty_true(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { - fields1069 := msg - _ = fields1069 + fields1074 := msg + _ = fields1074 p.write("(") p.write("false") p.write(")") @@ -1877,24 +1881,24 @@ func (p *PrettyPrinter) pretty_false(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { - 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 + _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() - 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) + field1078 := unwrapped_fields1076[1].(*pb.Formula) + p.pretty_formula(field1078) p.dedent() p.write(")") } @@ -1902,26 +1906,26 @@ func (p *PrettyPrinter) pretty_exists(msg *pb.Exists) interface{} { } func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { - flat1080 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) - if flat1080 != nil { - p.write(*flat1080) + flat1085 := p.tryFlat(msg, func() { p.pretty_reduce(msg) }) + if flat1085 != nil { + p.write(*flat1085) return nil } else { _dollar_dollar := msg - fields1075 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} - unwrapped_fields1076 := fields1075 + fields1080 := []interface{}{_dollar_dollar.GetOp(), _dollar_dollar.GetBody(), _dollar_dollar.GetTerms()} + unwrapped_fields1081 := fields1080 p.write("(") p.write("reduce") p.indentSexp() p.newline() - 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) + field1084 := unwrapped_fields1081[2].([]*pb.Term) + p.pretty_terms(field1084) p.dedent() p.write(")") } @@ -1929,22 +1933,22 @@ func (p *PrettyPrinter) pretty_reduce(msg *pb.Reduce) interface{} { } func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { - 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) + p.pretty_term(elem1087) } } p.dedent() @@ -1954,30 +1958,30 @@ func (p *PrettyPrinter) pretty_terms(msg []*pb.Term) interface{} { } func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { - flat1089 := p.tryFlat(msg, func() { p.pretty_term(msg) }) - if flat1089 != nil { - p.write(*flat1089) + flat1094 := p.tryFlat(msg, func() { p.pretty_term(msg) }) + if flat1094 != nil { + p.write(*flat1094) return nil } else { _dollar_dollar := msg - var _t1745 *pb.Var + var _t1755 *pb.Var if hasProtoField(_dollar_dollar, "var") { - _t1745 = _dollar_dollar.GetVar() + _t1755 = _dollar_dollar.GetVar() } - deconstruct_result1087 := _t1745 - if deconstruct_result1087 != nil { - unwrapped1088 := deconstruct_result1087 - p.pretty_var(unwrapped1088) + deconstruct_result1092 := _t1755 + if deconstruct_result1092 != nil { + unwrapped1093 := deconstruct_result1092 + p.pretty_var(unwrapped1093) } else { _dollar_dollar := msg - var _t1746 *pb.Value + var _t1756 *pb.Value if hasProtoField(_dollar_dollar, "constant") { - _t1746 = _dollar_dollar.GetConstant() + _t1756 = _dollar_dollar.GetConstant() } - deconstruct_result1085 := _t1746 - if deconstruct_result1085 != nil { - unwrapped1086 := deconstruct_result1085 - p.pretty_value(unwrapped1086) + deconstruct_result1090 := _t1756 + if deconstruct_result1090 != nil { + unwrapped1091 := deconstruct_result1090 + p.pretty_value(unwrapped1091) } else { panic(ParseError{msg: "No matching rule for term"}) } @@ -1987,147 +1991,147 @@ func (p *PrettyPrinter) pretty_term(msg *pb.Term) interface{} { } func (p *PrettyPrinter) pretty_var(msg *pb.Var) interface{} { - 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) + fields1095 := _dollar_dollar.GetName() + unwrapped_fields1096 := fields1095 + p.write(unwrapped_fields1096) } return nil } func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { - flat1118 := p.tryFlat(msg, func() { p.pretty_value(msg) }) - if flat1118 != nil { - p.write(*flat1118) + flat1123 := p.tryFlat(msg, func() { p.pretty_value(msg) }) + if flat1123 != nil { + p.write(*flat1123) return nil } else { _dollar_dollar := msg - var _t1747 *pb.DateValue + var _t1757 *pb.DateValue if hasProtoField(_dollar_dollar, "date_value") { - _t1747 = _dollar_dollar.GetDateValue() + _t1757 = _dollar_dollar.GetDateValue() } - deconstruct_result1116 := _t1747 - if deconstruct_result1116 != nil { - unwrapped1117 := deconstruct_result1116 - p.pretty_date(unwrapped1117) + deconstruct_result1121 := _t1757 + if deconstruct_result1121 != nil { + unwrapped1122 := deconstruct_result1121 + p.pretty_date(unwrapped1122) } else { _dollar_dollar := msg - var _t1748 *pb.DateTimeValue + var _t1758 *pb.DateTimeValue if hasProtoField(_dollar_dollar, "datetime_value") { - _t1748 = _dollar_dollar.GetDatetimeValue() + _t1758 = _dollar_dollar.GetDatetimeValue() } - deconstruct_result1114 := _t1748 - if deconstruct_result1114 != nil { - unwrapped1115 := deconstruct_result1114 - p.pretty_datetime(unwrapped1115) + deconstruct_result1119 := _t1758 + if deconstruct_result1119 != nil { + unwrapped1120 := deconstruct_result1119 + p.pretty_datetime(unwrapped1120) } else { _dollar_dollar := msg - var _t1749 *string + var _t1759 *string if hasProtoField(_dollar_dollar, "string_value") { - _t1749 = ptr(_dollar_dollar.GetStringValue()) + _t1759 = ptr(_dollar_dollar.GetStringValue()) } - deconstruct_result1112 := _t1749 - if deconstruct_result1112 != nil { - unwrapped1113 := *deconstruct_result1112 - p.write(p.formatStringValue(unwrapped1113)) + deconstruct_result1117 := _t1759 + if deconstruct_result1117 != nil { + unwrapped1118 := *deconstruct_result1117 + p.write(p.formatStringValue(unwrapped1118)) } else { _dollar_dollar := msg - var _t1750 *int32 + var _t1760 *int32 if hasProtoField(_dollar_dollar, "int32_value") { - _t1750 = ptr(_dollar_dollar.GetInt32Value()) + _t1760 = ptr(_dollar_dollar.GetInt32Value()) } - deconstruct_result1110 := _t1750 - if deconstruct_result1110 != nil { - unwrapped1111 := *deconstruct_result1110 - p.write(fmt.Sprintf("%di32", unwrapped1111)) + deconstruct_result1115 := _t1760 + if deconstruct_result1115 != nil { + unwrapped1116 := *deconstruct_result1115 + p.write(fmt.Sprintf("%di32", unwrapped1116)) } else { _dollar_dollar := msg - var _t1751 *int64 + var _t1761 *int64 if hasProtoField(_dollar_dollar, "int_value") { - _t1751 = ptr(_dollar_dollar.GetIntValue()) + _t1761 = ptr(_dollar_dollar.GetIntValue()) } - deconstruct_result1108 := _t1751 - if deconstruct_result1108 != nil { - unwrapped1109 := *deconstruct_result1108 - p.write(fmt.Sprintf("%d", unwrapped1109)) + deconstruct_result1113 := _t1761 + if deconstruct_result1113 != nil { + unwrapped1114 := *deconstruct_result1113 + p.write(fmt.Sprintf("%d", unwrapped1114)) } else { _dollar_dollar := msg - var _t1752 *float32 + var _t1762 *float32 if hasProtoField(_dollar_dollar, "float32_value") { - _t1752 = ptr(_dollar_dollar.GetFloat32Value()) + _t1762 = ptr(_dollar_dollar.GetFloat32Value()) } - deconstruct_result1106 := _t1752 - if deconstruct_result1106 != nil { - unwrapped1107 := *deconstruct_result1106 - p.write(formatFloat32(unwrapped1107)) + deconstruct_result1111 := _t1762 + if deconstruct_result1111 != nil { + unwrapped1112 := *deconstruct_result1111 + p.write(formatFloat32(unwrapped1112)) } else { _dollar_dollar := msg - var _t1753 *float64 + var _t1763 *float64 if hasProtoField(_dollar_dollar, "float_value") { - _t1753 = ptr(_dollar_dollar.GetFloatValue()) + _t1763 = ptr(_dollar_dollar.GetFloatValue()) } - deconstruct_result1104 := _t1753 - if deconstruct_result1104 != nil { - unwrapped1105 := *deconstruct_result1104 - p.write(formatFloat64(unwrapped1105)) + deconstruct_result1109 := _t1763 + if deconstruct_result1109 != nil { + unwrapped1110 := *deconstruct_result1109 + p.write(formatFloat64(unwrapped1110)) } else { _dollar_dollar := msg - var _t1754 *uint32 + var _t1764 *uint32 if hasProtoField(_dollar_dollar, "uint32_value") { - _t1754 = ptr(_dollar_dollar.GetUint32Value()) + _t1764 = ptr(_dollar_dollar.GetUint32Value()) } - deconstruct_result1102 := _t1754 - if deconstruct_result1102 != nil { - unwrapped1103 := *deconstruct_result1102 - p.write(fmt.Sprintf("%du32", unwrapped1103)) + deconstruct_result1107 := _t1764 + if deconstruct_result1107 != nil { + unwrapped1108 := *deconstruct_result1107 + p.write(fmt.Sprintf("%du32", unwrapped1108)) } else { _dollar_dollar := msg - var _t1755 *pb.UInt128Value + var _t1765 *pb.UInt128Value if hasProtoField(_dollar_dollar, "uint128_value") { - _t1755 = _dollar_dollar.GetUint128Value() + _t1765 = _dollar_dollar.GetUint128Value() } - deconstruct_result1100 := _t1755 - if deconstruct_result1100 != nil { - unwrapped1101 := deconstruct_result1100 - p.write(p.formatUint128(unwrapped1101)) + deconstruct_result1105 := _t1765 + if deconstruct_result1105 != nil { + unwrapped1106 := deconstruct_result1105 + p.write(p.formatUint128(unwrapped1106)) } else { _dollar_dollar := msg - var _t1756 *pb.Int128Value + var _t1766 *pb.Int128Value if hasProtoField(_dollar_dollar, "int128_value") { - _t1756 = _dollar_dollar.GetInt128Value() + _t1766 = _dollar_dollar.GetInt128Value() } - deconstruct_result1098 := _t1756 - if deconstruct_result1098 != nil { - unwrapped1099 := deconstruct_result1098 - p.write(p.formatInt128(unwrapped1099)) + deconstruct_result1103 := _t1766 + if deconstruct_result1103 != nil { + unwrapped1104 := deconstruct_result1103 + p.write(p.formatInt128(unwrapped1104)) } else { _dollar_dollar := msg - var _t1757 *pb.DecimalValue + var _t1767 *pb.DecimalValue if hasProtoField(_dollar_dollar, "decimal_value") { - _t1757 = _dollar_dollar.GetDecimalValue() + _t1767 = _dollar_dollar.GetDecimalValue() } - deconstruct_result1096 := _t1757 - if deconstruct_result1096 != nil { - unwrapped1097 := deconstruct_result1096 - p.write(p.formatDecimal(unwrapped1097)) + deconstruct_result1101 := _t1767 + if deconstruct_result1101 != nil { + unwrapped1102 := deconstruct_result1101 + p.write(p.formatDecimal(unwrapped1102)) } else { _dollar_dollar := msg - var _t1758 *bool + var _t1768 *bool if hasProtoField(_dollar_dollar, "boolean_value") { - _t1758 = ptr(_dollar_dollar.GetBooleanValue()) + _t1768 = ptr(_dollar_dollar.GetBooleanValue()) } - deconstruct_result1094 := _t1758 - if deconstruct_result1094 != nil { - unwrapped1095 := *deconstruct_result1094 - p.pretty_boolean_value(unwrapped1095) + deconstruct_result1099 := _t1768 + if deconstruct_result1099 != nil { + unwrapped1100 := *deconstruct_result1099 + p.pretty_boolean_value(unwrapped1100) } else { - fields1093 := msg - _ = fields1093 + fields1098 := msg + _ = fields1098 p.write("missing") } } @@ -2146,26 +2150,26 @@ func (p *PrettyPrinter) pretty_value(msg *pb.Value) interface{} { } func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { - 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 + 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() - field1121 := unwrapped_fields1120[0].(int64) - p.write(fmt.Sprintf("%d", field1121)) + field1126 := unwrapped_fields1125[0].(int64) + p.write(fmt.Sprintf("%d", field1126)) 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)) + field1128 := unwrapped_fields1125[2].(int64) + p.write(fmt.Sprintf("%d", field1128)) p.dedent() p.write(")") } @@ -2173,40 +2177,40 @@ func (p *PrettyPrinter) pretty_date(msg *pb.DateValue) interface{} { } func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { - 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 + 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() - 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)) + opt_val1139 := *field1138 + p.write(fmt.Sprintf("%d", opt_val1139)) } p.dedent() p.write(")") @@ -2215,24 +2219,24 @@ func (p *PrettyPrinter) pretty_datetime(msg *pb.DateTimeValue) interface{} { } func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { - flat1140 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) - if flat1140 != nil { - p.write(*flat1140) + flat1145 := p.tryFlat(msg, func() { p.pretty_conjunction(msg) }) + if flat1145 != nil { + p.write(*flat1145) return nil } else { _dollar_dollar := msg - fields1136 := _dollar_dollar.GetArgs() - unwrapped_fields1137 := fields1136 + fields1141 := _dollar_dollar.GetArgs() + unwrapped_fields1142 := fields1141 p.write("(") p.write("and") p.indentSexp() - if !(len(unwrapped_fields1137) == 0) { + if !(len(unwrapped_fields1142) == 0) { p.newline() - for i1139, elem1138 := range unwrapped_fields1137 { - if (i1139 > 0) { + for i1144, elem1143 := range unwrapped_fields1142 { + if (i1144 > 0) { p.newline() } - p.pretty_formula(elem1138) + p.pretty_formula(elem1143) } } p.dedent() @@ -2242,24 +2246,24 @@ func (p *PrettyPrinter) pretty_conjunction(msg *pb.Conjunction) interface{} { } func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { - flat1145 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) - if flat1145 != nil { - p.write(*flat1145) + flat1150 := p.tryFlat(msg, func() { p.pretty_disjunction(msg) }) + if flat1150 != nil { + p.write(*flat1150) return nil } else { _dollar_dollar := msg - fields1141 := _dollar_dollar.GetArgs() - unwrapped_fields1142 := fields1141 + fields1146 := _dollar_dollar.GetArgs() + unwrapped_fields1147 := fields1146 p.write("(") p.write("or") p.indentSexp() - if !(len(unwrapped_fields1142) == 0) { + if !(len(unwrapped_fields1147) == 0) { p.newline() - for i1144, elem1143 := range unwrapped_fields1142 { - if (i1144 > 0) { + for i1149, elem1148 := range unwrapped_fields1147 { + if (i1149 > 0) { p.newline() } - p.pretty_formula(elem1143) + p.pretty_formula(elem1148) } } p.dedent() @@ -2269,19 +2273,19 @@ func (p *PrettyPrinter) pretty_disjunction(msg *pb.Disjunction) interface{} { } func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { - flat1148 := p.tryFlat(msg, func() { p.pretty_not(msg) }) - if flat1148 != nil { - p.write(*flat1148) + flat1153 := p.tryFlat(msg, func() { p.pretty_not(msg) }) + if flat1153 != nil { + p.write(*flat1153) return nil } else { _dollar_dollar := msg - fields1146 := _dollar_dollar.GetArg() - unwrapped_fields1147 := fields1146 + fields1151 := _dollar_dollar.GetArg() + unwrapped_fields1152 := fields1151 p.write("(") p.write("not") p.indentSexp() p.newline() - p.pretty_formula(unwrapped_fields1147) + p.pretty_formula(unwrapped_fields1152) p.dedent() p.write(")") } @@ -2289,26 +2293,26 @@ func (p *PrettyPrinter) pretty_not(msg *pb.Not) interface{} { } func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { - flat1154 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) - if flat1154 != nil { - p.write(*flat1154) + flat1159 := p.tryFlat(msg, func() { p.pretty_ffi(msg) }) + if flat1159 != nil { + p.write(*flat1159) return nil } else { _dollar_dollar := msg - fields1149 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} - unwrapped_fields1150 := fields1149 + fields1154 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs(), _dollar_dollar.GetTerms()} + unwrapped_fields1155 := fields1154 p.write("(") p.write("ffi") p.indentSexp() p.newline() - field1151 := unwrapped_fields1150[0].(string) - p.pretty_name(field1151) + field1156 := unwrapped_fields1155[0].(string) + p.pretty_name(field1156) p.newline() - field1152 := unwrapped_fields1150[1].([]*pb.Abstraction) - p.pretty_ffi_args(field1152) + field1157 := unwrapped_fields1155[1].([]*pb.Abstraction) + p.pretty_ffi_args(field1157) p.newline() - field1153 := unwrapped_fields1150[2].([]*pb.Term) - p.pretty_terms(field1153) + field1158 := unwrapped_fields1155[2].([]*pb.Term) + p.pretty_terms(field1158) p.dedent() p.write(")") } @@ -2316,35 +2320,35 @@ func (p *PrettyPrinter) pretty_ffi(msg *pb.FFI) interface{} { } func (p *PrettyPrinter) pretty_name(msg string) interface{} { - 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) + p.write(fields1160) } return nil } func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { - 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) + p.pretty_abstraction(elem1163) } } p.dedent() @@ -2354,28 +2358,28 @@ func (p *PrettyPrinter) pretty_ffi_args(msg []*pb.Abstraction) interface{} { } func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { - 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 + fields1166 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1167 := fields1166 p.write("(") p.write("atom") p.indentSexp() p.newline() - field1163 := unwrapped_fields1162[0].(*pb.RelationId) - p.pretty_relation_id(field1163) - field1164 := unwrapped_fields1162[1].([]*pb.Term) - if !(len(field1164) == 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 i1166, elem1165 := range field1164 { - if (i1166 > 0) { + for i1171, elem1170 := range field1169 { + if (i1171 > 0) { p.newline() } - p.pretty_term(elem1165) + p.pretty_term(elem1170) } } p.dedent() @@ -2385,28 +2389,28 @@ func (p *PrettyPrinter) pretty_atom(msg *pb.Atom) interface{} { } func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { - 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 + fields1173 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1174 := fields1173 p.write("(") p.write("pragma") p.indentSexp() p.newline() - 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) + p.pretty_term(elem1177) } } p.dedent() @@ -2416,109 +2420,109 @@ func (p *PrettyPrinter) pretty_pragma(msg *pb.Pragma) interface{} { } func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { - 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 + fields1180 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetTerms()} + unwrapped_fields1181 := fields1180 p.write("(") p.write("primitive") p.indentSexp() p.newline() - field1177 := unwrapped_fields1176[0].(string) - p.pretty_name(field1177) - field1178 := unwrapped_fields1176[1].([]*pb.RelTerm) - if !(len(field1178) == 0) { + field1182 := unwrapped_fields1181[0].(string) + p.pretty_name(field1182) + field1183 := unwrapped_fields1181[1].([]*pb.RelTerm) + if !(len(field1183) == 0) { p.newline() - for i1180, elem1179 := range field1178 { - if (i1180 > 0) { + for i1185, elem1184 := range field1183 { + if (i1185 > 0) { p.newline() } - p.pretty_rel_term(elem1179) + p.pretty_rel_term(elem1184) } } p.dedent() @@ -2537,48 +2541,20 @@ func (p *PrettyPrinter) pretty_primitive(msg *pb.Primitive) interface{} { } func (p *PrettyPrinter) pretty_eq(msg *pb.Primitive) interface{} { - flat1195 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) - if flat1195 != nil { - p.write(*flat1195) - return nil - } else { - _dollar_dollar := msg - var _t1768 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_eq" { - _t1768 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} - } - fields1191 := _t1768 - unwrapped_fields1192 := fields1191 - p.write("(") - p.write("=") - p.indentSexp() - p.newline() - field1193 := unwrapped_fields1192[0].(*pb.Term) - p.pretty_term(field1193) - p.newline() - field1194 := unwrapped_fields1192[1].(*pb.Term) - p.pretty_term(field1194) - p.dedent() - p.write(")") - } - return nil -} - -func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { - flat1200 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) + flat1200 := p.tryFlat(msg, func() { p.pretty_eq(msg) }) if flat1200 != nil { p.write(*flat1200) return nil } else { _dollar_dollar := msg - var _t1769 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { - _t1769 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + var _t1778 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_eq" { + _t1778 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1196 := _t1769 + fields1196 := _t1778 unwrapped_fields1197 := fields1196 p.write("(") - p.write("<") + p.write("=") p.indentSexp() p.newline() field1198 := unwrapped_fields1197[0].(*pb.Term) @@ -2592,21 +2568,21 @@ func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { - flat1205 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) +func (p *PrettyPrinter) pretty_lt(msg *pb.Primitive) interface{} { + flat1205 := p.tryFlat(msg, func() { p.pretty_lt(msg) }) if flat1205 != nil { p.write(*flat1205) return nil } else { _dollar_dollar := msg - var _t1770 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { - _t1770 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + var _t1779 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_lt_monotype" { + _t1779 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1201 := _t1770 + fields1201 := _t1779 unwrapped_fields1202 := fields1201 p.write("(") - p.write("<=") + p.write("<") p.indentSexp() p.newline() field1203 := unwrapped_fields1202[0].(*pb.Term) @@ -2620,21 +2596,21 @@ func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { - flat1210 := p.tryFlat(msg, func() { p.pretty_gt(msg) }) +func (p *PrettyPrinter) pretty_lt_eq(msg *pb.Primitive) interface{} { + flat1210 := p.tryFlat(msg, func() { p.pretty_lt_eq(msg) }) if flat1210 != nil { p.write(*flat1210) return nil } else { _dollar_dollar := msg - var _t1771 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { - _t1771 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + var _t1780 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_lt_eq_monotype" { + _t1780 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1206 := _t1771 + fields1206 := _t1780 unwrapped_fields1207 := fields1206 p.write("(") - p.write(">") + p.write("<=") p.indentSexp() p.newline() field1208 := unwrapped_fields1207[0].(*pb.Term) @@ -2648,21 +2624,21 @@ func (p *PrettyPrinter) pretty_gt(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { - flat1215 := p.tryFlat(msg, func() { p.pretty_gt_eq(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 - var _t1772 []interface{} - if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { - _t1772 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} + var _t1781 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_gt_monotype" { + _t1781 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1211 := _t1772 + fields1211 := _t1781 unwrapped_fields1212 := fields1211 p.write("(") - p.write(">=") + p.write(">") p.indentSexp() p.newline() field1213 := unwrapped_fields1212[0].(*pb.Term) @@ -2676,21 +2652,21 @@ func (p *PrettyPrinter) pretty_gt_eq(msg *pb.Primitive) interface{} { return nil } -func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { - flat1221 := p.tryFlat(msg, func() { p.pretty_add(msg) }) - if flat1221 != nil { - p.write(*flat1221) +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 - var _t1773 []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()} + var _t1782 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_gt_eq_monotype" { + _t1782 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm()} } - fields1216 := _t1773 + fields1216 := _t1782 unwrapped_fields1217 := fields1216 p.write("(") - p.write("+") + p.write(">=") p.indentSexp() p.newline() field1218 := unwrapped_fields1217[0].(*pb.Term) @@ -2698,9 +2674,37 @@ func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { p.newline() field1219 := unwrapped_fields1217[1].(*pb.Term) p.pretty_term(field1219) + p.dedent() + p.write(")") + } + return nil +} + +func (p *PrettyPrinter) pretty_add(msg *pb.Primitive) interface{} { + flat1226 := p.tryFlat(msg, func() { p.pretty_add(msg) }) + if flat1226 != nil { + p.write(*flat1226) + return nil + } else { + _dollar_dollar := msg + var _t1783 []interface{} + if _dollar_dollar.GetName() == "rel_primitive_add_monotype" { + _t1783 = []interface{}{_dollar_dollar.GetTerms()[0].GetTerm(), _dollar_dollar.GetTerms()[1].GetTerm(), _dollar_dollar.GetTerms()[2].GetTerm()} + } + fields1221 := _t1783 + unwrapped_fields1222 := fields1221 + p.write("(") + p.write("+") + p.indentSexp() + p.newline() + field1223 := unwrapped_fields1222[0].(*pb.Term) + p.pretty_term(field1223) + p.newline() + 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(")") } @@ -2708,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(")") } @@ -2739,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(")") } @@ -2770,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(")") } @@ -2801,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"}) } @@ -2834,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() @@ -2878,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(")") } @@ -2902,22 +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) + p.pretty_attribute(elem1265) } } p.dedent() @@ -2927,28 +2931,28 @@ func (p *PrettyPrinter) pretty_attrs(msg []*pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { - flat1269 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) - if flat1269 != nil { - p.write(*flat1269) + flat1274 := p.tryFlat(msg, func() { p.pretty_attribute(msg) }) + if flat1274 != nil { + p.write(*flat1274) return nil } else { _dollar_dollar := msg - fields1263 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} - unwrapped_fields1264 := fields1263 + fields1268 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetArgs()} + unwrapped_fields1269 := fields1268 p.write("(") p.write("attribute") p.indentSexp() p.newline() - 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) + p.pretty_raw_value(elem1272) } } p.dedent() @@ -2958,39 +2962,39 @@ func (p *PrettyPrinter) pretty_attribute(msg *pb.Attribute) interface{} { } func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { - 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) + opt_val1282 := field1281 + p.pretty_attrs(opt_val1282) } p.dedent() p.write(")") @@ -2999,24 +3003,24 @@ func (p *PrettyPrinter) pretty_algorithm(msg *pb.Algorithm) interface{} { } func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { - 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) + p.pretty_construct(elem1286) } } p.dedent() @@ -3026,30 +3030,30 @@ func (p *PrettyPrinter) pretty_script(msg *pb.Script) interface{} { } func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { - 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) + deconstruct_result1289 := _t1791 + if deconstruct_result1289 != nil { + unwrapped1290 := deconstruct_result1289 + p.pretty_instruction(unwrapped1290) } else { panic(ParseError{msg: "No matching rule for construct"}) } @@ -3059,32 +3063,32 @@ func (p *PrettyPrinter) pretty_construct(msg *pb.Construct) interface{} { } func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { - 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 + fields1294 := []interface{}{_dollar_dollar.GetInit(), _dollar_dollar.GetBody(), _t1792} + unwrapped_fields1295 := fields1294 p.write("(") p.write("loop") p.indentSexp() p.newline() - field1291 := unwrapped_fields1290[0].([]*pb.Instruction) - p.pretty_init(field1291) + field1296 := unwrapped_fields1295[0].([]*pb.Instruction) + p.pretty_init(field1296) p.newline() - field1292 := unwrapped_fields1290[1].(*pb.Script) - p.pretty_script(field1292) - field1293 := unwrapped_fields1290[2].([]*pb.Attribute) - if field1293 != nil { + field1297 := unwrapped_fields1295[1].(*pb.Script) + p.pretty_script(field1297) + field1298 := unwrapped_fields1295[2].([]*pb.Attribute) + if field1298 != nil { p.newline() - opt_val1294 := field1293 - p.pretty_attrs(opt_val1294) + opt_val1299 := field1298 + p.pretty_attrs(opt_val1299) } p.dedent() p.write(")") @@ -3093,22 +3097,22 @@ func (p *PrettyPrinter) pretty_loop(msg *pb.Loop) interface{} { } func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { - 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) + p.pretty_instruction(elem1302) } } p.dedent() @@ -3118,60 +3122,60 @@ func (p *PrettyPrinter) pretty_init(msg []*pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { - 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) + deconstruct_result1305 := _t1797 + if deconstruct_result1305 != nil { + unwrapped1306 := deconstruct_result1305 + p.pretty_monus_def(unwrapped1306) } else { panic(ParseError{msg: "No matching rule for instruction"}) } @@ -3184,32 +3188,32 @@ func (p *PrettyPrinter) pretty_instruction(msg *pb.Instruction) interface{} { } func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { - 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 + fields1316 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1798} + unwrapped_fields1317 := fields1316 p.write("(") p.write("assign") p.indentSexp() p.newline() - field1313 := unwrapped_fields1312[0].(*pb.RelationId) - p.pretty_relation_id(field1313) + field1318 := unwrapped_fields1317[0].(*pb.RelationId) + p.pretty_relation_id(field1318) 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) + opt_val1321 := field1320 + p.pretty_attrs(opt_val1321) } p.dedent() p.write(")") @@ -3218,32 +3222,32 @@ func (p *PrettyPrinter) pretty_assign(msg *pb.Assign) interface{} { } func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { - 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 + 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() - field1320 := unwrapped_fields1319[0].(*pb.RelationId) - p.pretty_relation_id(field1320) + field1325 := unwrapped_fields1324[0].(*pb.RelationId) + p.pretty_relation_id(field1325) p.newline() - field1321 := unwrapped_fields1319[1].([]interface{}) - p.pretty_abstraction_with_arity(field1321) - field1322 := unwrapped_fields1319[2].([]*pb.Attribute) - if field1322 != nil { + field1326 := unwrapped_fields1324[1].([]interface{}) + p.pretty_abstraction_with_arity(field1326) + field1327 := unwrapped_fields1324[2].([]*pb.Attribute) + if field1327 != nil { p.newline() - opt_val1323 := field1322 - p.pretty_attrs(opt_val1323) + opt_val1328 := field1327 + p.pretty_attrs(opt_val1328) } p.dedent() p.write(")") @@ -3252,22 +3256,22 @@ func (p *PrettyPrinter) pretty_upsert(msg *pb.Upsert) interface{} { } func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interface{} { - 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) + field1333 := unwrapped_fields1331[1].(*pb.Formula) + p.pretty_formula(field1333) p.dedent() p.write(")") } @@ -3275,32 +3279,32 @@ func (p *PrettyPrinter) pretty_abstraction_with_arity(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { - flat1336 := p.tryFlat(msg, func() { p.pretty_break(msg) }) - if flat1336 != nil { - p.write(*flat1336) + 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 + fields1335 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetBody(), _t1801} + unwrapped_fields1336 := fields1335 p.write("(") p.write("break") p.indentSexp() p.newline() - field1332 := unwrapped_fields1331[0].(*pb.RelationId) - p.pretty_relation_id(field1332) + field1337 := unwrapped_fields1336[0].(*pb.RelationId) + p.pretty_relation_id(field1337) p.newline() - field1333 := unwrapped_fields1331[1].(*pb.Abstraction) - p.pretty_abstraction(field1333) - field1334 := unwrapped_fields1331[2].([]*pb.Attribute) - if field1334 != nil { + field1338 := unwrapped_fields1336[1].(*pb.Abstraction) + p.pretty_abstraction(field1338) + field1339 := unwrapped_fields1336[2].([]*pb.Attribute) + if field1339 != nil { p.newline() - opt_val1335 := field1334 - p.pretty_attrs(opt_val1335) + opt_val1340 := field1339 + p.pretty_attrs(opt_val1340) } p.dedent() p.write(")") @@ -3309,35 +3313,35 @@ func (p *PrettyPrinter) pretty_break(msg *pb.Break) interface{} { } func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { - 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 + 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() - field1339 := unwrapped_fields1338[0].(*pb.Monoid) - p.pretty_monoid(field1339) + field1344 := unwrapped_fields1343[0].(*pb.Monoid) + p.pretty_monoid(field1344) p.newline() - field1340 := unwrapped_fields1338[1].(*pb.RelationId) - p.pretty_relation_id(field1340) + field1345 := unwrapped_fields1343[1].(*pb.RelationId) + p.pretty_relation_id(field1345) p.newline() - field1341 := unwrapped_fields1338[2].([]interface{}) - p.pretty_abstraction_with_arity(field1341) - field1342 := unwrapped_fields1338[3].([]*pb.Attribute) - if field1342 != nil { + field1346 := unwrapped_fields1343[2].([]interface{}) + p.pretty_abstraction_with_arity(field1346) + field1347 := unwrapped_fields1343[3].([]*pb.Attribute) + if field1347 != nil { p.newline() - opt_val1343 := field1342 - p.pretty_attrs(opt_val1343) + opt_val1348 := field1347 + p.pretty_attrs(opt_val1348) } p.dedent() p.write(")") @@ -3346,50 +3350,50 @@ func (p *PrettyPrinter) pretty_monoid_def(msg *pb.MonoidDef) interface{} { } func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { - 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) + deconstruct_result1350 := _t1806 + if deconstruct_result1350 != nil { + unwrapped1351 := deconstruct_result1350 + p.pretty_sum_monoid(unwrapped1351) } else { panic(ParseError{msg: "No matching rule for monoid"}) } @@ -3401,8 +3405,8 @@ func (p *PrettyPrinter) pretty_monoid(msg *pb.Monoid) interface{} { } func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { - fields1354 := msg - _ = fields1354 + fields1359 := msg + _ = fields1359 p.write("(") p.write("or") p.write(")") @@ -3410,19 +3414,19 @@ func (p *PrettyPrinter) pretty_or_monoid(msg *pb.OrMonoid) interface{} { } func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { - flat1357 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) - if flat1357 != nil { - p.write(*flat1357) + flat1362 := p.tryFlat(msg, func() { p.pretty_min_monoid(msg) }) + if flat1362 != nil { + p.write(*flat1362) return nil } else { _dollar_dollar := msg - fields1355 := _dollar_dollar.GetType() - unwrapped_fields1356 := fields1355 + fields1360 := _dollar_dollar.GetType() + unwrapped_fields1361 := fields1360 p.write("(") p.write("min") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1356) + p.pretty_type(unwrapped_fields1361) p.dedent() p.write(")") } @@ -3430,19 +3434,19 @@ func (p *PrettyPrinter) pretty_min_monoid(msg *pb.MinMonoid) interface{} { } func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { - 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 + fields1363 := _dollar_dollar.GetType() + unwrapped_fields1364 := fields1363 p.write("(") p.write("max") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1359) + p.pretty_type(unwrapped_fields1364) p.dedent() p.write(")") } @@ -3450,19 +3454,19 @@ func (p *PrettyPrinter) pretty_max_monoid(msg *pb.MaxMonoid) interface{} { } func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { - flat1363 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) - if flat1363 != nil { - p.write(*flat1363) + flat1368 := p.tryFlat(msg, func() { p.pretty_sum_monoid(msg) }) + if flat1368 != nil { + p.write(*flat1368) return nil } else { _dollar_dollar := msg - fields1361 := _dollar_dollar.GetType() - unwrapped_fields1362 := fields1361 + fields1366 := _dollar_dollar.GetType() + unwrapped_fields1367 := fields1366 p.write("(") p.write("sum") p.indentSexp() p.newline() - p.pretty_type(unwrapped_fields1362) + p.pretty_type(unwrapped_fields1367) p.dedent() p.write(")") } @@ -3470,35 +3474,35 @@ func (p *PrettyPrinter) pretty_sum_monoid(msg *pb.SumMonoid) interface{} { } func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { - 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 + 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() - field1366 := unwrapped_fields1365[0].(*pb.Monoid) - p.pretty_monoid(field1366) + field1371 := unwrapped_fields1370[0].(*pb.Monoid) + p.pretty_monoid(field1371) p.newline() - field1367 := unwrapped_fields1365[1].(*pb.RelationId) - p.pretty_relation_id(field1367) + field1372 := unwrapped_fields1370[1].(*pb.RelationId) + p.pretty_relation_id(field1372) 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) + opt_val1375 := field1374 + p.pretty_attrs(opt_val1375) } p.dedent() p.write(")") @@ -3507,29 +3511,29 @@ func (p *PrettyPrinter) pretty_monus_def(msg *pb.MonusDef) interface{} { } func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { - 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 + 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() - field1374 := unwrapped_fields1373[0].(*pb.RelationId) - p.pretty_relation_id(field1374) + field1379 := unwrapped_fields1378[0].(*pb.RelationId) + p.pretty_relation_id(field1379) p.newline() - field1375 := unwrapped_fields1373[1].(*pb.Abstraction) - p.pretty_abstraction(field1375) + field1380 := unwrapped_fields1378[1].(*pb.Abstraction) + p.pretty_abstraction(field1380) p.newline() - field1376 := unwrapped_fields1373[2].([]*pb.Var) - p.pretty_functional_dependency_keys(field1376) + field1381 := unwrapped_fields1378[2].([]*pb.Var) + p.pretty_functional_dependency_keys(field1381) p.newline() - field1377 := unwrapped_fields1373[3].([]*pb.Var) - p.pretty_functional_dependency_values(field1377) + field1382 := unwrapped_fields1378[3].([]*pb.Var) + p.pretty_functional_dependency_values(field1382) p.dedent() p.write(")") } @@ -3537,22 +3541,22 @@ func (p *PrettyPrinter) pretty_constraint(msg *pb.Constraint) interface{} { } func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interface{} { - 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) + p.pretty_var(elem1385) } } p.dedent() @@ -3562,22 +3566,22 @@ func (p *PrettyPrinter) pretty_functional_dependency_keys(msg []*pb.Var) interfa } func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) interface{} { - 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) + p.pretty_var(elem1389) } } p.dedent() @@ -3587,50 +3591,50 @@ func (p *PrettyPrinter) pretty_functional_dependency_values(msg []*pb.Var) inter } func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { - 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) + deconstruct_result1392 := _t1811 + if deconstruct_result1392 != nil { + unwrapped1393 := deconstruct_result1392 + p.pretty_iceberg_data(unwrapped1393) } else { panic(ParseError{msg: "No matching rule for data"}) } @@ -3642,26 +3646,26 @@ func (p *PrettyPrinter) pretty_data(msg *pb.Data) interface{} { } func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { - 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 + fields1401 := []interface{}{_dollar_dollar.GetTargetId(), _dollar_dollar.GetPath(), _dollar_dollar.GetTypes()} + unwrapped_fields1402 := fields1401 p.write("(") p.write("edb") p.indentSexp() p.newline() - field1398 := unwrapped_fields1397[0].(*pb.RelationId) - p.pretty_relation_id(field1398) + field1403 := unwrapped_fields1402[0].(*pb.RelationId) + p.pretty_relation_id(field1403) p.newline() - field1399 := unwrapped_fields1397[1].([]string) - p.pretty_edb_path(field1399) + field1404 := unwrapped_fields1402[1].([]string) + p.pretty_edb_path(field1404) p.newline() - field1400 := unwrapped_fields1397[2].([]*pb.Type) - p.pretty_edb_types(field1400) + field1405 := unwrapped_fields1402[2].([]*pb.Type) + p.pretty_edb_types(field1405) p.dedent() p.write(")") } @@ -3669,19 +3673,19 @@ func (p *PrettyPrinter) pretty_edb(msg *pb.EDB) interface{} { } func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { - 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)) + p.write(p.formatStringValue(elem1408)) } p.dedent() p.write("]") @@ -3690,19 +3694,19 @@ func (p *PrettyPrinter) pretty_edb_path(msg []string) interface{} { } func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { - 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) + p.pretty_type(elem1412) } p.dedent() p.write("]") @@ -3711,23 +3715,23 @@ func (p *PrettyPrinter) pretty_edb_types(msg []*pb.Type) interface{} { } func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface{} { - 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 + fields1415 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationInfo()} + unwrapped_fields1416 := fields1415 p.write("(") p.write("betree_relation") p.indentSexp() p.newline() - 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) + field1418 := unwrapped_fields1416[1].(*pb.BeTreeInfo) + p.pretty_betree_info(field1418) p.dedent() p.write(")") } @@ -3735,27 +3739,27 @@ func (p *PrettyPrinter) pretty_betree_relation(msg *pb.BeTreeRelation) interface } func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { - 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 + _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() - field1417 := unwrapped_fields1416[0].([]*pb.Type) - p.pretty_betree_info_key_types(field1417) + field1422 := unwrapped_fields1421[0].([]*pb.Type) + p.pretty_betree_info_key_types(field1422) p.newline() - field1418 := unwrapped_fields1416[1].([]*pb.Type) - p.pretty_betree_info_value_types(field1418) + field1423 := unwrapped_fields1421[1].([]*pb.Type) + p.pretty_betree_info_value_types(field1423) p.newline() - field1419 := unwrapped_fields1416[2].([][]interface{}) - p.pretty_config_dict(field1419) + field1424 := unwrapped_fields1421[2].([][]interface{}) + p.pretty_config_dict(field1424) p.dedent() p.write(")") } @@ -3763,22 +3767,22 @@ func (p *PrettyPrinter) pretty_betree_info(msg *pb.BeTreeInfo) interface{} { } func (p *PrettyPrinter) pretty_betree_info_key_types(msg []*pb.Type) interface{} { - 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) + p.pretty_type(elem1427) } } p.dedent() @@ -3788,22 +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{} { - 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) + p.pretty_type(elem1431) } } p.dedent() @@ -3813,40 +3817,40 @@ func (p *PrettyPrinter) pretty_betree_info_value_types(msg []*pb.Type) interface } func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { - 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 + _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() - field1431 := unwrapped_fields1430[0].(*pb.CSVLocator) - p.pretty_csvlocator(field1431) + field1436 := unwrapped_fields1435[0].(*pb.CSVLocator) + p.pretty_csvlocator(field1436) 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) + field1442 := unwrapped_fields1435[4].(string) + p.pretty_csv_asof(field1442) p.dedent() p.write(")") } @@ -3854,36 +3858,36 @@ func (p *PrettyPrinter) pretty_csv_data(msg *pb.CSVData) interface{} { } func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { - 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) + opt_val1449 := *field1448 + p.pretty_csv_locator_inline_data(opt_val1449) } p.dedent() p.write(")") @@ -3892,22 +3896,22 @@ func (p *PrettyPrinter) pretty_csvlocator(msg *pb.CSVLocator) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { - 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)) + p.write(p.formatStringValue(elem1452)) } } p.dedent() @@ -3917,17 +3921,17 @@ func (p *PrettyPrinter) pretty_csv_locator_paths(msg []string) interface{} { } func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { - 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 + fields1455 := msg p.write("(") p.write("inline_data") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1450)) + p.write(p.formatStringValue(fields1455)) p.dedent() p.write(")") } @@ -3935,27 +3939,27 @@ func (p *PrettyPrinter) pretty_csv_locator_inline_data(msg string) interface{} { } func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { - 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 + _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() - field1454 := unwrapped_fields1453[0].([][]interface{}) - p.pretty_config_dict(field1454) - field1455 := unwrapped_fields1453[1].([][]interface{}) - if field1455 != nil { + field1459 := unwrapped_fields1458[0].([][]interface{}) + p.pretty_config_dict(field1459) + field1460 := unwrapped_fields1458[1].([][]interface{}) + if field1460 != nil { p.newline() - opt_val1456 := field1455 - p.pretty__storage_integration(opt_val1456) + opt_val1461 := field1460 + p.pretty__storage_integration(opt_val1461) } p.dedent() p.write(")") @@ -3964,17 +3968,17 @@ func (p *PrettyPrinter) pretty_csv_config(msg *pb.CSVConfig) interface{} { } func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interface{} { - 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 + fields1463 := msg p.write("(") p.write("storage_integration") p.indentSexp() p.newline() - p.pretty_config_dict(fields1458) + p.pretty_config_dict(fields1463) p.dedent() p.write(")") } @@ -3982,22 +3986,22 @@ func (p *PrettyPrinter) pretty__storage_integration(msg [][]interface{}) interfa } func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { - 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) + p.pretty_gnf_column(elem1466) } } p.dedent() @@ -4007,38 +4011,38 @@ func (p *PrettyPrinter) pretty_gnf_columns(msg []*pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { - 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 + fields1469 := []interface{}{_dollar_dollar.GetColumnPath(), _t1819, _dollar_dollar.GetTypes()} + unwrapped_fields1470 := fields1469 p.write("(") p.write("column") p.indentSexp() p.newline() - 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) + p.pretty_type(elem1475) } p.write("]") p.dedent() @@ -4048,36 +4052,36 @@ func (p *PrettyPrinter) pretty_gnf_column(msg *pb.GNFColumn) interface{} { } func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { - 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)) + p.write(p.formatStringValue(elem1480)) } p.dedent() p.write("]") @@ -4090,23 +4094,23 @@ func (p *PrettyPrinter) pretty_gnf_column_path(msg []string) interface{} { } 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(")") } @@ -4114,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() @@ -4139,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(")") } @@ -4163,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"}) } @@ -4200,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() @@ -4248,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() @@ -4273,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() @@ -4298,17 +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 + fields1525 := msg p.write("(") p.write("asof") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1520)) + p.write(p.formatStringValue(fields1525)) p.dedent() p.write(")") } @@ -4316,43 +4320,43 @@ func (p *PrettyPrinter) pretty_csv_asof(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { - 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 + _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() - 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) + field1536 := unwrapped_fields1528[5].(bool) + p.pretty_boolean_value(field1536) p.dedent() p.write(")") } @@ -4360,26 +4364,26 @@ func (p *PrettyPrinter) pretty_iceberg_data(msg *pb.IcebergData) interface{} { } func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface{} { - 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 + fields1538 := []interface{}{_dollar_dollar.GetTableName(), _dollar_dollar.GetNamespace(), _dollar_dollar.GetWarehouse()} + unwrapped_fields1539 := fields1538 p.write("(") p.write("iceberg_locator") p.indentSexp() p.newline() - 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) + field1542 := unwrapped_fields1539[2].(string) + p.pretty_iceberg_locator_warehouse(field1542) p.dedent() p.write(")") } @@ -4387,17 +4391,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator(msg *pb.IcebergLocator) interface } func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{} { - flat1540 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) - if flat1540 != nil { - p.write(*flat1540) + flat1545 := p.tryFlat(msg, func() { p.pretty_iceberg_locator_table_name(msg) }) + if flat1545 != nil { + p.write(*flat1545) return nil } else { - fields1539 := msg + fields1544 := msg p.write("(") p.write("table_name") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1539)) + p.write(p.formatStringValue(fields1544)) p.dedent() p.write(")") } @@ -4405,22 +4409,22 @@ func (p *PrettyPrinter) pretty_iceberg_locator_table_name(msg string) interface{ } func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface{} { - 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)) + p.write(p.formatStringValue(elem1547)) } } p.dedent() @@ -4430,17 +4434,17 @@ func (p *PrettyPrinter) pretty_iceberg_locator_namespace(msg []string) interface } func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} { - 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 + fields1550 := msg p.write("(") p.write("warehouse") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1545)) + p.write(p.formatStringValue(fields1550)) p.dedent() p.write(")") } @@ -4448,33 +4452,33 @@ func (p *PrettyPrinter) pretty_iceberg_locator_warehouse(msg string) interface{} } func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConfig) interface{} { - flat1554 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) - if flat1554 != nil { - p.write(*flat1554) + flat1559 := p.tryFlat(msg, func() { p.pretty_iceberg_catalog_config(msg) }) + if flat1559 != nil { + p.write(*flat1559) 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 + _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() - 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) + field1558 := unwrapped_fields1553[3].([][]interface{}) + p.pretty_iceberg_auth_properties(field1558) p.dedent() p.write(")") } @@ -4482,17 +4486,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config(msg *pb.IcebergCatalogConf } func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { - 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 + fields1560 := msg p.write("(") p.write("catalog_uri") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1555)) + p.write(p.formatStringValue(fields1560)) p.dedent() p.write(")") } @@ -4500,17 +4504,17 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_uri(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interface{} { - 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 + fields1562 := msg p.write("(") p.write("scope") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1557)) + p.write(p.formatStringValue(fields1562)) p.dedent() p.write(")") } @@ -4518,22 +4522,22 @@ func (p *PrettyPrinter) pretty_iceberg_catalog_config_scope(msg string) interfac } func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface{} { - 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) + p.pretty_iceberg_property_entry(elem1565) } } p.dedent() @@ -4543,23 +4547,23 @@ func (p *PrettyPrinter) pretty_iceberg_properties(msg [][]interface{}) interface } func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interface{} { - 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 + fields1568 := []interface{}{_dollar_dollar[0].(string), _dollar_dollar[1].(string)} + unwrapped_fields1569 := fields1568 p.write("(") p.write("prop") p.indentSexp() p.newline() - field1565 := unwrapped_fields1564[0].(string) - p.write(p.formatStringValue(field1565)) + field1570 := unwrapped_fields1569[0].(string) + p.write(p.formatStringValue(field1570)) p.newline() - field1566 := unwrapped_fields1564[1].(string) - p.write(p.formatStringValue(field1566)) + field1571 := unwrapped_fields1569[1].(string) + p.write(p.formatStringValue(field1571)) p.dedent() p.write(")") } @@ -4567,22 +4571,22 @@ func (p *PrettyPrinter) pretty_iceberg_property_entry(msg []interface{}) interfa } func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) interface{} { - 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) + p.pretty_iceberg_masked_property_entry(elem1574) } } p.dedent() @@ -4592,24 +4596,24 @@ func (p *PrettyPrinter) pretty_iceberg_auth_properties(msg [][]interface{}) inte } func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) interface{} { - 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 + _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() - field1574 := unwrapped_fields1573[0].(string) - p.write(p.formatStringValue(field1574)) + field1579 := unwrapped_fields1578[0].(string) + p.write(p.formatStringValue(field1579)) p.newline() - field1575 := unwrapped_fields1573[1].(string) - p.write(p.formatStringValue(field1575)) + field1580 := unwrapped_fields1578[1].(string) + p.write(p.formatStringValue(field1580)) p.dedent() p.write(")") } @@ -4617,17 +4621,17 @@ func (p *PrettyPrinter) pretty_iceberg_masked_property_entry(msg []interface{}) } func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { - 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 + fields1582 := msg p.write("(") p.write("from_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1577)) + p.write(p.formatStringValue(fields1582)) p.dedent() p.write(")") } @@ -4635,17 +4639,17 @@ func (p *PrettyPrinter) pretty_iceberg_from_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { - 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 + fields1584 := msg p.write("(") p.write("to_snapshot") p.indentSexp() p.newline() - p.write(p.formatStringValue(fields1579)) + p.write(p.formatStringValue(fields1584)) p.dedent() p.write(")") } @@ -4653,19 +4657,19 @@ func (p *PrettyPrinter) pretty_iceberg_to_snapshot(msg string) interface{} { } func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { - 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 + fields1586 := _dollar_dollar.GetFragmentId() + unwrapped_fields1587 := fields1586 p.write("(") p.write("undefine") p.indentSexp() p.newline() - p.pretty_fragment_id(unwrapped_fields1582) + p.pretty_fragment_id(unwrapped_fields1587) p.dedent() p.write(")") } @@ -4673,24 +4677,24 @@ func (p *PrettyPrinter) pretty_undefine(msg *pb.Undefine) interface{} { } func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { - flat1588 := p.tryFlat(msg, func() { p.pretty_context(msg) }) - if flat1588 != nil { - p.write(*flat1588) + flat1593 := p.tryFlat(msg, func() { p.pretty_context(msg) }) + if flat1593 != nil { + p.write(*flat1593) 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) + p.pretty_relation_id(elem1591) } } p.dedent() @@ -4700,28 +4704,28 @@ func (p *PrettyPrinter) pretty_context(msg *pb.Context) interface{} { } func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { - 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 + fields1594 := []interface{}{_dollar_dollar.GetPrefix(), _dollar_dollar.GetMappings()} + unwrapped_fields1595 := fields1594 p.write("(") p.write("snapshot") p.indentSexp() p.newline() - 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) + p.pretty_snapshot_mapping(elem1598) } } p.dedent() @@ -4731,40 +4735,40 @@ func (p *PrettyPrinter) pretty_snapshot(msg *pb.Snapshot) interface{} { } func (p *PrettyPrinter) pretty_snapshot_mapping(msg *pb.SnapshotMapping) interface{} { - 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) + field1604 := unwrapped_fields1602[1].(*pb.RelationId) + p.pretty_relation_id(field1604) } return nil } func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { - 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) + p.pretty_read(elem1607) } } p.dedent() @@ -4774,60 +4778,60 @@ func (p *PrettyPrinter) pretty_epoch_reads(msg []*pb.Read) interface{} { } func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { - 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) + deconstruct_result1610 := _t1832 + if deconstruct_result1610 != nil { + unwrapped1611 := deconstruct_result1610 + p.pretty_export(unwrapped1611) } else { panic(ParseError{msg: "No matching rule for read"}) } @@ -4840,19 +4844,19 @@ func (p *PrettyPrinter) pretty_read(msg *pb.Read) interface{} { } func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { - 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 + fields1621 := _dollar_dollar.GetRelationId() + unwrapped_fields1622 := fields1621 p.write("(") p.write("demand") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped_fields1617) + p.pretty_relation_id(unwrapped_fields1622) p.dedent() p.write(")") } @@ -4860,23 +4864,23 @@ func (p *PrettyPrinter) pretty_demand(msg *pb.Demand) interface{} { } func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { - 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 + fields1624 := []interface{}{_dollar_dollar.GetName(), _dollar_dollar.GetRelationId()} + unwrapped_fields1625 := fields1624 p.write("(") p.write("output") p.indentSexp() p.newline() - 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) + field1627 := unwrapped_fields1625[1].(*pb.RelationId) + p.pretty_relation_id(field1627) p.dedent() p.write(")") } @@ -4884,23 +4888,23 @@ func (p *PrettyPrinter) pretty_output(msg *pb.Output) interface{} { } func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { - 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 + fields1629 := []interface{}{_dollar_dollar.GetBranch(), _dollar_dollar.GetEpoch()} + unwrapped_fields1630 := fields1629 p.write("(") p.write("what_if") p.indentSexp() p.newline() - 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) + field1632 := unwrapped_fields1630[1].(*pb.Epoch) + p.pretty_epoch(field1632) p.dedent() p.write(")") } @@ -4908,30 +4912,30 @@ func (p *PrettyPrinter) pretty_what_if(msg *pb.WhatIf) interface{} { } func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { - 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) + field1638 := unwrapped_fields1635[1].(*pb.RelationId) + p.pretty_relation_id(field1638) p.dedent() p.write(")") } @@ -4939,40 +4943,40 @@ func (p *PrettyPrinter) pretty_abort(msg *pb.Abort) interface{} { } func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { - 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 + deconstruct_result1642 := _t1834 + if deconstruct_result1642 != nil { + unwrapped1643 := deconstruct_result1642 p.write("(") p.write("export") p.indentSexp() p.newline() - p.pretty_export_csv_config(unwrapped1638) + p.pretty_export_csv_config(unwrapped1643) p.dedent() p.write(")") } else { _dollar_dollar := msg - 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 + deconstruct_result1640 := _t1835 + if deconstruct_result1640 != nil { + unwrapped1641 := deconstruct_result1640 p.write("(") p.write("export_iceberg") p.indentSexp() p.newline() - p.pretty_export_iceberg_config(unwrapped1636) + p.pretty_export_iceberg_config(unwrapped1641) p.dedent() p.write(")") } else { @@ -4984,55 +4988,56 @@ func (p *PrettyPrinter) pretty_export(msg *pb.Export) interface{} { } func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interface{} { - 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 + deconstruct_result1650 := _t1836 + if deconstruct_result1650 != nil { + unwrapped1651 := deconstruct_result1650 p.write("(") p.write("export_csv_config_v2") p.indentSexp() p.newline() - field1647 := unwrapped1646[0].(string) - p.pretty_export_csv_path(field1647) + field1652 := unwrapped1651[0].([]interface{}) + p.pretty_export_csv_output_location(field1652) p.newline() - field1648 := unwrapped1646[1].(*pb.ExportCSVSource) - p.pretty_export_csv_source(field1648) + field1653 := unwrapped1651[1].(*pb.ExportCSVSource) + p.pretty_export_csv_source(field1653) p.newline() - field1649 := unwrapped1646[2].(*pb.CSVConfig) - p.pretty_csv_config(field1649) + field1654 := unwrapped1651[2].(*pb.CSVConfig) + p.pretty_csv_config(field1654) p.dedent() p.write(")") } else { _dollar_dollar := msg - 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 + deconstruct_result1645 := _t1838 + if deconstruct_result1645 != nil { + unwrapped1646 := deconstruct_result1645 p.write("(") p.write("export_csv_config") p.indentSexp() p.newline() - 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) + field1649 := unwrapped1646[2].([][]interface{}) + p.pretty_config_dict(field1649) p.dedent() p.write(")") } else { @@ -5043,66 +5048,93 @@ func (p *PrettyPrinter) pretty_export_csv_config(msg *pb.ExportCSVConfig) interf return nil } -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) +func (p *PrettyPrinter) pretty_export_csv_output_location(msg []interface{}) interface{} { + flat1660 := p.tryFlat(msg, func() { p.pretty_export_csv_output_location(msg) }) + if flat1660 != nil { + p.write(*flat1660) return nil } else { - fields1651 := msg - p.write("(") - p.write("path") - p.indentSexp() - p.newline() - p.write(p.formatStringValue(fields1651)) - p.dedent() - p.write(")") + _dollar_dollar := msg + var _t1840 *string + if _dollar_dollar[0].(string) != "" { + _t1840 = ptr(_dollar_dollar[0].(string)) + } + deconstruct_result1658 := _t1840 + if deconstruct_result1658 != nil { + unwrapped1659 := *deconstruct_result1658 + p.write("(") + p.write("path") + p.indentSexp() + p.newline() + p.write(p.formatStringValue(unwrapped1659)) + p.dedent() + p.write(")") + } else { + _dollar_dollar := msg + var _t1841 *string + if _dollar_dollar[1].(string) != "" { + _t1841 = ptr(_dollar_dollar[1].(string)) + } + deconstruct_result1656 := _t1841 + if deconstruct_result1656 != nil { + unwrapped1657 := *deconstruct_result1656 + p.write("(") + p.write("transaction_output_name") + p.indentSexp() + p.newline() + p.pretty_name(unwrapped1657) + 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{} { - 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) + p.pretty_export_csv_column(elem1665) } } p.dedent() p.write(")") } else { _dollar_dollar := msg - 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 + deconstruct_result1661 := _t1843 + if deconstruct_result1661 != nil { + unwrapped1662 := deconstruct_result1661 p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(unwrapped1654) + p.pretty_relation_id(unwrapped1662) p.dedent() p.write(")") } else { @@ -5114,23 +5146,41 @@ func (p *PrettyPrinter) pretty_export_csv_source(msg *pb.ExportCSVSource) interf } func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interface{} { - flat1664 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) - if flat1664 != nil { - p.write(*flat1664) + flat1672 := p.tryFlat(msg, func() { p.pretty_export_csv_column(msg) }) + if flat1672 != nil { + p.write(*flat1672) return nil } else { _dollar_dollar := msg - fields1660 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} - unwrapped_fields1661 := fields1660 + fields1668 := []interface{}{_dollar_dollar.GetColumnName(), _dollar_dollar.GetColumnData()} + unwrapped_fields1669 := fields1668 p.write("(") p.write("column") p.indentSexp() p.newline() - field1662 := unwrapped_fields1661[0].(string) - p.write(p.formatStringValue(field1662)) + field1670 := unwrapped_fields1669[0].(string) + p.write(p.formatStringValue(field1670)) + p.newline() + field1671 := unwrapped_fields1669[1].(*pb.RelationId) + p.pretty_relation_id(field1671) + p.dedent() + p.write(")") + } + return nil +} + +func (p *PrettyPrinter) pretty_export_csv_path(msg string) interface{} { + flat1674 := p.tryFlat(msg, func() { p.pretty_export_csv_path(msg) }) + if flat1674 != nil { + p.write(*flat1674) + return nil + } else { + fields1673 := msg + p.write("(") + p.write("path") + p.indentSexp() p.newline() - field1663 := unwrapped_fields1661[1].(*pb.RelationId) - p.pretty_relation_id(field1663) + p.write(p.formatStringValue(fields1673)) p.dedent() p.write(")") } @@ -5138,22 +5188,22 @@ func (p *PrettyPrinter) pretty_export_csv_column(msg *pb.ExportCSVColumn) interf } func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn) interface{} { - 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) + p.pretty_export_csv_column(elem1676) } } p.dedent() @@ -5163,35 +5213,35 @@ func (p *PrettyPrinter) pretty_export_csv_columns_list(msg []*pb.ExportCSVColumn } func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig) interface{} { - 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 + _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() - field1671 := unwrapped_fields1670[0].(*pb.IcebergLocator) - p.pretty_iceberg_locator(field1671) + field1681 := unwrapped_fields1680[0].(*pb.IcebergLocator) + p.pretty_iceberg_locator(field1681) p.newline() - field1672 := unwrapped_fields1670[1].(*pb.IcebergCatalogConfig) - p.pretty_iceberg_catalog_config(field1672) + field1682 := unwrapped_fields1680[1].(*pb.IcebergCatalogConfig) + p.pretty_iceberg_catalog_config(field1682) p.newline() - field1673 := unwrapped_fields1670[2].(*pb.RelationId) - p.pretty_export_iceberg_table_def(field1673) + field1683 := unwrapped_fields1680[2].(*pb.RelationId) + p.pretty_export_iceberg_table_def(field1683) 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) + opt_val1686 := field1685 + p.pretty_config_dict(opt_val1686) } p.dedent() p.write(")") @@ -5200,17 +5250,17 @@ func (p *PrettyPrinter) pretty_export_iceberg_config(msg *pb.ExportIcebergConfig } func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) interface{} { - 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 + fields1688 := msg p.write("(") p.write("table_def") p.indentSexp() p.newline() - p.pretty_relation_id(fields1678) + p.pretty_relation_id(fields1688) p.dedent() p.write(")") } @@ -5218,22 +5268,22 @@ func (p *PrettyPrinter) pretty_export_iceberg_table_def(msg *pb.RelationId) inte } func (p *PrettyPrinter) pretty_iceberg_table_properties(msg [][]interface{}) interface{} { - 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) + p.pretty_iceberg_property_entry(elem1691) } } p.dedent() @@ -5251,8 +5301,8 @@ func (p *PrettyPrinter) pretty_debug_info(msg *pb.DebugInfo) interface{} { for _idx, _rid := range msg.GetIds() { p.newline() p.write("(") - _t1885 := &pb.UInt128Value{Low: _rid.GetIdLow(), High: _rid.GetIdHigh()} - p.pprintDispatch(_t1885) + _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/julia/LogicalQueryProtocol.jl/src/equality.jl b/sdks/julia/LogicalQueryProtocol.jl/src/equality.jl index 6a1b3d42..39c46cb8 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/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 3a412920..97bbbe01 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 - _t2187 = nothing + _t2199 = 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 - _t2188 = nothing + _t2200 = 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 - _t2189 = nothing + _t2201 = 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 - _t2190 = nothing + _t2202 = 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 - _t2191 = nothing + _t2203 = 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 - _t2192 = nothing + _t2204 = 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 - _t2193 = nothing + _t2205 = 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 - _t2194 = nothing + _t2206 = nothing end return nothing end @@ -444,118 +444,118 @@ function _try_extract_value_uint128(parser::ParserState, value::Union{Nothing, P if (!isnothing(value) && _has_proto_field(value, Symbol("uint128_value"))) return _get_oneof_field(value, :uint128_value) else - _t2195 = nothing + _t2207 = nothing end return nothing end function construct_non_cdc_relations(parser::ParserState, targets::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2196 = Proto.PlainTargets(targets=targets) - _t2197 = Proto.TargetRelations(body=OneOf(:plain, _t2196), keys=Proto.NamedColumn[]) - return _t2197 + _t2208 = Proto.PlainTargets(targets=targets) + _t2209 = Proto.TargetRelations(body=OneOf(:plain, _t2208), keys=Proto.NamedColumn[]) + return _t2209 end function construct_cdc_relations(parser::ParserState, inserts::Vector{Proto.TargetRelation}, deletes::Vector{Proto.TargetRelation})::Proto.TargetRelations - _t2198 = Proto.CDCTargets(inserts=inserts, deletes=deletes) - _t2199 = Proto.TargetRelations(body=OneOf(:cdc, _t2198), keys=Proto.NamedColumn[]) - return _t2199 + _t2210 = Proto.CDCTargets(inserts=inserts, deletes=deletes) + _t2211 = Proto.TargetRelations(body=OneOf(:cdc, _t2210), keys=Proto.NamedColumn[]) + return _t2211 end function construct_relations(parser::ParserState, keys::Vector{Proto.NamedColumn}, body::Proto.TargetRelations)::Proto.TargetRelations if _has_proto_field(body, Symbol("plain")) - _t2201 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys) - return _t2201 + _t2213 = Proto.TargetRelations(body=OneOf(:plain, _get_oneof_field(body, :plain)), keys=keys) + return _t2213 else - _t2200 = nothing + _t2212 = nothing end - _t2202 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys) - return _t2202 + _t2214 = Proto.TargetRelations(body=OneOf(:cdc, _get_oneof_field(body, :cdc)), keys=keys) + return _t2214 end function construct_csv_data(parser::ParserState, locator::Proto.CSVLocator, config::Proto.CSVConfig, columns_opt::Union{Nothing, Vector{Proto.GNFColumn}}, relations_opt::Union{Nothing, Proto.TargetRelations}, asof::String)::Proto.CSVData - _t2203 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) - return _t2203 + _t2215 = Proto.CSVData(locator=locator, config=config, columns=(!isnothing(columns_opt) ? columns_opt : Proto.GNFColumn[]), asof=asof, relations=relations_opt) + return _t2215 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) - _t2204 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) - header_row = _t2204 - _t2205 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) - skip = _t2205 - _t2206 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") - new_line = _t2206 - _t2207 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") - delimiter = _t2207 - _t2208 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") - quotechar = _t2208 - _t2209 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") - escapechar = _t2209 - _t2210 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") - comment = _t2210 - _t2211 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) - missing_strings = _t2211 - _t2212 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") - decimal_separator = _t2212 - _t2213 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") - encoding = _t2213 - _t2214 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") - compression = _t2214 - _t2215 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) - partition_size_mb = _t2215 - _t2216 = construct_csv_storage_integration(parser, storage_integration_opt) - storage_integration = _t2216 - _t2217 = 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 _t2217 + _t2216 = _extract_value_int32(parser, get(config, "csv_header_row", nothing), 1) + header_row = _t2216 + _t2217 = _extract_value_int64(parser, get(config, "csv_skip", nothing), 0) + skip = _t2217 + _t2218 = _extract_value_string(parser, get(config, "csv_new_line", nothing), "") + new_line = _t2218 + _t2219 = _extract_value_string(parser, get(config, "csv_delimiter", nothing), ",") + delimiter = _t2219 + _t2220 = _extract_value_string(parser, get(config, "csv_quotechar", nothing), "\"") + quotechar = _t2220 + _t2221 = _extract_value_string(parser, get(config, "csv_escapechar", nothing), "\"") + escapechar = _t2221 + _t2222 = _extract_value_string(parser, get(config, "csv_comment", nothing), "") + comment = _t2222 + _t2223 = _extract_value_string_list(parser, get(config, "csv_missing_strings", nothing), String[]) + missing_strings = _t2223 + _t2224 = _extract_value_string(parser, get(config, "csv_decimal_separator", nothing), ".") + decimal_separator = _t2224 + _t2225 = _extract_value_string(parser, get(config, "csv_encoding", nothing), "utf-8") + encoding = _t2225 + _t2226 = _extract_value_string(parser, get(config, "csv_compression", nothing), "") + compression = _t2226 + _t2227 = _extract_value_int64(parser, get(config, "csv_partition_size_mb", nothing), 0) + partition_size_mb = _t2227 + _t2228 = construct_csv_storage_integration(parser, storage_integration_opt) + storage_integration = _t2228 + _t2229 = 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 _t2229 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 - _t2218 = nothing + _t2230 = nothing end config = Dict(storage_integration_opt) - _t2219 = _extract_value_string(parser, get(config, "provider", nothing), "") - _t2220 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") - _t2221 = _extract_value_string(parser, get(config, "s3_region", nothing), "") - _t2222 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") - _t2223 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") - _t2224 = Proto.StorageIntegration(provider=_t2219, azure_sas_token=_t2220, s3_region=_t2221, s3_access_key_id=_t2222, s3_secret_access_key=_t2223) - return _t2224 + _t2231 = _extract_value_string(parser, get(config, "provider", nothing), "") + _t2232 = _extract_value_string(parser, get(config, "azure_sas_token", nothing), "") + _t2233 = _extract_value_string(parser, get(config, "s3_region", nothing), "") + _t2234 = _extract_value_string(parser, get(config, "s3_access_key_id", nothing), "") + _t2235 = _extract_value_string(parser, get(config, "s3_secret_access_key", nothing), "") + _t2236 = Proto.StorageIntegration(provider=_t2231, azure_sas_token=_t2232, s3_region=_t2233, s3_access_key_id=_t2234, s3_secret_access_key=_t2235) + return _t2236 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) - _t2225 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) - epsilon = _t2225 - _t2226 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) - max_pivots = _t2226 - _t2227 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) - max_deltas = _t2227 - _t2228 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) - max_leaf = _t2228 - _t2229 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) - storage_config = _t2229 - _t2230 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) - root_pageid = _t2230 - _t2231 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) - inline_data = _t2231 - _t2232 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) - element_count = _t2232 - _t2233 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) - tree_height = _t2233 - _t2234 = 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 = _t2234 - _t2235 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) - return _t2235 + _t2237 = _try_extract_value_float64(parser, get(config, "betree_config_epsilon", nothing)) + epsilon = _t2237 + _t2238 = _try_extract_value_int64(parser, get(config, "betree_config_max_pivots", nothing)) + max_pivots = _t2238 + _t2239 = _try_extract_value_int64(parser, get(config, "betree_config_max_deltas", nothing)) + max_deltas = _t2239 + _t2240 = _try_extract_value_int64(parser, get(config, "betree_config_max_leaf", nothing)) + max_leaf = _t2240 + _t2241 = Proto.BeTreeConfig(epsilon=epsilon, max_pivots=max_pivots, max_deltas=max_deltas, max_leaf=max_leaf) + storage_config = _t2241 + _t2242 = _try_extract_value_uint128(parser, get(config, "betree_locator_root_pageid", nothing)) + root_pageid = _t2242 + _t2243 = _try_extract_value_bytes(parser, get(config, "betree_locator_inline_data", nothing)) + inline_data = _t2243 + _t2244 = _try_extract_value_int64(parser, get(config, "betree_locator_element_count", nothing)) + element_count = _t2244 + _t2245 = _try_extract_value_int64(parser, get(config, "betree_locator_tree_height", nothing)) + tree_height = _t2245 + _t2246 = 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 = _t2246 + _t2247 = Proto.BeTreeInfo(key_types=key_types, value_types=value_types, storage_config=storage_config, relation_locator=relation_locator) + return _t2247 end function default_configure(parser::ParserState)::Proto.Configure - _t2236 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) - ivm_config = _t2236 - _t2237 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) - return _t2237 + _t2248 = Proto.IVMConfig(level=Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF) + ivm_config = _t2248 + _t2249 = Proto.Configure(semantics_version=0, ivm_config=ivm_config) + return _t2249 end function construct_configure(parser::ParserState, config_dict::Vector{Tuple{String, Proto.Value}})::Proto.Configure @@ -577,4020 +577,4059 @@ function construct_configure(parser::ParserState, config_dict::Vector{Tuple{Stri end end end - _t2238 = Proto.IVMConfig(level=maintenance_level) - ivm_config = _t2238 - _t2239 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) - semantics_version = _t2239 - _t2240 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) - return _t2240 + _t2250 = Proto.IVMConfig(level=maintenance_level) + ivm_config = _t2250 + _t2251 = _extract_value_int64(parser, get(config, "semantics_version", nothing), 0) + semantics_version = _t2251 + _t2252 = Proto.Configure(semantics_version=semantics_version, ivm_config=ivm_config) + return _t2252 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) - _t2241 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) - partition_size = _t2241 - _t2242 = _extract_value_string(parser, get(config, "compression", nothing), "") - compression = _t2242 - _t2243 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) - syntax_header_row = _t2243 - _t2244 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") - syntax_missing_string = _t2244 - _t2245 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") - syntax_delim = _t2245 - _t2246 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") - syntax_quotechar = _t2246 - _t2247 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") - syntax_escapechar = _t2247 - _t2248 = 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 _t2248 -end - -function construct_export_csv_config_with_source(parser::ParserState, path::String, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig - _t2249 = Proto.ExportCSVConfig(path=path, csv_source=csv_source, csv_config=csv_config) - return _t2249 + _t2253 = _extract_value_int64(parser, get(config, "partition_size", nothing), 0) + partition_size = _t2253 + _t2254 = _extract_value_string(parser, get(config, "compression", nothing), "") + compression = _t2254 + _t2255 = _extract_value_boolean(parser, get(config, "syntax_header_row", nothing), true) + syntax_header_row = _t2255 + _t2256 = _extract_value_string(parser, get(config, "syntax_missing_string", nothing), "") + syntax_missing_string = _t2256 + _t2257 = _extract_value_string(parser, get(config, "syntax_delim", nothing), ",") + syntax_delim = _t2257 + _t2258 = _extract_value_string(parser, get(config, "syntax_quotechar", nothing), "\"") + syntax_quotechar = _t2258 + _t2259 = _extract_value_string(parser, get(config, "syntax_escapechar", nothing), "\\") + syntax_escapechar = _t2259 + _t2260 = 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 _t2260 +end + +function construct_export_csv_config_with_location(parser::ParserState, location::Tuple{String, String}, csv_source::Proto.ExportCSVSource, csv_config::Proto.CSVConfig)::Proto.ExportCSVConfig + _t2261 = Proto.ExportCSVConfig(path=location[1], transaction_output_name=location[2], csv_source=csv_source, csv_config=csv_config) + return _t2261 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) - _t2250 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) - return _t2250 + _t2262 = Proto.IcebergCatalogConfig(catalog_uri=catalog_uri, scope=(!isnothing(scope_opt) ? scope_opt : ""), properties=props, auth_properties=auth_props) + return _t2262 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 - _t2251 = 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 _t2251 + _t2263 = 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 _t2263 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}[])) - _t2252 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") - prefix = _t2252 - _t2253 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) - target_file_size_bytes = _t2253 - _t2254 = _extract_value_string(parser, get(cfg, "compression", nothing), "") - compression = _t2254 + _t2264 = _extract_value_string(parser, get(cfg, "prefix", nothing), "") + prefix = _t2264 + _t2265 = _extract_value_int64(parser, get(cfg, "target_file_size_bytes", nothing), 0) + target_file_size_bytes = _t2265 + _t2266 = _extract_value_string(parser, get(cfg, "compression", nothing), "") + compression = _t2266 table_props = Dict(table_property_pairs) - _t2255 = 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 _t2255 + _t2267 = 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 _t2267 end # --- Parse functions --- function parse_transaction(parser::ParserState)::Proto.Transaction - span_start710 = span_start(parser) + span_start713 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "transaction") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "configure", 1)) - _t1409 = parse_configure(parser) - _t1408 = _t1409 + _t1415 = parse_configure(parser) + _t1414 = _t1415 else - _t1408 = nothing + _t1414 = nothing end - configure704 = _t1408 + configure707 = _t1414 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "sync", 1)) - _t1411 = parse_sync(parser) - _t1410 = _t1411 + _t1417 = parse_sync(parser) + _t1416 = _t1417 else - _t1410 = nothing - end - sync705 = _t1410 - xs706 = Proto.Epoch[] - cond707 = match_lookahead_literal(parser, "(", 0) - while cond707 - _t1412 = parse_epoch(parser) - item708 = _t1412 - push!(xs706, item708) - cond707 = match_lookahead_literal(parser, "(", 0) - end - epochs709 = xs706 + _t1416 = nothing + end + sync708 = _t1416 + xs709 = Proto.Epoch[] + cond710 = match_lookahead_literal(parser, "(", 0) + while cond710 + _t1418 = parse_epoch(parser) + item711 = _t1418 + push!(xs709, item711) + cond710 = match_lookahead_literal(parser, "(", 0) + end + epochs712 = xs709 consume_literal!(parser, ")") - _t1413 = default_configure(parser) - _t1414 = Proto.Transaction(epochs=epochs709, configure=(!isnothing(configure704) ? configure704 : _t1413), sync=sync705) - result711 = _t1414 - record_span!(parser, span_start710, "Transaction") - return result711 + _t1419 = default_configure(parser) + _t1420 = Proto.Transaction(epochs=epochs712, configure=(!isnothing(configure707) ? configure707 : _t1419), sync=sync708) + result714 = _t1420 + record_span!(parser, span_start713, "Transaction") + return result714 end function parse_configure(parser::ParserState)::Proto.Configure - span_start713 = span_start(parser) + span_start716 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "configure") - _t1415 = parse_config_dict(parser) - config_dict712 = _t1415 + _t1421 = parse_config_dict(parser) + config_dict715 = _t1421 consume_literal!(parser, ")") - _t1416 = construct_configure(parser, config_dict712) - result714 = _t1416 - record_span!(parser, span_start713, "Configure") - return result714 + _t1422 = construct_configure(parser, config_dict715) + result717 = _t1422 + record_span!(parser, span_start716, "Configure") + return result717 end function parse_config_dict(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "{") - xs715 = Tuple{String, Proto.Value}[] - cond716 = match_lookahead_literal(parser, ":", 0) - while cond716 - _t1417 = parse_config_key_value(parser) - item717 = _t1417 - push!(xs715, item717) - cond716 = match_lookahead_literal(parser, ":", 0) - end - config_key_values718 = xs715 + xs718 = Tuple{String, Proto.Value}[] + cond719 = match_lookahead_literal(parser, ":", 0) + while cond719 + _t1423 = parse_config_key_value(parser) + item720 = _t1423 + push!(xs718, item720) + cond719 = match_lookahead_literal(parser, ":", 0) + end + config_key_values721 = xs718 consume_literal!(parser, "}") - return config_key_values718 + return config_key_values721 end function parse_config_key_value(parser::ParserState)::Tuple{String, Proto.Value} consume_literal!(parser, ":") - symbol719 = consume_terminal!(parser, "SYMBOL") - _t1418 = parse_raw_value(parser) - raw_value720 = _t1418 - return (symbol719, raw_value720,) + symbol722 = consume_terminal!(parser, "SYMBOL") + _t1424 = parse_raw_value(parser) + raw_value723 = _t1424 + return (symbol722, raw_value723,) end function parse_raw_value(parser::ParserState)::Proto.Value - span_start734 = span_start(parser) + span_start737 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1419 = 12 + _t1425 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1420 = 11 + _t1426 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1421 = 12 + _t1427 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1423 = 1 + _t1429 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1424 = 0 + _t1430 = 0 else - _t1424 = -1 + _t1430 = -1 end - _t1423 = _t1424 + _t1429 = _t1430 end - _t1422 = _t1423 + _t1428 = _t1429 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1425 = 7 + _t1431 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1426 = 8 + _t1432 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1427 = 2 + _t1433 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1428 = 3 + _t1434 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1429 = 9 + _t1435 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1430 = 4 + _t1436 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1431 = 5 + _t1437 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1432 = 6 + _t1438 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1433 = 10 + _t1439 = 10 else - _t1433 = -1 + _t1439 = -1 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 end - _t1426 = _t1427 + _t1432 = _t1433 end - _t1425 = _t1426 + _t1431 = _t1432 end - _t1422 = _t1425 + _t1428 = _t1431 end - _t1421 = _t1422 + _t1427 = _t1428 end - _t1420 = _t1421 + _t1426 = _t1427 end - _t1419 = _t1420 - end - prediction721 = _t1419 - if prediction721 == 12 - _t1435 = parse_boolean_value(parser) - boolean_value733 = _t1435 - _t1436 = Proto.Value(value=OneOf(:boolean_value, boolean_value733)) - _t1434 = _t1436 + _t1425 = _t1426 + end + prediction724 = _t1425 + if prediction724 == 12 + _t1441 = parse_boolean_value(parser) + boolean_value736 = _t1441 + _t1442 = Proto.Value(value=OneOf(:boolean_value, boolean_value736)) + _t1440 = _t1442 else - if prediction721 == 11 + if prediction724 == 11 consume_literal!(parser, "missing") - _t1438 = Proto.MissingValue() - _t1439 = Proto.Value(value=OneOf(:missing_value, _t1438)) - _t1437 = _t1439 + _t1444 = Proto.MissingValue() + _t1445 = Proto.Value(value=OneOf(:missing_value, _t1444)) + _t1443 = _t1445 else - if prediction721 == 10 - decimal732 = consume_terminal!(parser, "DECIMAL") - _t1441 = Proto.Value(value=OneOf(:decimal_value, decimal732)) - _t1440 = _t1441 + if prediction724 == 10 + decimal735 = consume_terminal!(parser, "DECIMAL") + _t1447 = Proto.Value(value=OneOf(:decimal_value, decimal735)) + _t1446 = _t1447 else - if prediction721 == 9 - int128731 = consume_terminal!(parser, "INT128") - _t1443 = Proto.Value(value=OneOf(:int128_value, int128731)) - _t1442 = _t1443 + if prediction724 == 9 + int128734 = consume_terminal!(parser, "INT128") + _t1449 = Proto.Value(value=OneOf(:int128_value, int128734)) + _t1448 = _t1449 else - if prediction721 == 8 - uint128730 = consume_terminal!(parser, "UINT128") - _t1445 = Proto.Value(value=OneOf(:uint128_value, uint128730)) - _t1444 = _t1445 + if prediction724 == 8 + uint128733 = consume_terminal!(parser, "UINT128") + _t1451 = Proto.Value(value=OneOf(:uint128_value, uint128733)) + _t1450 = _t1451 else - if prediction721 == 7 - uint32729 = consume_terminal!(parser, "UINT32") - _t1447 = Proto.Value(value=OneOf(:uint32_value, uint32729)) - _t1446 = _t1447 + if prediction724 == 7 + uint32732 = consume_terminal!(parser, "UINT32") + _t1453 = Proto.Value(value=OneOf(:uint32_value, uint32732)) + _t1452 = _t1453 else - if prediction721 == 6 - float728 = consume_terminal!(parser, "FLOAT") - _t1449 = Proto.Value(value=OneOf(:float_value, float728)) - _t1448 = _t1449 + if prediction724 == 6 + float731 = consume_terminal!(parser, "FLOAT") + _t1455 = Proto.Value(value=OneOf(:float_value, float731)) + _t1454 = _t1455 else - if prediction721 == 5 - float32727 = consume_terminal!(parser, "FLOAT32") - _t1451 = Proto.Value(value=OneOf(:float32_value, float32727)) - _t1450 = _t1451 + if prediction724 == 5 + float32730 = consume_terminal!(parser, "FLOAT32") + _t1457 = Proto.Value(value=OneOf(:float32_value, float32730)) + _t1456 = _t1457 else - if prediction721 == 4 - int726 = consume_terminal!(parser, "INT") - _t1453 = Proto.Value(value=OneOf(:int_value, int726)) - _t1452 = _t1453 + if prediction724 == 4 + int729 = consume_terminal!(parser, "INT") + _t1459 = Proto.Value(value=OneOf(:int_value, int729)) + _t1458 = _t1459 else - if prediction721 == 3 - int32725 = consume_terminal!(parser, "INT32") - _t1455 = Proto.Value(value=OneOf(:int32_value, int32725)) - _t1454 = _t1455 + if prediction724 == 3 + int32728 = consume_terminal!(parser, "INT32") + _t1461 = Proto.Value(value=OneOf(:int32_value, int32728)) + _t1460 = _t1461 else - if prediction721 == 2 - string724 = consume_terminal!(parser, "STRING") - _t1457 = Proto.Value(value=OneOf(:string_value, string724)) - _t1456 = _t1457 + if prediction724 == 2 + string727 = consume_terminal!(parser, "STRING") + _t1463 = Proto.Value(value=OneOf(:string_value, string727)) + _t1462 = _t1463 else - if prediction721 == 1 - _t1459 = parse_raw_datetime(parser) - raw_datetime723 = _t1459 - _t1460 = Proto.Value(value=OneOf(:datetime_value, raw_datetime723)) - _t1458 = _t1460 + if prediction724 == 1 + _t1465 = parse_raw_datetime(parser) + raw_datetime726 = _t1465 + _t1466 = Proto.Value(value=OneOf(:datetime_value, raw_datetime726)) + _t1464 = _t1466 else - if prediction721 == 0 - _t1462 = parse_raw_date(parser) - raw_date722 = _t1462 - _t1463 = Proto.Value(value=OneOf(:date_value, raw_date722)) - _t1461 = _t1463 + if prediction724 == 0 + _t1468 = parse_raw_date(parser) + raw_date725 = _t1468 + _t1469 = Proto.Value(value=OneOf(:date_value, raw_date725)) + _t1467 = _t1469 else throw(ParseError("Unexpected token in raw_value" * ": " * string(lookahead(parser, 0)))) end - _t1458 = _t1461 + _t1464 = _t1467 end - _t1456 = _t1458 + _t1462 = _t1464 end - _t1454 = _t1456 + _t1460 = _t1462 end - _t1452 = _t1454 + _t1458 = _t1460 end - _t1450 = _t1452 + _t1456 = _t1458 end - _t1448 = _t1450 + _t1454 = _t1456 end - _t1446 = _t1448 + _t1452 = _t1454 end - _t1444 = _t1446 + _t1450 = _t1452 end - _t1442 = _t1444 + _t1448 = _t1450 end - _t1440 = _t1442 + _t1446 = _t1448 end - _t1437 = _t1440 + _t1443 = _t1446 end - _t1434 = _t1437 + _t1440 = _t1443 end - result735 = _t1434 - record_span!(parser, span_start734, "Value") - return result735 + result738 = _t1440 + record_span!(parser, span_start737, "Value") + return result738 end function parse_raw_date(parser::ParserState)::Proto.DateValue - span_start739 = span_start(parser) + span_start742 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - int736 = consume_terminal!(parser, "INT") - int_3737 = consume_terminal!(parser, "INT") - int_4738 = consume_terminal!(parser, "INT") + int739 = consume_terminal!(parser, "INT") + int_3740 = consume_terminal!(parser, "INT") + int_4741 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1464 = Proto.DateValue(year=Int32(int736), month=Int32(int_3737), day=Int32(int_4738)) - result740 = _t1464 - record_span!(parser, span_start739, "DateValue") - return result740 + _t1470 = Proto.DateValue(year=Int32(int739), month=Int32(int_3740), day=Int32(int_4741)) + result743 = _t1470 + record_span!(parser, span_start742, "DateValue") + return result743 end function parse_raw_datetime(parser::ParserState)::Proto.DateTimeValue - span_start748 = span_start(parser) + span_start751 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - int741 = consume_terminal!(parser, "INT") - int_3742 = consume_terminal!(parser, "INT") - int_4743 = consume_terminal!(parser, "INT") - int_5744 = consume_terminal!(parser, "INT") - int_6745 = consume_terminal!(parser, "INT") - int_7746 = consume_terminal!(parser, "INT") + int744 = consume_terminal!(parser, "INT") + int_3745 = consume_terminal!(parser, "INT") + int_4746 = consume_terminal!(parser, "INT") + int_5747 = consume_terminal!(parser, "INT") + int_6748 = consume_terminal!(parser, "INT") + int_7749 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1465 = consume_terminal!(parser, "INT") + _t1471 = consume_terminal!(parser, "INT") else - _t1465 = nothing + _t1471 = nothing end - int_8747 = _t1465 + int_8750 = _t1471 consume_literal!(parser, ")") - _t1466 = Proto.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((!isnothing(int_8747) ? int_8747 : 0))) - result749 = _t1466 - record_span!(parser, span_start748, "DateTimeValue") - return result749 + _t1472 = Proto.DateTimeValue(year=Int32(int744), month=Int32(int_3745), day=Int32(int_4746), hour=Int32(int_5747), minute=Int32(int_6748), second=Int32(int_7749), microsecond=Int32((!isnothing(int_8750) ? int_8750 : 0))) + result752 = _t1472 + record_span!(parser, span_start751, "DateTimeValue") + return result752 end function parse_boolean_value(parser::ParserState)::Bool if match_lookahead_literal(parser, "true", 0) - _t1467 = 0 + _t1473 = 0 else if match_lookahead_literal(parser, "false", 0) - _t1468 = 1 + _t1474 = 1 else - _t1468 = -1 + _t1474 = -1 end - _t1467 = _t1468 + _t1473 = _t1474 end - prediction750 = _t1467 - if prediction750 == 1 + prediction753 = _t1473 + if prediction753 == 1 consume_literal!(parser, "false") - _t1469 = false + _t1475 = false else - if prediction750 == 0 + if prediction753 == 0 consume_literal!(parser, "true") - _t1470 = true + _t1476 = true else throw(ParseError("Unexpected token in boolean_value" * ": " * string(lookahead(parser, 0)))) end - _t1469 = _t1470 + _t1475 = _t1476 end - return _t1469 + return _t1475 end function parse_sync(parser::ParserState)::Proto.Sync - span_start755 = span_start(parser) + span_start758 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sync") - xs751 = Proto.FragmentId[] - cond752 = match_lookahead_literal(parser, ":", 0) - while cond752 - _t1471 = parse_fragment_id(parser) - item753 = _t1471 - push!(xs751, item753) - cond752 = match_lookahead_literal(parser, ":", 0) - end - fragment_ids754 = xs751 + xs754 = Proto.FragmentId[] + cond755 = match_lookahead_literal(parser, ":", 0) + while cond755 + _t1477 = parse_fragment_id(parser) + item756 = _t1477 + push!(xs754, item756) + cond755 = match_lookahead_literal(parser, ":", 0) + end + fragment_ids757 = xs754 consume_literal!(parser, ")") - _t1472 = Proto.Sync(fragments=fragment_ids754) - result756 = _t1472 - record_span!(parser, span_start755, "Sync") - return result756 + _t1478 = Proto.Sync(fragments=fragment_ids757) + result759 = _t1478 + record_span!(parser, span_start758, "Sync") + return result759 end function parse_fragment_id(parser::ParserState)::Proto.FragmentId - span_start758 = span_start(parser) + span_start761 = span_start(parser) consume_literal!(parser, ":") - symbol757 = consume_terminal!(parser, "SYMBOL") - result759 = Proto.FragmentId(Vector{UInt8}(symbol757)) - record_span!(parser, span_start758, "FragmentId") - return result759 + symbol760 = consume_terminal!(parser, "SYMBOL") + result762 = Proto.FragmentId(Vector{UInt8}(symbol760)) + record_span!(parser, span_start761, "FragmentId") + return result762 end function parse_epoch(parser::ParserState)::Proto.Epoch - span_start762 = span_start(parser) + span_start765 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "epoch") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "writes", 1)) - _t1474 = parse_epoch_writes(parser) - _t1473 = _t1474 + _t1480 = parse_epoch_writes(parser) + _t1479 = _t1480 else - _t1473 = nothing + _t1479 = nothing end - epoch_writes760 = _t1473 + epoch_writes763 = _t1479 if match_lookahead_literal(parser, "(", 0) - _t1476 = parse_epoch_reads(parser) - _t1475 = _t1476 + _t1482 = parse_epoch_reads(parser) + _t1481 = _t1482 else - _t1475 = nothing + _t1481 = nothing end - epoch_reads761 = _t1475 + epoch_reads764 = _t1481 consume_literal!(parser, ")") - _t1477 = Proto.Epoch(writes=(!isnothing(epoch_writes760) ? epoch_writes760 : Proto.Write[]), reads=(!isnothing(epoch_reads761) ? epoch_reads761 : Proto.Read[])) - result763 = _t1477 - record_span!(parser, span_start762, "Epoch") - return result763 + _t1483 = Proto.Epoch(writes=(!isnothing(epoch_writes763) ? epoch_writes763 : Proto.Write[]), reads=(!isnothing(epoch_reads764) ? epoch_reads764 : Proto.Read[])) + result766 = _t1483 + record_span!(parser, span_start765, "Epoch") + return result766 end function parse_epoch_writes(parser::ParserState)::Vector{Proto.Write} consume_literal!(parser, "(") consume_literal!(parser, "writes") - xs764 = Proto.Write[] - cond765 = match_lookahead_literal(parser, "(", 0) - while cond765 - _t1478 = parse_write(parser) - item766 = _t1478 - push!(xs764, item766) - cond765 = match_lookahead_literal(parser, "(", 0) - end - writes767 = xs764 + xs767 = Proto.Write[] + cond768 = match_lookahead_literal(parser, "(", 0) + while cond768 + _t1484 = parse_write(parser) + item769 = _t1484 + push!(xs767, item769) + cond768 = match_lookahead_literal(parser, "(", 0) + end + writes770 = xs767 consume_literal!(parser, ")") - return writes767 + return writes770 end function parse_write(parser::ParserState)::Proto.Write - span_start773 = span_start(parser) + span_start776 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "undefine", 1) - _t1480 = 1 + _t1486 = 1 else if match_lookahead_literal(parser, "snapshot", 1) - _t1481 = 3 + _t1487 = 3 else if match_lookahead_literal(parser, "define", 1) - _t1482 = 0 + _t1488 = 0 else if match_lookahead_literal(parser, "context", 1) - _t1483 = 2 + _t1489 = 2 else - _t1483 = -1 + _t1489 = -1 end - _t1482 = _t1483 + _t1488 = _t1489 end - _t1481 = _t1482 + _t1487 = _t1488 end - _t1480 = _t1481 + _t1486 = _t1487 end - _t1479 = _t1480 + _t1485 = _t1486 else - _t1479 = -1 - end - prediction768 = _t1479 - if prediction768 == 3 - _t1485 = parse_snapshot(parser) - snapshot772 = _t1485 - _t1486 = Proto.Write(write_type=OneOf(:snapshot, snapshot772)) - _t1484 = _t1486 + _t1485 = -1 + end + prediction771 = _t1485 + if prediction771 == 3 + _t1491 = parse_snapshot(parser) + snapshot775 = _t1491 + _t1492 = Proto.Write(write_type=OneOf(:snapshot, snapshot775)) + _t1490 = _t1492 else - if prediction768 == 2 - _t1488 = parse_context(parser) - context771 = _t1488 - _t1489 = Proto.Write(write_type=OneOf(:context, context771)) - _t1487 = _t1489 + if prediction771 == 2 + _t1494 = parse_context(parser) + context774 = _t1494 + _t1495 = Proto.Write(write_type=OneOf(:context, context774)) + _t1493 = _t1495 else - if prediction768 == 1 - _t1491 = parse_undefine(parser) - undefine770 = _t1491 - _t1492 = Proto.Write(write_type=OneOf(:undefine, undefine770)) - _t1490 = _t1492 + if prediction771 == 1 + _t1497 = parse_undefine(parser) + undefine773 = _t1497 + _t1498 = Proto.Write(write_type=OneOf(:undefine, undefine773)) + _t1496 = _t1498 else - if prediction768 == 0 - _t1494 = parse_define(parser) - define769 = _t1494 - _t1495 = Proto.Write(write_type=OneOf(:define, define769)) - _t1493 = _t1495 + if prediction771 == 0 + _t1500 = parse_define(parser) + define772 = _t1500 + _t1501 = Proto.Write(write_type=OneOf(:define, define772)) + _t1499 = _t1501 else throw(ParseError("Unexpected token in write" * ": " * string(lookahead(parser, 0)))) end - _t1490 = _t1493 + _t1496 = _t1499 end - _t1487 = _t1490 + _t1493 = _t1496 end - _t1484 = _t1487 + _t1490 = _t1493 end - result774 = _t1484 - record_span!(parser, span_start773, "Write") - return result774 + result777 = _t1490 + record_span!(parser, span_start776, "Write") + return result777 end function parse_define(parser::ParserState)::Proto.Define - span_start776 = span_start(parser) + span_start779 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "define") - _t1496 = parse_fragment(parser) - fragment775 = _t1496 + _t1502 = parse_fragment(parser) + fragment778 = _t1502 consume_literal!(parser, ")") - _t1497 = Proto.Define(fragment=fragment775) - result777 = _t1497 - record_span!(parser, span_start776, "Define") - return result777 + _t1503 = Proto.Define(fragment=fragment778) + result780 = _t1503 + record_span!(parser, span_start779, "Define") + return result780 end function parse_fragment(parser::ParserState)::Proto.Fragment - span_start783 = span_start(parser) + span_start786 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "fragment") - _t1498 = parse_new_fragment_id(parser) - new_fragment_id778 = _t1498 - xs779 = Proto.Declaration[] - cond780 = match_lookahead_literal(parser, "(", 0) - while cond780 - _t1499 = parse_declaration(parser) - item781 = _t1499 - push!(xs779, item781) - cond780 = match_lookahead_literal(parser, "(", 0) - end - declarations782 = xs779 + _t1504 = parse_new_fragment_id(parser) + new_fragment_id781 = _t1504 + xs782 = Proto.Declaration[] + cond783 = match_lookahead_literal(parser, "(", 0) + while cond783 + _t1505 = parse_declaration(parser) + item784 = _t1505 + push!(xs782, item784) + cond783 = match_lookahead_literal(parser, "(", 0) + end + declarations785 = xs782 consume_literal!(parser, ")") - result784 = construct_fragment(parser, new_fragment_id778, declarations782) - record_span!(parser, span_start783, "Fragment") - return result784 + result787 = construct_fragment(parser, new_fragment_id781, declarations785) + record_span!(parser, span_start786, "Fragment") + return result787 end function parse_new_fragment_id(parser::ParserState)::Proto.FragmentId - span_start786 = span_start(parser) - _t1500 = parse_fragment_id(parser) - fragment_id785 = _t1500 - start_fragment!(parser, fragment_id785) - result787 = fragment_id785 - record_span!(parser, span_start786, "FragmentId") - return result787 + span_start789 = span_start(parser) + _t1506 = parse_fragment_id(parser) + fragment_id788 = _t1506 + start_fragment!(parser, fragment_id788) + result790 = fragment_id788 + record_span!(parser, span_start789, "FragmentId") + return result790 end function parse_declaration(parser::ParserState)::Proto.Declaration - span_start793 = span_start(parser) + span_start796 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1502 = 3 + _t1508 = 3 else if match_lookahead_literal(parser, "functional_dependency", 1) - _t1503 = 2 + _t1509 = 2 else if match_lookahead_literal(parser, "edb", 1) - _t1504 = 3 + _t1510 = 3 else if match_lookahead_literal(parser, "def", 1) - _t1505 = 0 + _t1511 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1506 = 3 + _t1512 = 3 else if match_lookahead_literal(parser, "betree_relation", 1) - _t1507 = 3 + _t1513 = 3 else if match_lookahead_literal(parser, "algorithm", 1) - _t1508 = 1 + _t1514 = 1 else - _t1508 = -1 + _t1514 = -1 end - _t1507 = _t1508 + _t1513 = _t1514 end - _t1506 = _t1507 + _t1512 = _t1513 end - _t1505 = _t1506 + _t1511 = _t1512 end - _t1504 = _t1505 + _t1510 = _t1511 end - _t1503 = _t1504 + _t1509 = _t1510 end - _t1502 = _t1503 + _t1508 = _t1509 end - _t1501 = _t1502 + _t1507 = _t1508 else - _t1501 = -1 - end - prediction788 = _t1501 - if prediction788 == 3 - _t1510 = parse_data(parser) - data792 = _t1510 - _t1511 = Proto.Declaration(declaration_type=OneOf(:data, data792)) - _t1509 = _t1511 + _t1507 = -1 + end + prediction791 = _t1507 + if prediction791 == 3 + _t1516 = parse_data(parser) + data795 = _t1516 + _t1517 = Proto.Declaration(declaration_type=OneOf(:data, data795)) + _t1515 = _t1517 else - if prediction788 == 2 - _t1513 = parse_constraint(parser) - constraint791 = _t1513 - _t1514 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint791)) - _t1512 = _t1514 + if prediction791 == 2 + _t1519 = parse_constraint(parser) + constraint794 = _t1519 + _t1520 = Proto.Declaration(declaration_type=OneOf(:constraint, constraint794)) + _t1518 = _t1520 else - if prediction788 == 1 - _t1516 = parse_algorithm(parser) - algorithm790 = _t1516 - _t1517 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm790)) - _t1515 = _t1517 + if prediction791 == 1 + _t1522 = parse_algorithm(parser) + algorithm793 = _t1522 + _t1523 = Proto.Declaration(declaration_type=OneOf(:algorithm, algorithm793)) + _t1521 = _t1523 else - if prediction788 == 0 - _t1519 = parse_def(parser) - def789 = _t1519 - _t1520 = Proto.Declaration(declaration_type=OneOf(:def, def789)) - _t1518 = _t1520 + if prediction791 == 0 + _t1525 = parse_def(parser) + def792 = _t1525 + _t1526 = Proto.Declaration(declaration_type=OneOf(:def, def792)) + _t1524 = _t1526 else throw(ParseError("Unexpected token in declaration" * ": " * string(lookahead(parser, 0)))) end - _t1515 = _t1518 + _t1521 = _t1524 end - _t1512 = _t1515 + _t1518 = _t1521 end - _t1509 = _t1512 + _t1515 = _t1518 end - result794 = _t1509 - record_span!(parser, span_start793, "Declaration") - return result794 + result797 = _t1515 + record_span!(parser, span_start796, "Declaration") + return result797 end function parse_def(parser::ParserState)::Proto.Def - span_start798 = span_start(parser) + span_start801 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "def") - _t1521 = parse_relation_id(parser) - relation_id795 = _t1521 - _t1522 = parse_abstraction(parser) - abstraction796 = _t1522 + _t1527 = parse_relation_id(parser) + relation_id798 = _t1527 + _t1528 = parse_abstraction(parser) + abstraction799 = _t1528 if match_lookahead_literal(parser, "(", 0) - _t1524 = parse_attrs(parser) - _t1523 = _t1524 + _t1530 = parse_attrs(parser) + _t1529 = _t1530 else - _t1523 = nothing + _t1529 = nothing end - attrs797 = _t1523 + attrs800 = _t1529 consume_literal!(parser, ")") - _t1525 = Proto.Def(name=relation_id795, body=abstraction796, attrs=(!isnothing(attrs797) ? attrs797 : Proto.Attribute[])) - result799 = _t1525 - record_span!(parser, span_start798, "Def") - return result799 + _t1531 = Proto.Def(name=relation_id798, body=abstraction799, attrs=(!isnothing(attrs800) ? attrs800 : Proto.Attribute[])) + result802 = _t1531 + record_span!(parser, span_start801, "Def") + return result802 end function parse_relation_id(parser::ParserState)::Proto.RelationId - span_start803 = span_start(parser) + span_start806 = span_start(parser) if match_lookahead_literal(parser, ":", 0) - _t1526 = 0 + _t1532 = 0 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1527 = 1 + _t1533 = 1 else - _t1527 = -1 + _t1533 = -1 end - _t1526 = _t1527 + _t1532 = _t1533 end - prediction800 = _t1526 - if prediction800 == 1 - uint128802 = consume_terminal!(parser, "UINT128") - _t1528 = Proto.RelationId(uint128802.low, uint128802.high) + prediction803 = _t1532 + if prediction803 == 1 + uint128805 = consume_terminal!(parser, "UINT128") + _t1534 = Proto.RelationId(uint128805.low, uint128805.high) else - if prediction800 == 0 + if prediction803 == 0 consume_literal!(parser, ":") - symbol801 = consume_terminal!(parser, "SYMBOL") - _t1529 = relation_id_from_string(parser, symbol801) + symbol804 = consume_terminal!(parser, "SYMBOL") + _t1535 = relation_id_from_string(parser, symbol804) else throw(ParseError("Unexpected token in relation_id" * ": " * string(lookahead(parser, 0)))) end - _t1528 = _t1529 + _t1534 = _t1535 end - result804 = _t1528 - record_span!(parser, span_start803, "RelationId") - return result804 + result807 = _t1534 + record_span!(parser, span_start806, "RelationId") + return result807 end function parse_abstraction(parser::ParserState)::Proto.Abstraction - span_start807 = span_start(parser) + span_start810 = span_start(parser) consume_literal!(parser, "(") - _t1530 = parse_bindings(parser) - bindings805 = _t1530 - _t1531 = parse_formula(parser) - formula806 = _t1531 + _t1536 = parse_bindings(parser) + bindings808 = _t1536 + _t1537 = parse_formula(parser) + formula809 = _t1537 consume_literal!(parser, ")") - _t1532 = Proto.Abstraction(vars=vcat(bindings805[1], !isnothing(bindings805[2]) ? bindings805[2] : []), value=formula806) - result808 = _t1532 - record_span!(parser, span_start807, "Abstraction") - return result808 + _t1538 = Proto.Abstraction(vars=vcat(bindings808[1], !isnothing(bindings808[2]) ? bindings808[2] : []), value=formula809) + result811 = _t1538 + record_span!(parser, span_start810, "Abstraction") + return result811 end function parse_bindings(parser::ParserState)::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}} consume_literal!(parser, "[") - xs809 = Proto.Binding[] - cond810 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond810 - _t1533 = parse_binding(parser) - item811 = _t1533 - push!(xs809, item811) - cond810 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - bindings812 = xs809 + xs812 = Proto.Binding[] + cond813 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond813 + _t1539 = parse_binding(parser) + item814 = _t1539 + push!(xs812, item814) + cond813 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + bindings815 = xs812 if match_lookahead_literal(parser, "|", 0) - _t1535 = parse_value_bindings(parser) - _t1534 = _t1535 + _t1541 = parse_value_bindings(parser) + _t1540 = _t1541 else - _t1534 = nothing + _t1540 = nothing end - value_bindings813 = _t1534 + value_bindings816 = _t1540 consume_literal!(parser, "]") - return (bindings812, (!isnothing(value_bindings813) ? value_bindings813 : Proto.Binding[]),) + return (bindings815, (!isnothing(value_bindings816) ? value_bindings816 : Proto.Binding[]),) end function parse_binding(parser::ParserState)::Proto.Binding - span_start816 = span_start(parser) - symbol814 = consume_terminal!(parser, "SYMBOL") + span_start819 = span_start(parser) + symbol817 = consume_terminal!(parser, "SYMBOL") consume_literal!(parser, "::") - _t1536 = parse_type(parser) - type815 = _t1536 - _t1537 = Proto.Var(name=symbol814) - _t1538 = Proto.Binding(var=_t1537, var"#type"=type815) - result817 = _t1538 - record_span!(parser, span_start816, "Binding") - return result817 + _t1542 = parse_type(parser) + type818 = _t1542 + _t1543 = Proto.Var(name=symbol817) + _t1544 = Proto.Binding(var=_t1543, var"#type"=type818) + result820 = _t1544 + record_span!(parser, span_start819, "Binding") + return result820 end function parse_type(parser::ParserState)::Proto.var"#Type" - span_start833 = span_start(parser) + span_start836 = span_start(parser) if match_lookahead_literal(parser, "UNKNOWN", 0) - _t1539 = 0 + _t1545 = 0 else if match_lookahead_literal(parser, "UINT32", 0) - _t1540 = 13 + _t1546 = 13 else if match_lookahead_literal(parser, "UINT128", 0) - _t1541 = 4 + _t1547 = 4 else if match_lookahead_literal(parser, "STRING", 0) - _t1542 = 1 + _t1548 = 1 else if match_lookahead_literal(parser, "MISSING", 0) - _t1543 = 8 + _t1549 = 8 else if match_lookahead_literal(parser, "INT32", 0) - _t1544 = 11 + _t1550 = 11 else if match_lookahead_literal(parser, "INT128", 0) - _t1545 = 5 + _t1551 = 5 else if match_lookahead_literal(parser, "INT", 0) - _t1546 = 2 + _t1552 = 2 else if match_lookahead_literal(parser, "FLOAT32", 0) - _t1547 = 12 + _t1553 = 12 else if match_lookahead_literal(parser, "FLOAT", 0) - _t1548 = 3 + _t1554 = 3 else if match_lookahead_literal(parser, "DATETIME", 0) - _t1549 = 7 + _t1555 = 7 else if match_lookahead_literal(parser, "DATE", 0) - _t1550 = 6 + _t1556 = 6 else if match_lookahead_literal(parser, "BOOLEAN", 0) - _t1551 = 10 + _t1557 = 10 else if match_lookahead_literal(parser, "(", 0) - _t1552 = 9 + _t1558 = 9 else - _t1552 = -1 + _t1558 = -1 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 - end - prediction818 = _t1539 - if prediction818 == 13 - _t1554 = parse_uint32_type(parser) - uint32_type832 = _t1554 - _t1555 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type832)) - _t1553 = _t1555 + _t1545 = _t1546 + end + prediction821 = _t1545 + if prediction821 == 13 + _t1560 = parse_uint32_type(parser) + uint32_type835 = _t1560 + _t1561 = Proto.var"#Type"(var"#type"=OneOf(:uint32_type, uint32_type835)) + _t1559 = _t1561 else - if prediction818 == 12 - _t1557 = parse_float32_type(parser) - float32_type831 = _t1557 - _t1558 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type831)) - _t1556 = _t1558 + if prediction821 == 12 + _t1563 = parse_float32_type(parser) + float32_type834 = _t1563 + _t1564 = Proto.var"#Type"(var"#type"=OneOf(:float32_type, float32_type834)) + _t1562 = _t1564 else - if prediction818 == 11 - _t1560 = parse_int32_type(parser) - int32_type830 = _t1560 - _t1561 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type830)) - _t1559 = _t1561 + if prediction821 == 11 + _t1566 = parse_int32_type(parser) + int32_type833 = _t1566 + _t1567 = Proto.var"#Type"(var"#type"=OneOf(:int32_type, int32_type833)) + _t1565 = _t1567 else - if prediction818 == 10 - _t1563 = parse_boolean_type(parser) - boolean_type829 = _t1563 - _t1564 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type829)) - _t1562 = _t1564 + if prediction821 == 10 + _t1569 = parse_boolean_type(parser) + boolean_type832 = _t1569 + _t1570 = Proto.var"#Type"(var"#type"=OneOf(:boolean_type, boolean_type832)) + _t1568 = _t1570 else - if prediction818 == 9 - _t1566 = parse_decimal_type(parser) - decimal_type828 = _t1566 - _t1567 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type828)) - _t1565 = _t1567 + if prediction821 == 9 + _t1572 = parse_decimal_type(parser) + decimal_type831 = _t1572 + _t1573 = Proto.var"#Type"(var"#type"=OneOf(:decimal_type, decimal_type831)) + _t1571 = _t1573 else - if prediction818 == 8 - _t1569 = parse_missing_type(parser) - missing_type827 = _t1569 - _t1570 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type827)) - _t1568 = _t1570 + if prediction821 == 8 + _t1575 = parse_missing_type(parser) + missing_type830 = _t1575 + _t1576 = Proto.var"#Type"(var"#type"=OneOf(:missing_type, missing_type830)) + _t1574 = _t1576 else - if prediction818 == 7 - _t1572 = parse_datetime_type(parser) - datetime_type826 = _t1572 - _t1573 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type826)) - _t1571 = _t1573 + if prediction821 == 7 + _t1578 = parse_datetime_type(parser) + datetime_type829 = _t1578 + _t1579 = Proto.var"#Type"(var"#type"=OneOf(:datetime_type, datetime_type829)) + _t1577 = _t1579 else - if prediction818 == 6 - _t1575 = parse_date_type(parser) - date_type825 = _t1575 - _t1576 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type825)) - _t1574 = _t1576 + if prediction821 == 6 + _t1581 = parse_date_type(parser) + date_type828 = _t1581 + _t1582 = Proto.var"#Type"(var"#type"=OneOf(:date_type, date_type828)) + _t1580 = _t1582 else - if prediction818 == 5 - _t1578 = parse_int128_type(parser) - int128_type824 = _t1578 - _t1579 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type824)) - _t1577 = _t1579 + if prediction821 == 5 + _t1584 = parse_int128_type(parser) + int128_type827 = _t1584 + _t1585 = Proto.var"#Type"(var"#type"=OneOf(:int128_type, int128_type827)) + _t1583 = _t1585 else - if prediction818 == 4 - _t1581 = parse_uint128_type(parser) - uint128_type823 = _t1581 - _t1582 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type823)) - _t1580 = _t1582 + if prediction821 == 4 + _t1587 = parse_uint128_type(parser) + uint128_type826 = _t1587 + _t1588 = Proto.var"#Type"(var"#type"=OneOf(:uint128_type, uint128_type826)) + _t1586 = _t1588 else - if prediction818 == 3 - _t1584 = parse_float_type(parser) - float_type822 = _t1584 - _t1585 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type822)) - _t1583 = _t1585 + if prediction821 == 3 + _t1590 = parse_float_type(parser) + float_type825 = _t1590 + _t1591 = Proto.var"#Type"(var"#type"=OneOf(:float_type, float_type825)) + _t1589 = _t1591 else - if prediction818 == 2 - _t1587 = parse_int_type(parser) - int_type821 = _t1587 - _t1588 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type821)) - _t1586 = _t1588 + if prediction821 == 2 + _t1593 = parse_int_type(parser) + int_type824 = _t1593 + _t1594 = Proto.var"#Type"(var"#type"=OneOf(:int_type, int_type824)) + _t1592 = _t1594 else - if prediction818 == 1 - _t1590 = parse_string_type(parser) - string_type820 = _t1590 - _t1591 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type820)) - _t1589 = _t1591 + if prediction821 == 1 + _t1596 = parse_string_type(parser) + string_type823 = _t1596 + _t1597 = Proto.var"#Type"(var"#type"=OneOf(:string_type, string_type823)) + _t1595 = _t1597 else - if prediction818 == 0 - _t1593 = parse_unspecified_type(parser) - unspecified_type819 = _t1593 - _t1594 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type819)) - _t1592 = _t1594 + if prediction821 == 0 + _t1599 = parse_unspecified_type(parser) + unspecified_type822 = _t1599 + _t1600 = Proto.var"#Type"(var"#type"=OneOf(:unspecified_type, unspecified_type822)) + _t1598 = _t1600 else throw(ParseError("Unexpected token in type" * ": " * string(lookahead(parser, 0)))) 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 - _t1556 = _t1559 + _t1562 = _t1565 end - _t1553 = _t1556 + _t1559 = _t1562 end - result834 = _t1553 - record_span!(parser, span_start833, "Type") - return result834 + result837 = _t1559 + record_span!(parser, span_start836, "Type") + return result837 end function parse_unspecified_type(parser::ParserState)::Proto.UnspecifiedType - span_start835 = span_start(parser) + span_start838 = span_start(parser) consume_literal!(parser, "UNKNOWN") - _t1595 = Proto.UnspecifiedType() - result836 = _t1595 - record_span!(parser, span_start835, "UnspecifiedType") - return result836 + _t1601 = Proto.UnspecifiedType() + result839 = _t1601 + record_span!(parser, span_start838, "UnspecifiedType") + return result839 end function parse_string_type(parser::ParserState)::Proto.StringType - span_start837 = span_start(parser) + span_start840 = span_start(parser) consume_literal!(parser, "STRING") - _t1596 = Proto.StringType() - result838 = _t1596 - record_span!(parser, span_start837, "StringType") - return result838 + _t1602 = Proto.StringType() + result841 = _t1602 + record_span!(parser, span_start840, "StringType") + return result841 end function parse_int_type(parser::ParserState)::Proto.IntType - span_start839 = span_start(parser) + span_start842 = span_start(parser) consume_literal!(parser, "INT") - _t1597 = Proto.IntType() - result840 = _t1597 - record_span!(parser, span_start839, "IntType") - return result840 + _t1603 = Proto.IntType() + result843 = _t1603 + record_span!(parser, span_start842, "IntType") + return result843 end function parse_float_type(parser::ParserState)::Proto.FloatType - span_start841 = span_start(parser) + span_start844 = span_start(parser) consume_literal!(parser, "FLOAT") - _t1598 = Proto.FloatType() - result842 = _t1598 - record_span!(parser, span_start841, "FloatType") - return result842 + _t1604 = Proto.FloatType() + result845 = _t1604 + record_span!(parser, span_start844, "FloatType") + return result845 end function parse_uint128_type(parser::ParserState)::Proto.UInt128Type - span_start843 = span_start(parser) + span_start846 = span_start(parser) consume_literal!(parser, "UINT128") - _t1599 = Proto.UInt128Type() - result844 = _t1599 - record_span!(parser, span_start843, "UInt128Type") - return result844 + _t1605 = Proto.UInt128Type() + result847 = _t1605 + record_span!(parser, span_start846, "UInt128Type") + return result847 end function parse_int128_type(parser::ParserState)::Proto.Int128Type - span_start845 = span_start(parser) + span_start848 = span_start(parser) consume_literal!(parser, "INT128") - _t1600 = Proto.Int128Type() - result846 = _t1600 - record_span!(parser, span_start845, "Int128Type") - return result846 + _t1606 = Proto.Int128Type() + result849 = _t1606 + record_span!(parser, span_start848, "Int128Type") + return result849 end function parse_date_type(parser::ParserState)::Proto.DateType - span_start847 = span_start(parser) + span_start850 = span_start(parser) consume_literal!(parser, "DATE") - _t1601 = Proto.DateType() - result848 = _t1601 - record_span!(parser, span_start847, "DateType") - return result848 + _t1607 = Proto.DateType() + result851 = _t1607 + record_span!(parser, span_start850, "DateType") + return result851 end function parse_datetime_type(parser::ParserState)::Proto.DateTimeType - span_start849 = span_start(parser) + span_start852 = span_start(parser) consume_literal!(parser, "DATETIME") - _t1602 = Proto.DateTimeType() - result850 = _t1602 - record_span!(parser, span_start849, "DateTimeType") - return result850 + _t1608 = Proto.DateTimeType() + result853 = _t1608 + record_span!(parser, span_start852, "DateTimeType") + return result853 end function parse_missing_type(parser::ParserState)::Proto.MissingType - span_start851 = span_start(parser) + span_start854 = span_start(parser) consume_literal!(parser, "MISSING") - _t1603 = Proto.MissingType() - result852 = _t1603 - record_span!(parser, span_start851, "MissingType") - return result852 + _t1609 = Proto.MissingType() + result855 = _t1609 + record_span!(parser, span_start854, "MissingType") + return result855 end function parse_decimal_type(parser::ParserState)::Proto.DecimalType - span_start855 = span_start(parser) + span_start858 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "DECIMAL") - int853 = consume_terminal!(parser, "INT") - int_3854 = consume_terminal!(parser, "INT") + int856 = consume_terminal!(parser, "INT") + int_3857 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1604 = Proto.DecimalType(precision=Int32(int853), scale=Int32(int_3854)) - result856 = _t1604 - record_span!(parser, span_start855, "DecimalType") - return result856 + _t1610 = Proto.DecimalType(precision=Int32(int856), scale=Int32(int_3857)) + result859 = _t1610 + record_span!(parser, span_start858, "DecimalType") + return result859 end function parse_boolean_type(parser::ParserState)::Proto.BooleanType - span_start857 = span_start(parser) + span_start860 = span_start(parser) consume_literal!(parser, "BOOLEAN") - _t1605 = Proto.BooleanType() - result858 = _t1605 - record_span!(parser, span_start857, "BooleanType") - return result858 + _t1611 = Proto.BooleanType() + result861 = _t1611 + record_span!(parser, span_start860, "BooleanType") + return result861 end function parse_int32_type(parser::ParserState)::Proto.Int32Type - span_start859 = span_start(parser) + span_start862 = span_start(parser) consume_literal!(parser, "INT32") - _t1606 = Proto.Int32Type() - result860 = _t1606 - record_span!(parser, span_start859, "Int32Type") - return result860 + _t1612 = Proto.Int32Type() + result863 = _t1612 + record_span!(parser, span_start862, "Int32Type") + return result863 end function parse_float32_type(parser::ParserState)::Proto.Float32Type - span_start861 = span_start(parser) + span_start864 = span_start(parser) consume_literal!(parser, "FLOAT32") - _t1607 = Proto.Float32Type() - result862 = _t1607 - record_span!(parser, span_start861, "Float32Type") - return result862 + _t1613 = Proto.Float32Type() + result865 = _t1613 + record_span!(parser, span_start864, "Float32Type") + return result865 end function parse_uint32_type(parser::ParserState)::Proto.UInt32Type - span_start863 = span_start(parser) + span_start866 = span_start(parser) consume_literal!(parser, "UINT32") - _t1608 = Proto.UInt32Type() - result864 = _t1608 - record_span!(parser, span_start863, "UInt32Type") - return result864 + _t1614 = Proto.UInt32Type() + result867 = _t1614 + record_span!(parser, span_start866, "UInt32Type") + return result867 end function parse_value_bindings(parser::ParserState)::Vector{Proto.Binding} consume_literal!(parser, "|") - xs865 = Proto.Binding[] - cond866 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond866 - _t1609 = parse_binding(parser) - item867 = _t1609 - push!(xs865, item867) - cond866 = match_lookahead_terminal(parser, "SYMBOL", 0) + xs868 = Proto.Binding[] + cond869 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond869 + _t1615 = parse_binding(parser) + item870 = _t1615 + push!(xs868, item870) + cond869 = match_lookahead_terminal(parser, "SYMBOL", 0) end - bindings868 = xs865 - return bindings868 + bindings871 = xs868 + return bindings871 end function parse_formula(parser::ParserState)::Proto.Formula - span_start883 = span_start(parser) + span_start886 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "true", 1) - _t1611 = 0 + _t1617 = 0 else if match_lookahead_literal(parser, "relatom", 1) - _t1612 = 11 + _t1618 = 11 else if match_lookahead_literal(parser, "reduce", 1) - _t1613 = 3 + _t1619 = 3 else if match_lookahead_literal(parser, "primitive", 1) - _t1614 = 10 + _t1620 = 10 else if match_lookahead_literal(parser, "pragma", 1) - _t1615 = 9 + _t1621 = 9 else if match_lookahead_literal(parser, "or", 1) - _t1616 = 5 + _t1622 = 5 else if match_lookahead_literal(parser, "not", 1) - _t1617 = 6 + _t1623 = 6 else if match_lookahead_literal(parser, "ffi", 1) - _t1618 = 7 + _t1624 = 7 else if match_lookahead_literal(parser, "false", 1) - _t1619 = 1 + _t1625 = 1 else if match_lookahead_literal(parser, "exists", 1) - _t1620 = 2 + _t1626 = 2 else if match_lookahead_literal(parser, "cast", 1) - _t1621 = 12 + _t1627 = 12 else if match_lookahead_literal(parser, "atom", 1) - _t1622 = 8 + _t1628 = 8 else if match_lookahead_literal(parser, "and", 1) - _t1623 = 4 + _t1629 = 4 else if match_lookahead_literal(parser, ">=", 1) - _t1624 = 10 + _t1630 = 10 else if match_lookahead_literal(parser, ">", 1) - _t1625 = 10 + _t1631 = 10 else if match_lookahead_literal(parser, "=", 1) - _t1626 = 10 + _t1632 = 10 else if match_lookahead_literal(parser, "<=", 1) - _t1627 = 10 + _t1633 = 10 else if match_lookahead_literal(parser, "<", 1) - _t1628 = 10 + _t1634 = 10 else if match_lookahead_literal(parser, "/", 1) - _t1629 = 10 + _t1635 = 10 else if match_lookahead_literal(parser, "-", 1) - _t1630 = 10 + _t1636 = 10 else if match_lookahead_literal(parser, "+", 1) - _t1631 = 10 + _t1637 = 10 else if match_lookahead_literal(parser, "*", 1) - _t1632 = 10 + _t1638 = 10 else - _t1632 = -1 + _t1638 = -1 end - _t1631 = _t1632 + _t1637 = _t1638 end - _t1630 = _t1631 + _t1636 = _t1637 end - _t1629 = _t1630 + _t1635 = _t1636 end - _t1628 = _t1629 + _t1634 = _t1635 end - _t1627 = _t1628 + _t1633 = _t1634 end - _t1626 = _t1627 + _t1632 = _t1633 end - _t1625 = _t1626 + _t1631 = _t1632 end - _t1624 = _t1625 + _t1630 = _t1631 end - _t1623 = _t1624 + _t1629 = _t1630 end - _t1622 = _t1623 + _t1628 = _t1629 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 else - _t1610 = -1 - end - prediction869 = _t1610 - if prediction869 == 12 - _t1634 = parse_cast(parser) - cast882 = _t1634 - _t1635 = Proto.Formula(formula_type=OneOf(:cast, cast882)) - _t1633 = _t1635 + _t1616 = -1 + end + prediction872 = _t1616 + if prediction872 == 12 + _t1640 = parse_cast(parser) + cast885 = _t1640 + _t1641 = Proto.Formula(formula_type=OneOf(:cast, cast885)) + _t1639 = _t1641 else - if prediction869 == 11 - _t1637 = parse_rel_atom(parser) - rel_atom881 = _t1637 - _t1638 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom881)) - _t1636 = _t1638 + if prediction872 == 11 + _t1643 = parse_rel_atom(parser) + rel_atom884 = _t1643 + _t1644 = Proto.Formula(formula_type=OneOf(:rel_atom, rel_atom884)) + _t1642 = _t1644 else - if prediction869 == 10 - _t1640 = parse_primitive(parser) - primitive880 = _t1640 - _t1641 = Proto.Formula(formula_type=OneOf(:primitive, primitive880)) - _t1639 = _t1641 + if prediction872 == 10 + _t1646 = parse_primitive(parser) + primitive883 = _t1646 + _t1647 = Proto.Formula(formula_type=OneOf(:primitive, primitive883)) + _t1645 = _t1647 else - if prediction869 == 9 - _t1643 = parse_pragma(parser) - pragma879 = _t1643 - _t1644 = Proto.Formula(formula_type=OneOf(:pragma, pragma879)) - _t1642 = _t1644 + if prediction872 == 9 + _t1649 = parse_pragma(parser) + pragma882 = _t1649 + _t1650 = Proto.Formula(formula_type=OneOf(:pragma, pragma882)) + _t1648 = _t1650 else - if prediction869 == 8 - _t1646 = parse_atom(parser) - atom878 = _t1646 - _t1647 = Proto.Formula(formula_type=OneOf(:atom, atom878)) - _t1645 = _t1647 + if prediction872 == 8 + _t1652 = parse_atom(parser) + atom881 = _t1652 + _t1653 = Proto.Formula(formula_type=OneOf(:atom, atom881)) + _t1651 = _t1653 else - if prediction869 == 7 - _t1649 = parse_ffi(parser) - ffi877 = _t1649 - _t1650 = Proto.Formula(formula_type=OneOf(:ffi, ffi877)) - _t1648 = _t1650 + if prediction872 == 7 + _t1655 = parse_ffi(parser) + ffi880 = _t1655 + _t1656 = Proto.Formula(formula_type=OneOf(:ffi, ffi880)) + _t1654 = _t1656 else - if prediction869 == 6 - _t1652 = parse_not(parser) - not876 = _t1652 - _t1653 = Proto.Formula(formula_type=OneOf(:not, not876)) - _t1651 = _t1653 + if prediction872 == 6 + _t1658 = parse_not(parser) + not879 = _t1658 + _t1659 = Proto.Formula(formula_type=OneOf(:not, not879)) + _t1657 = _t1659 else - if prediction869 == 5 - _t1655 = parse_disjunction(parser) - disjunction875 = _t1655 - _t1656 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction875)) - _t1654 = _t1656 + if prediction872 == 5 + _t1661 = parse_disjunction(parser) + disjunction878 = _t1661 + _t1662 = Proto.Formula(formula_type=OneOf(:disjunction, disjunction878)) + _t1660 = _t1662 else - if prediction869 == 4 - _t1658 = parse_conjunction(parser) - conjunction874 = _t1658 - _t1659 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction874)) - _t1657 = _t1659 + if prediction872 == 4 + _t1664 = parse_conjunction(parser) + conjunction877 = _t1664 + _t1665 = Proto.Formula(formula_type=OneOf(:conjunction, conjunction877)) + _t1663 = _t1665 else - if prediction869 == 3 - _t1661 = parse_reduce(parser) - reduce873 = _t1661 - _t1662 = Proto.Formula(formula_type=OneOf(:reduce, reduce873)) - _t1660 = _t1662 + if prediction872 == 3 + _t1667 = parse_reduce(parser) + reduce876 = _t1667 + _t1668 = Proto.Formula(formula_type=OneOf(:reduce, reduce876)) + _t1666 = _t1668 else - if prediction869 == 2 - _t1664 = parse_exists(parser) - exists872 = _t1664 - _t1665 = Proto.Formula(formula_type=OneOf(:exists, exists872)) - _t1663 = _t1665 + if prediction872 == 2 + _t1670 = parse_exists(parser) + exists875 = _t1670 + _t1671 = Proto.Formula(formula_type=OneOf(:exists, exists875)) + _t1669 = _t1671 else - if prediction869 == 1 - _t1667 = parse_false(parser) - false871 = _t1667 - _t1668 = Proto.Formula(formula_type=OneOf(:disjunction, false871)) - _t1666 = _t1668 + if prediction872 == 1 + _t1673 = parse_false(parser) + false874 = _t1673 + _t1674 = Proto.Formula(formula_type=OneOf(:disjunction, false874)) + _t1672 = _t1674 else - if prediction869 == 0 - _t1670 = parse_true(parser) - true870 = _t1670 - _t1671 = Proto.Formula(formula_type=OneOf(:conjunction, true870)) - _t1669 = _t1671 + if prediction872 == 0 + _t1676 = parse_true(parser) + true873 = _t1676 + _t1677 = Proto.Formula(formula_type=OneOf(:conjunction, true873)) + _t1675 = _t1677 else throw(ParseError("Unexpected token in formula" * ": " * string(lookahead(parser, 0)))) end - _t1666 = _t1669 + _t1672 = _t1675 end - _t1663 = _t1666 + _t1669 = _t1672 end - _t1660 = _t1663 + _t1666 = _t1669 end - _t1657 = _t1660 + _t1663 = _t1666 end - _t1654 = _t1657 + _t1660 = _t1663 end - _t1651 = _t1654 + _t1657 = _t1660 end - _t1648 = _t1651 + _t1654 = _t1657 end - _t1645 = _t1648 + _t1651 = _t1654 end - _t1642 = _t1645 + _t1648 = _t1651 end - _t1639 = _t1642 + _t1645 = _t1648 end - _t1636 = _t1639 + _t1642 = _t1645 end - _t1633 = _t1636 + _t1639 = _t1642 end - result884 = _t1633 - record_span!(parser, span_start883, "Formula") - return result884 + result887 = _t1639 + record_span!(parser, span_start886, "Formula") + return result887 end function parse_true(parser::ParserState)::Proto.Conjunction - span_start885 = span_start(parser) + span_start888 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "true") consume_literal!(parser, ")") - _t1672 = Proto.Conjunction(args=Proto.Formula[]) - result886 = _t1672 - record_span!(parser, span_start885, "Conjunction") - return result886 + _t1678 = Proto.Conjunction(args=Proto.Formula[]) + result889 = _t1678 + record_span!(parser, span_start888, "Conjunction") + return result889 end function parse_false(parser::ParserState)::Proto.Disjunction - span_start887 = span_start(parser) + span_start890 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "false") consume_literal!(parser, ")") - _t1673 = Proto.Disjunction(args=Proto.Formula[]) - result888 = _t1673 - record_span!(parser, span_start887, "Disjunction") - return result888 + _t1679 = Proto.Disjunction(args=Proto.Formula[]) + result891 = _t1679 + record_span!(parser, span_start890, "Disjunction") + return result891 end function parse_exists(parser::ParserState)::Proto.Exists - span_start891 = span_start(parser) + span_start894 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "exists") - _t1674 = parse_bindings(parser) - bindings889 = _t1674 - _t1675 = parse_formula(parser) - formula890 = _t1675 + _t1680 = parse_bindings(parser) + bindings892 = _t1680 + _t1681 = parse_formula(parser) + formula893 = _t1681 consume_literal!(parser, ")") - _t1676 = Proto.Abstraction(vars=vcat(bindings889[1], !isnothing(bindings889[2]) ? bindings889[2] : []), value=formula890) - _t1677 = Proto.Exists(body=_t1676) - result892 = _t1677 - record_span!(parser, span_start891, "Exists") - return result892 + _t1682 = Proto.Abstraction(vars=vcat(bindings892[1], !isnothing(bindings892[2]) ? bindings892[2] : []), value=formula893) + _t1683 = Proto.Exists(body=_t1682) + result895 = _t1683 + record_span!(parser, span_start894, "Exists") + return result895 end function parse_reduce(parser::ParserState)::Proto.Reduce - span_start896 = span_start(parser) + span_start899 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "reduce") - _t1678 = parse_abstraction(parser) - abstraction893 = _t1678 - _t1679 = parse_abstraction(parser) - abstraction_3894 = _t1679 - _t1680 = parse_terms(parser) - terms895 = _t1680 + _t1684 = parse_abstraction(parser) + abstraction896 = _t1684 + _t1685 = parse_abstraction(parser) + abstraction_3897 = _t1685 + _t1686 = parse_terms(parser) + terms898 = _t1686 consume_literal!(parser, ")") - _t1681 = Proto.Reduce(op=abstraction893, body=abstraction_3894, terms=terms895) - result897 = _t1681 - record_span!(parser, span_start896, "Reduce") - return result897 + _t1687 = Proto.Reduce(op=abstraction896, body=abstraction_3897, terms=terms898) + result900 = _t1687 + record_span!(parser, span_start899, "Reduce") + return result900 end function parse_terms(parser::ParserState)::Vector{Proto.Term} consume_literal!(parser, "(") consume_literal!(parser, "terms") - xs898 = Proto.Term[] - cond899 = (((((((((((((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 cond899 - _t1682 = parse_term(parser) - item900 = _t1682 - push!(xs898, item900) - cond899 = (((((((((((((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 - terms901 = xs898 + xs901 = Proto.Term[] + cond902 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond902 + _t1688 = parse_term(parser) + item903 = _t1688 + push!(xs901, item903) + cond902 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + terms904 = xs901 consume_literal!(parser, ")") - return terms901 + return terms904 end function parse_term(parser::ParserState)::Proto.Term - span_start905 = span_start(parser) + span_start908 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1683 = 1 + _t1689 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1684 = 1 + _t1690 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1685 = 1 + _t1691 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1686 = 1 + _t1692 = 1 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1687 = 0 + _t1693 = 0 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1688 = 1 + _t1694 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1689 = 1 + _t1695 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1690 = 1 + _t1696 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1691 = 1 + _t1697 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1692 = 1 + _t1698 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1693 = 1 + _t1699 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1694 = 1 + _t1700 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1695 = 1 + _t1701 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1696 = 1 + _t1702 = 1 else - _t1696 = -1 + _t1702 = -1 end - _t1695 = _t1696 + _t1701 = _t1702 end - _t1694 = _t1695 + _t1700 = _t1701 end - _t1693 = _t1694 + _t1699 = _t1700 end - _t1692 = _t1693 + _t1698 = _t1699 end - _t1691 = _t1692 + _t1697 = _t1698 end - _t1690 = _t1691 + _t1696 = _t1697 end - _t1689 = _t1690 + _t1695 = _t1696 end - _t1688 = _t1689 + _t1694 = _t1695 end - _t1687 = _t1688 + _t1693 = _t1694 end - _t1686 = _t1687 + _t1692 = _t1693 end - _t1685 = _t1686 + _t1691 = _t1692 end - _t1684 = _t1685 + _t1690 = _t1691 end - _t1683 = _t1684 - end - prediction902 = _t1683 - if prediction902 == 1 - _t1698 = parse_value(parser) - value904 = _t1698 - _t1699 = Proto.Term(term_type=OneOf(:constant, value904)) - _t1697 = _t1699 + _t1689 = _t1690 + end + prediction905 = _t1689 + if prediction905 == 1 + _t1704 = parse_value(parser) + value907 = _t1704 + _t1705 = Proto.Term(term_type=OneOf(:constant, value907)) + _t1703 = _t1705 else - if prediction902 == 0 - _t1701 = parse_var(parser) - var903 = _t1701 - _t1702 = Proto.Term(term_type=OneOf(:var, var903)) - _t1700 = _t1702 + if prediction905 == 0 + _t1707 = parse_var(parser) + var906 = _t1707 + _t1708 = Proto.Term(term_type=OneOf(:var, var906)) + _t1706 = _t1708 else throw(ParseError("Unexpected token in term" * ": " * string(lookahead(parser, 0)))) end - _t1697 = _t1700 + _t1703 = _t1706 end - result906 = _t1697 - record_span!(parser, span_start905, "Term") - return result906 + result909 = _t1703 + record_span!(parser, span_start908, "Term") + return result909 end function parse_var(parser::ParserState)::Proto.Var - span_start908 = span_start(parser) - symbol907 = consume_terminal!(parser, "SYMBOL") - _t1703 = Proto.Var(name=symbol907) - result909 = _t1703 - record_span!(parser, span_start908, "Var") - return result909 + span_start911 = span_start(parser) + symbol910 = consume_terminal!(parser, "SYMBOL") + _t1709 = Proto.Var(name=symbol910) + result912 = _t1709 + record_span!(parser, span_start911, "Var") + return result912 end function parse_value(parser::ParserState)::Proto.Value - span_start923 = span_start(parser) + span_start926 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1704 = 12 + _t1710 = 12 else if match_lookahead_literal(parser, "missing", 0) - _t1705 = 11 + _t1711 = 11 else if match_lookahead_literal(parser, "false", 0) - _t1706 = 12 + _t1712 = 12 else if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "datetime", 1) - _t1708 = 1 + _t1714 = 1 else if match_lookahead_literal(parser, "date", 1) - _t1709 = 0 + _t1715 = 0 else - _t1709 = -1 + _t1715 = -1 end - _t1708 = _t1709 + _t1714 = _t1715 end - _t1707 = _t1708 + _t1713 = _t1714 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1710 = 7 + _t1716 = 7 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1711 = 8 + _t1717 = 8 else if match_lookahead_terminal(parser, "STRING", 0) - _t1712 = 2 + _t1718 = 2 else if match_lookahead_terminal(parser, "INT32", 0) - _t1713 = 3 + _t1719 = 3 else if match_lookahead_terminal(parser, "INT128", 0) - _t1714 = 9 + _t1720 = 9 else if match_lookahead_terminal(parser, "INT", 0) - _t1715 = 4 + _t1721 = 4 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1716 = 5 + _t1722 = 5 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1717 = 6 + _t1723 = 6 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1718 = 10 + _t1724 = 10 else - _t1718 = -1 + _t1724 = -1 end - _t1717 = _t1718 + _t1723 = _t1724 end - _t1716 = _t1717 + _t1722 = _t1723 end - _t1715 = _t1716 + _t1721 = _t1722 end - _t1714 = _t1715 + _t1720 = _t1721 end - _t1713 = _t1714 + _t1719 = _t1720 end - _t1712 = _t1713 + _t1718 = _t1719 end - _t1711 = _t1712 + _t1717 = _t1718 end - _t1710 = _t1711 + _t1716 = _t1717 end - _t1707 = _t1710 + _t1713 = _t1716 end - _t1706 = _t1707 + _t1712 = _t1713 end - _t1705 = _t1706 + _t1711 = _t1712 end - _t1704 = _t1705 - end - prediction910 = _t1704 - if prediction910 == 12 - _t1720 = parse_boolean_value(parser) - boolean_value922 = _t1720 - _t1721 = Proto.Value(value=OneOf(:boolean_value, boolean_value922)) - _t1719 = _t1721 + _t1710 = _t1711 + end + prediction913 = _t1710 + if prediction913 == 12 + _t1726 = parse_boolean_value(parser) + boolean_value925 = _t1726 + _t1727 = Proto.Value(value=OneOf(:boolean_value, boolean_value925)) + _t1725 = _t1727 else - if prediction910 == 11 + if prediction913 == 11 consume_literal!(parser, "missing") - _t1723 = Proto.MissingValue() - _t1724 = Proto.Value(value=OneOf(:missing_value, _t1723)) - _t1722 = _t1724 + _t1729 = Proto.MissingValue() + _t1730 = Proto.Value(value=OneOf(:missing_value, _t1729)) + _t1728 = _t1730 else - if prediction910 == 10 - formatted_decimal921 = consume_terminal!(parser, "DECIMAL") - _t1726 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal921)) - _t1725 = _t1726 + if prediction913 == 10 + formatted_decimal924 = consume_terminal!(parser, "DECIMAL") + _t1732 = Proto.Value(value=OneOf(:decimal_value, formatted_decimal924)) + _t1731 = _t1732 else - if prediction910 == 9 - formatted_int128920 = consume_terminal!(parser, "INT128") - _t1728 = Proto.Value(value=OneOf(:int128_value, formatted_int128920)) - _t1727 = _t1728 + if prediction913 == 9 + formatted_int128923 = consume_terminal!(parser, "INT128") + _t1734 = Proto.Value(value=OneOf(:int128_value, formatted_int128923)) + _t1733 = _t1734 else - if prediction910 == 8 - formatted_uint128919 = consume_terminal!(parser, "UINT128") - _t1730 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128919)) - _t1729 = _t1730 + if prediction913 == 8 + formatted_uint128922 = consume_terminal!(parser, "UINT128") + _t1736 = Proto.Value(value=OneOf(:uint128_value, formatted_uint128922)) + _t1735 = _t1736 else - if prediction910 == 7 - formatted_uint32918 = consume_terminal!(parser, "UINT32") - _t1732 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32918)) - _t1731 = _t1732 + if prediction913 == 7 + formatted_uint32921 = consume_terminal!(parser, "UINT32") + _t1738 = Proto.Value(value=OneOf(:uint32_value, formatted_uint32921)) + _t1737 = _t1738 else - if prediction910 == 6 - formatted_float917 = consume_terminal!(parser, "FLOAT") - _t1734 = Proto.Value(value=OneOf(:float_value, formatted_float917)) - _t1733 = _t1734 + if prediction913 == 6 + formatted_float920 = consume_terminal!(parser, "FLOAT") + _t1740 = Proto.Value(value=OneOf(:float_value, formatted_float920)) + _t1739 = _t1740 else - if prediction910 == 5 - formatted_float32916 = consume_terminal!(parser, "FLOAT32") - _t1736 = Proto.Value(value=OneOf(:float32_value, formatted_float32916)) - _t1735 = _t1736 + if prediction913 == 5 + formatted_float32919 = consume_terminal!(parser, "FLOAT32") + _t1742 = Proto.Value(value=OneOf(:float32_value, formatted_float32919)) + _t1741 = _t1742 else - if prediction910 == 4 - formatted_int915 = consume_terminal!(parser, "INT") - _t1738 = Proto.Value(value=OneOf(:int_value, formatted_int915)) - _t1737 = _t1738 + if prediction913 == 4 + formatted_int918 = consume_terminal!(parser, "INT") + _t1744 = Proto.Value(value=OneOf(:int_value, formatted_int918)) + _t1743 = _t1744 else - if prediction910 == 3 - formatted_int32914 = consume_terminal!(parser, "INT32") - _t1740 = Proto.Value(value=OneOf(:int32_value, formatted_int32914)) - _t1739 = _t1740 + if prediction913 == 3 + formatted_int32917 = consume_terminal!(parser, "INT32") + _t1746 = Proto.Value(value=OneOf(:int32_value, formatted_int32917)) + _t1745 = _t1746 else - if prediction910 == 2 - formatted_string913 = consume_terminal!(parser, "STRING") - _t1742 = Proto.Value(value=OneOf(:string_value, formatted_string913)) - _t1741 = _t1742 + if prediction913 == 2 + formatted_string916 = consume_terminal!(parser, "STRING") + _t1748 = Proto.Value(value=OneOf(:string_value, formatted_string916)) + _t1747 = _t1748 else - if prediction910 == 1 - _t1744 = parse_datetime(parser) - datetime912 = _t1744 - _t1745 = Proto.Value(value=OneOf(:datetime_value, datetime912)) - _t1743 = _t1745 + if prediction913 == 1 + _t1750 = parse_datetime(parser) + datetime915 = _t1750 + _t1751 = Proto.Value(value=OneOf(:datetime_value, datetime915)) + _t1749 = _t1751 else - if prediction910 == 0 - _t1747 = parse_date(parser) - date911 = _t1747 - _t1748 = Proto.Value(value=OneOf(:date_value, date911)) - _t1746 = _t1748 + if prediction913 == 0 + _t1753 = parse_date(parser) + date914 = _t1753 + _t1754 = Proto.Value(value=OneOf(:date_value, date914)) + _t1752 = _t1754 else throw(ParseError("Unexpected token in value" * ": " * string(lookahead(parser, 0)))) end - _t1743 = _t1746 + _t1749 = _t1752 end - _t1741 = _t1743 + _t1747 = _t1749 end - _t1739 = _t1741 + _t1745 = _t1747 end - _t1737 = _t1739 + _t1743 = _t1745 end - _t1735 = _t1737 + _t1741 = _t1743 end - _t1733 = _t1735 + _t1739 = _t1741 end - _t1731 = _t1733 + _t1737 = _t1739 end - _t1729 = _t1731 + _t1735 = _t1737 end - _t1727 = _t1729 + _t1733 = _t1735 end - _t1725 = _t1727 + _t1731 = _t1733 end - _t1722 = _t1725 + _t1728 = _t1731 end - _t1719 = _t1722 + _t1725 = _t1728 end - result924 = _t1719 - record_span!(parser, span_start923, "Value") - return result924 + result927 = _t1725 + record_span!(parser, span_start926, "Value") + return result927 end function parse_date(parser::ParserState)::Proto.DateValue - span_start928 = span_start(parser) + span_start931 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "date") - formatted_int925 = consume_terminal!(parser, "INT") - formatted_int_3926 = consume_terminal!(parser, "INT") - formatted_int_4927 = consume_terminal!(parser, "INT") + formatted_int928 = consume_terminal!(parser, "INT") + formatted_int_3929 = consume_terminal!(parser, "INT") + formatted_int_4930 = consume_terminal!(parser, "INT") consume_literal!(parser, ")") - _t1749 = Proto.DateValue(year=Int32(formatted_int925), month=Int32(formatted_int_3926), day=Int32(formatted_int_4927)) - result929 = _t1749 - record_span!(parser, span_start928, "DateValue") - return result929 + _t1755 = Proto.DateValue(year=Int32(formatted_int928), month=Int32(formatted_int_3929), day=Int32(formatted_int_4930)) + result932 = _t1755 + record_span!(parser, span_start931, "DateValue") + return result932 end function parse_datetime(parser::ParserState)::Proto.DateTimeValue - span_start937 = span_start(parser) + span_start940 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "datetime") - formatted_int930 = consume_terminal!(parser, "INT") - formatted_int_3931 = consume_terminal!(parser, "INT") - formatted_int_4932 = consume_terminal!(parser, "INT") - formatted_int_5933 = consume_terminal!(parser, "INT") - formatted_int_6934 = consume_terminal!(parser, "INT") - formatted_int_7935 = consume_terminal!(parser, "INT") + formatted_int933 = consume_terminal!(parser, "INT") + formatted_int_3934 = consume_terminal!(parser, "INT") + formatted_int_4935 = consume_terminal!(parser, "INT") + formatted_int_5936 = consume_terminal!(parser, "INT") + formatted_int_6937 = consume_terminal!(parser, "INT") + formatted_int_7938 = consume_terminal!(parser, "INT") if match_lookahead_terminal(parser, "INT", 0) - _t1750 = consume_terminal!(parser, "INT") + _t1756 = consume_terminal!(parser, "INT") else - _t1750 = nothing + _t1756 = nothing end - formatted_int_8936 = _t1750 + formatted_int_8939 = _t1756 consume_literal!(parser, ")") - _t1751 = Proto.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((!isnothing(formatted_int_8936) ? formatted_int_8936 : 0))) - result938 = _t1751 - record_span!(parser, span_start937, "DateTimeValue") - return result938 + _t1757 = Proto.DateTimeValue(year=Int32(formatted_int933), month=Int32(formatted_int_3934), day=Int32(formatted_int_4935), hour=Int32(formatted_int_5936), minute=Int32(formatted_int_6937), second=Int32(formatted_int_7938), microsecond=Int32((!isnothing(formatted_int_8939) ? formatted_int_8939 : 0))) + result941 = _t1757 + record_span!(parser, span_start940, "DateTimeValue") + return result941 end function parse_conjunction(parser::ParserState)::Proto.Conjunction - span_start943 = span_start(parser) + span_start946 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "and") - xs939 = Proto.Formula[] - cond940 = match_lookahead_literal(parser, "(", 0) - while cond940 - _t1752 = parse_formula(parser) - item941 = _t1752 - push!(xs939, item941) - cond940 = match_lookahead_literal(parser, "(", 0) - end - formulas942 = xs939 + xs942 = Proto.Formula[] + cond943 = match_lookahead_literal(parser, "(", 0) + while cond943 + _t1758 = parse_formula(parser) + item944 = _t1758 + push!(xs942, item944) + cond943 = match_lookahead_literal(parser, "(", 0) + end + formulas945 = xs942 consume_literal!(parser, ")") - _t1753 = Proto.Conjunction(args=formulas942) - result944 = _t1753 - record_span!(parser, span_start943, "Conjunction") - return result944 + _t1759 = Proto.Conjunction(args=formulas945) + result947 = _t1759 + record_span!(parser, span_start946, "Conjunction") + return result947 end function parse_disjunction(parser::ParserState)::Proto.Disjunction - span_start949 = span_start(parser) + span_start952 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") - xs945 = Proto.Formula[] - cond946 = match_lookahead_literal(parser, "(", 0) - while cond946 - _t1754 = parse_formula(parser) - item947 = _t1754 - push!(xs945, item947) - cond946 = match_lookahead_literal(parser, "(", 0) - end - formulas948 = xs945 + xs948 = Proto.Formula[] + cond949 = match_lookahead_literal(parser, "(", 0) + while cond949 + _t1760 = parse_formula(parser) + item950 = _t1760 + push!(xs948, item950) + cond949 = match_lookahead_literal(parser, "(", 0) + end + formulas951 = xs948 consume_literal!(parser, ")") - _t1755 = Proto.Disjunction(args=formulas948) - result950 = _t1755 - record_span!(parser, span_start949, "Disjunction") - return result950 + _t1761 = Proto.Disjunction(args=formulas951) + result953 = _t1761 + record_span!(parser, span_start952, "Disjunction") + return result953 end function parse_not(parser::ParserState)::Proto.Not - span_start952 = span_start(parser) + span_start955 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "not") - _t1756 = parse_formula(parser) - formula951 = _t1756 + _t1762 = parse_formula(parser) + formula954 = _t1762 consume_literal!(parser, ")") - _t1757 = Proto.Not(arg=formula951) - result953 = _t1757 - record_span!(parser, span_start952, "Not") - return result953 + _t1763 = Proto.Not(arg=formula954) + result956 = _t1763 + record_span!(parser, span_start955, "Not") + return result956 end function parse_ffi(parser::ParserState)::Proto.FFI - span_start957 = span_start(parser) + span_start960 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "ffi") - _t1758 = parse_name(parser) - name954 = _t1758 - _t1759 = parse_ffi_args(parser) - ffi_args955 = _t1759 - _t1760 = parse_terms(parser) - terms956 = _t1760 + _t1764 = parse_name(parser) + name957 = _t1764 + _t1765 = parse_ffi_args(parser) + ffi_args958 = _t1765 + _t1766 = parse_terms(parser) + terms959 = _t1766 consume_literal!(parser, ")") - _t1761 = Proto.FFI(name=name954, args=ffi_args955, terms=terms956) - result958 = _t1761 - record_span!(parser, span_start957, "FFI") - return result958 + _t1767 = Proto.FFI(name=name957, args=ffi_args958, terms=terms959) + result961 = _t1767 + record_span!(parser, span_start960, "FFI") + return result961 end function parse_name(parser::ParserState)::String consume_literal!(parser, ":") - symbol959 = consume_terminal!(parser, "SYMBOL") - return symbol959 + symbol962 = consume_terminal!(parser, "SYMBOL") + return symbol962 end function parse_ffi_args(parser::ParserState)::Vector{Proto.Abstraction} consume_literal!(parser, "(") consume_literal!(parser, "args") - xs960 = Proto.Abstraction[] - cond961 = match_lookahead_literal(parser, "(", 0) - while cond961 - _t1762 = parse_abstraction(parser) - item962 = _t1762 - push!(xs960, item962) - cond961 = match_lookahead_literal(parser, "(", 0) - end - abstractions963 = xs960 + xs963 = Proto.Abstraction[] + cond964 = match_lookahead_literal(parser, "(", 0) + while cond964 + _t1768 = parse_abstraction(parser) + item965 = _t1768 + push!(xs963, item965) + cond964 = match_lookahead_literal(parser, "(", 0) + end + abstractions966 = xs963 consume_literal!(parser, ")") - return abstractions963 + return abstractions966 end function parse_atom(parser::ParserState)::Proto.Atom - span_start969 = span_start(parser) + span_start972 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "atom") - _t1763 = parse_relation_id(parser) - relation_id964 = _t1763 - xs965 = Proto.Term[] - cond966 = (((((((((((((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 cond966 - _t1764 = parse_term(parser) - item967 = _t1764 - push!(xs965, item967) - cond966 = (((((((((((((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 - terms968 = xs965 + _t1769 = parse_relation_id(parser) + relation_id967 = _t1769 + xs968 = Proto.Term[] + cond969 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond969 + _t1770 = parse_term(parser) + item970 = _t1770 + push!(xs968, item970) + cond969 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + terms971 = xs968 consume_literal!(parser, ")") - _t1765 = Proto.Atom(name=relation_id964, terms=terms968) - result970 = _t1765 - record_span!(parser, span_start969, "Atom") - return result970 + _t1771 = Proto.Atom(name=relation_id967, terms=terms971) + result973 = _t1771 + record_span!(parser, span_start972, "Atom") + return result973 end function parse_pragma(parser::ParserState)::Proto.Pragma - span_start976 = span_start(parser) + span_start979 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "pragma") - _t1766 = parse_name(parser) - name971 = _t1766 - xs972 = Proto.Term[] - cond973 = (((((((((((((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 cond973 - _t1767 = parse_term(parser) - item974 = _t1767 - push!(xs972, item974) - cond973 = (((((((((((((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 - terms975 = xs972 + _t1772 = parse_name(parser) + name974 = _t1772 + xs975 = Proto.Term[] + cond976 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond976 + _t1773 = parse_term(parser) + item977 = _t1773 + push!(xs975, item977) + cond976 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + terms978 = xs975 consume_literal!(parser, ")") - _t1768 = Proto.Pragma(name=name971, terms=terms975) - result977 = _t1768 - record_span!(parser, span_start976, "Pragma") - return result977 + _t1774 = Proto.Pragma(name=name974, terms=terms978) + result980 = _t1774 + record_span!(parser, span_start979, "Pragma") + return result980 end function parse_primitive(parser::ParserState)::Proto.Primitive - span_start993 = span_start(parser) + span_start996 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "primitive", 1) - _t1770 = 9 + _t1776 = 9 else if match_lookahead_literal(parser, ">=", 1) - _t1771 = 4 + _t1777 = 4 else if match_lookahead_literal(parser, ">", 1) - _t1772 = 3 + _t1778 = 3 else if match_lookahead_literal(parser, "=", 1) - _t1773 = 0 + _t1779 = 0 else if match_lookahead_literal(parser, "<=", 1) - _t1774 = 2 + _t1780 = 2 else if match_lookahead_literal(parser, "<", 1) - _t1775 = 1 + _t1781 = 1 else if match_lookahead_literal(parser, "/", 1) - _t1776 = 8 + _t1782 = 8 else if match_lookahead_literal(parser, "-", 1) - _t1777 = 6 + _t1783 = 6 else if match_lookahead_literal(parser, "+", 1) - _t1778 = 5 + _t1784 = 5 else if match_lookahead_literal(parser, "*", 1) - _t1779 = 7 + _t1785 = 7 else - _t1779 = -1 + _t1785 = -1 end - _t1778 = _t1779 + _t1784 = _t1785 end - _t1777 = _t1778 + _t1783 = _t1784 end - _t1776 = _t1777 + _t1782 = _t1783 end - _t1775 = _t1776 + _t1781 = _t1782 end - _t1774 = _t1775 + _t1780 = _t1781 end - _t1773 = _t1774 + _t1779 = _t1780 end - _t1772 = _t1773 + _t1778 = _t1779 end - _t1771 = _t1772 + _t1777 = _t1778 end - _t1770 = _t1771 + _t1776 = _t1777 end - _t1769 = _t1770 + _t1775 = _t1776 else - _t1769 = -1 + _t1775 = -1 end - prediction978 = _t1769 - if prediction978 == 9 + prediction981 = _t1775 + if prediction981 == 9 consume_literal!(parser, "(") consume_literal!(parser, "primitive") - _t1781 = parse_name(parser) - name988 = _t1781 - xs989 = Proto.RelTerm[] - cond990 = ((((((((((((((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 cond990 - _t1782 = parse_rel_term(parser) - item991 = _t1782 - push!(xs989, item991) - cond990 = ((((((((((((((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)) + _t1787 = parse_name(parser) + name991 = _t1787 + xs992 = Proto.RelTerm[] + cond993 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond993 + _t1788 = parse_rel_term(parser) + item994 = _t1788 + push!(xs992, item994) + cond993 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) end - rel_terms992 = xs989 + rel_terms995 = xs992 consume_literal!(parser, ")") - _t1783 = Proto.Primitive(name=name988, terms=rel_terms992) - _t1780 = _t1783 + _t1789 = Proto.Primitive(name=name991, terms=rel_terms995) + _t1786 = _t1789 else - if prediction978 == 8 - _t1785 = parse_divide(parser) - divide987 = _t1785 - _t1784 = divide987 + if prediction981 == 8 + _t1791 = parse_divide(parser) + divide990 = _t1791 + _t1790 = divide990 else - if prediction978 == 7 - _t1787 = parse_multiply(parser) - multiply986 = _t1787 - _t1786 = multiply986 + if prediction981 == 7 + _t1793 = parse_multiply(parser) + multiply989 = _t1793 + _t1792 = multiply989 else - if prediction978 == 6 - _t1789 = parse_minus(parser) - minus985 = _t1789 - _t1788 = minus985 + if prediction981 == 6 + _t1795 = parse_minus(parser) + minus988 = _t1795 + _t1794 = minus988 else - if prediction978 == 5 - _t1791 = parse_add(parser) - add984 = _t1791 - _t1790 = add984 + if prediction981 == 5 + _t1797 = parse_add(parser) + add987 = _t1797 + _t1796 = add987 else - if prediction978 == 4 - _t1793 = parse_gt_eq(parser) - gt_eq983 = _t1793 - _t1792 = gt_eq983 + if prediction981 == 4 + _t1799 = parse_gt_eq(parser) + gt_eq986 = _t1799 + _t1798 = gt_eq986 else - if prediction978 == 3 - _t1795 = parse_gt(parser) - gt982 = _t1795 - _t1794 = gt982 + if prediction981 == 3 + _t1801 = parse_gt(parser) + gt985 = _t1801 + _t1800 = gt985 else - if prediction978 == 2 - _t1797 = parse_lt_eq(parser) - lt_eq981 = _t1797 - _t1796 = lt_eq981 + if prediction981 == 2 + _t1803 = parse_lt_eq(parser) + lt_eq984 = _t1803 + _t1802 = lt_eq984 else - if prediction978 == 1 - _t1799 = parse_lt(parser) - lt980 = _t1799 - _t1798 = lt980 + if prediction981 == 1 + _t1805 = parse_lt(parser) + lt983 = _t1805 + _t1804 = lt983 else - if prediction978 == 0 - _t1801 = parse_eq(parser) - eq979 = _t1801 - _t1800 = eq979 + if prediction981 == 0 + _t1807 = parse_eq(parser) + eq982 = _t1807 + _t1806 = eq982 else throw(ParseError("Unexpected token in primitive" * ": " * string(lookahead(parser, 0)))) end - _t1798 = _t1800 + _t1804 = _t1806 end - _t1796 = _t1798 + _t1802 = _t1804 end - _t1794 = _t1796 + _t1800 = _t1802 end - _t1792 = _t1794 + _t1798 = _t1800 end - _t1790 = _t1792 + _t1796 = _t1798 end - _t1788 = _t1790 + _t1794 = _t1796 end - _t1786 = _t1788 + _t1792 = _t1794 end - _t1784 = _t1786 + _t1790 = _t1792 end - _t1780 = _t1784 + _t1786 = _t1790 end - result994 = _t1780 - record_span!(parser, span_start993, "Primitive") - return result994 + result997 = _t1786 + record_span!(parser, span_start996, "Primitive") + return result997 end function parse_eq(parser::ParserState)::Proto.Primitive - span_start997 = span_start(parser) + span_start1000 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "=") - _t1802 = parse_term(parser) - term995 = _t1802 - _t1803 = parse_term(parser) - term_3996 = _t1803 + _t1808 = parse_term(parser) + term998 = _t1808 + _t1809 = parse_term(parser) + term_3999 = _t1809 consume_literal!(parser, ")") - _t1804 = Proto.RelTerm(rel_term_type=OneOf(:term, term995)) - _t1805 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3996)) - _t1806 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1804, _t1805]) - result998 = _t1806 - record_span!(parser, span_start997, "Primitive") - return result998 + _t1810 = Proto.RelTerm(rel_term_type=OneOf(:term, term998)) + _t1811 = Proto.RelTerm(rel_term_type=OneOf(:term, term_3999)) + _t1812 = Proto.Primitive(name="rel_primitive_eq", terms=Proto.RelTerm[_t1810, _t1811]) + result1001 = _t1812 + record_span!(parser, span_start1000, "Primitive") + return result1001 end function parse_lt(parser::ParserState)::Proto.Primitive - span_start1001 = span_start(parser) + span_start1004 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<") - _t1807 = parse_term(parser) - term999 = _t1807 - _t1808 = parse_term(parser) - term_31000 = _t1808 + _t1813 = parse_term(parser) + term1002 = _t1813 + _t1814 = parse_term(parser) + term_31003 = _t1814 consume_literal!(parser, ")") - _t1809 = Proto.RelTerm(rel_term_type=OneOf(:term, term999)) - _t1810 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31000)) - _t1811 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1809, _t1810]) - result1002 = _t1811 - record_span!(parser, span_start1001, "Primitive") - return result1002 + _t1815 = Proto.RelTerm(rel_term_type=OneOf(:term, term1002)) + _t1816 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31003)) + _t1817 = Proto.Primitive(name="rel_primitive_lt_monotype", terms=Proto.RelTerm[_t1815, _t1816]) + result1005 = _t1817 + record_span!(parser, span_start1004, "Primitive") + return result1005 end function parse_lt_eq(parser::ParserState)::Proto.Primitive - span_start1005 = span_start(parser) + span_start1008 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "<=") - _t1812 = parse_term(parser) - term1003 = _t1812 - _t1813 = parse_term(parser) - term_31004 = _t1813 + _t1818 = parse_term(parser) + term1006 = _t1818 + _t1819 = parse_term(parser) + term_31007 = _t1819 consume_literal!(parser, ")") - _t1814 = Proto.RelTerm(rel_term_type=OneOf(:term, term1003)) - _t1815 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31004)) - _t1816 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1814, _t1815]) - result1006 = _t1816 - record_span!(parser, span_start1005, "Primitive") - return result1006 + _t1820 = Proto.RelTerm(rel_term_type=OneOf(:term, term1006)) + _t1821 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31007)) + _t1822 = Proto.Primitive(name="rel_primitive_lt_eq_monotype", terms=Proto.RelTerm[_t1820, _t1821]) + result1009 = _t1822 + record_span!(parser, span_start1008, "Primitive") + return result1009 end function parse_gt(parser::ParserState)::Proto.Primitive - span_start1009 = span_start(parser) + span_start1012 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">") - _t1817 = parse_term(parser) - term1007 = _t1817 - _t1818 = parse_term(parser) - term_31008 = _t1818 + _t1823 = parse_term(parser) + term1010 = _t1823 + _t1824 = parse_term(parser) + term_31011 = _t1824 consume_literal!(parser, ")") - _t1819 = Proto.RelTerm(rel_term_type=OneOf(:term, term1007)) - _t1820 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31008)) - _t1821 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1819, _t1820]) - result1010 = _t1821 - record_span!(parser, span_start1009, "Primitive") - return result1010 + _t1825 = Proto.RelTerm(rel_term_type=OneOf(:term, term1010)) + _t1826 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31011)) + _t1827 = Proto.Primitive(name="rel_primitive_gt_monotype", terms=Proto.RelTerm[_t1825, _t1826]) + result1013 = _t1827 + record_span!(parser, span_start1012, "Primitive") + return result1013 end function parse_gt_eq(parser::ParserState)::Proto.Primitive - span_start1013 = span_start(parser) + span_start1016 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, ">=") - _t1822 = parse_term(parser) - term1011 = _t1822 - _t1823 = parse_term(parser) - term_31012 = _t1823 + _t1828 = parse_term(parser) + term1014 = _t1828 + _t1829 = parse_term(parser) + term_31015 = _t1829 consume_literal!(parser, ")") - _t1824 = Proto.RelTerm(rel_term_type=OneOf(:term, term1011)) - _t1825 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31012)) - _t1826 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1824, _t1825]) - result1014 = _t1826 - record_span!(parser, span_start1013, "Primitive") - return result1014 + _t1830 = Proto.RelTerm(rel_term_type=OneOf(:term, term1014)) + _t1831 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31015)) + _t1832 = Proto.Primitive(name="rel_primitive_gt_eq_monotype", terms=Proto.RelTerm[_t1830, _t1831]) + result1017 = _t1832 + record_span!(parser, span_start1016, "Primitive") + return result1017 end function parse_add(parser::ParserState)::Proto.Primitive - span_start1018 = span_start(parser) + span_start1021 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "+") - _t1827 = parse_term(parser) - term1015 = _t1827 - _t1828 = parse_term(parser) - term_31016 = _t1828 - _t1829 = parse_term(parser) - term_41017 = _t1829 + _t1833 = parse_term(parser) + term1018 = _t1833 + _t1834 = parse_term(parser) + term_31019 = _t1834 + _t1835 = parse_term(parser) + term_41020 = _t1835 consume_literal!(parser, ")") - _t1830 = Proto.RelTerm(rel_term_type=OneOf(:term, term1015)) - _t1831 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31016)) - _t1832 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41017)) - _t1833 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1830, _t1831, _t1832]) - result1019 = _t1833 - record_span!(parser, span_start1018, "Primitive") - return result1019 + _t1836 = Proto.RelTerm(rel_term_type=OneOf(:term, term1018)) + _t1837 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31019)) + _t1838 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41020)) + _t1839 = Proto.Primitive(name="rel_primitive_add_monotype", terms=Proto.RelTerm[_t1836, _t1837, _t1838]) + result1022 = _t1839 + record_span!(parser, span_start1021, "Primitive") + return result1022 end function parse_minus(parser::ParserState)::Proto.Primitive - span_start1023 = span_start(parser) + span_start1026 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "-") - _t1834 = parse_term(parser) - term1020 = _t1834 - _t1835 = parse_term(parser) - term_31021 = _t1835 - _t1836 = parse_term(parser) - term_41022 = _t1836 + _t1840 = parse_term(parser) + term1023 = _t1840 + _t1841 = parse_term(parser) + term_31024 = _t1841 + _t1842 = parse_term(parser) + term_41025 = _t1842 consume_literal!(parser, ")") - _t1837 = Proto.RelTerm(rel_term_type=OneOf(:term, term1020)) - _t1838 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31021)) - _t1839 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41022)) - _t1840 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1837, _t1838, _t1839]) - result1024 = _t1840 - record_span!(parser, span_start1023, "Primitive") - return result1024 + _t1843 = Proto.RelTerm(rel_term_type=OneOf(:term, term1023)) + _t1844 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31024)) + _t1845 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41025)) + _t1846 = Proto.Primitive(name="rel_primitive_subtract_monotype", terms=Proto.RelTerm[_t1843, _t1844, _t1845]) + result1027 = _t1846 + record_span!(parser, span_start1026, "Primitive") + return result1027 end function parse_multiply(parser::ParserState)::Proto.Primitive - span_start1028 = span_start(parser) + span_start1031 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "*") - _t1841 = parse_term(parser) - term1025 = _t1841 - _t1842 = parse_term(parser) - term_31026 = _t1842 - _t1843 = parse_term(parser) - term_41027 = _t1843 + _t1847 = parse_term(parser) + term1028 = _t1847 + _t1848 = parse_term(parser) + term_31029 = _t1848 + _t1849 = parse_term(parser) + term_41030 = _t1849 consume_literal!(parser, ")") - _t1844 = Proto.RelTerm(rel_term_type=OneOf(:term, term1025)) - _t1845 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31026)) - _t1846 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41027)) - _t1847 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1844, _t1845, _t1846]) - result1029 = _t1847 - record_span!(parser, span_start1028, "Primitive") - return result1029 + _t1850 = Proto.RelTerm(rel_term_type=OneOf(:term, term1028)) + _t1851 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31029)) + _t1852 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41030)) + _t1853 = Proto.Primitive(name="rel_primitive_multiply_monotype", terms=Proto.RelTerm[_t1850, _t1851, _t1852]) + result1032 = _t1853 + record_span!(parser, span_start1031, "Primitive") + return result1032 end function parse_divide(parser::ParserState)::Proto.Primitive - span_start1033 = span_start(parser) + span_start1036 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "/") - _t1848 = parse_term(parser) - term1030 = _t1848 - _t1849 = parse_term(parser) - term_31031 = _t1849 - _t1850 = parse_term(parser) - term_41032 = _t1850 + _t1854 = parse_term(parser) + term1033 = _t1854 + _t1855 = parse_term(parser) + term_31034 = _t1855 + _t1856 = parse_term(parser) + term_41035 = _t1856 consume_literal!(parser, ")") - _t1851 = Proto.RelTerm(rel_term_type=OneOf(:term, term1030)) - _t1852 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31031)) - _t1853 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41032)) - _t1854 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1851, _t1852, _t1853]) - result1034 = _t1854 - record_span!(parser, span_start1033, "Primitive") - return result1034 + _t1857 = Proto.RelTerm(rel_term_type=OneOf(:term, term1033)) + _t1858 = Proto.RelTerm(rel_term_type=OneOf(:term, term_31034)) + _t1859 = Proto.RelTerm(rel_term_type=OneOf(:term, term_41035)) + _t1860 = Proto.Primitive(name="rel_primitive_divide_monotype", terms=Proto.RelTerm[_t1857, _t1858, _t1859]) + result1037 = _t1860 + record_span!(parser, span_start1036, "Primitive") + return result1037 end function parse_rel_term(parser::ParserState)::Proto.RelTerm - span_start1038 = span_start(parser) + span_start1041 = span_start(parser) if match_lookahead_literal(parser, "true", 0) - _t1855 = 1 + _t1861 = 1 else if match_lookahead_literal(parser, "missing", 0) - _t1856 = 1 + _t1862 = 1 else if match_lookahead_literal(parser, "false", 0) - _t1857 = 1 + _t1863 = 1 else if match_lookahead_literal(parser, "(", 0) - _t1858 = 1 + _t1864 = 1 else if match_lookahead_literal(parser, "#", 0) - _t1859 = 0 + _t1865 = 0 else if match_lookahead_terminal(parser, "SYMBOL", 0) - _t1860 = 1 + _t1866 = 1 else if match_lookahead_terminal(parser, "UINT32", 0) - _t1861 = 1 + _t1867 = 1 else if match_lookahead_terminal(parser, "UINT128", 0) - _t1862 = 1 + _t1868 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t1863 = 1 + _t1869 = 1 else if match_lookahead_terminal(parser, "INT32", 0) - _t1864 = 1 + _t1870 = 1 else if match_lookahead_terminal(parser, "INT128", 0) - _t1865 = 1 + _t1871 = 1 else if match_lookahead_terminal(parser, "INT", 0) - _t1866 = 1 + _t1872 = 1 else if match_lookahead_terminal(parser, "FLOAT32", 0) - _t1867 = 1 + _t1873 = 1 else if match_lookahead_terminal(parser, "FLOAT", 0) - _t1868 = 1 + _t1874 = 1 else if match_lookahead_terminal(parser, "DECIMAL", 0) - _t1869 = 1 + _t1875 = 1 else - _t1869 = -1 + _t1875 = -1 end - _t1868 = _t1869 + _t1874 = _t1875 end - _t1867 = _t1868 + _t1873 = _t1874 end - _t1866 = _t1867 + _t1872 = _t1873 end - _t1865 = _t1866 + _t1871 = _t1872 end - _t1864 = _t1865 + _t1870 = _t1871 end - _t1863 = _t1864 + _t1869 = _t1870 end - _t1862 = _t1863 + _t1868 = _t1869 end - _t1861 = _t1862 + _t1867 = _t1868 end - _t1860 = _t1861 + _t1866 = _t1867 end - _t1859 = _t1860 + _t1865 = _t1866 end - _t1858 = _t1859 + _t1864 = _t1865 end - _t1857 = _t1858 + _t1863 = _t1864 end - _t1856 = _t1857 + _t1862 = _t1863 end - _t1855 = _t1856 - end - prediction1035 = _t1855 - if prediction1035 == 1 - _t1871 = parse_term(parser) - term1037 = _t1871 - _t1872 = Proto.RelTerm(rel_term_type=OneOf(:term, term1037)) - _t1870 = _t1872 + _t1861 = _t1862 + end + prediction1038 = _t1861 + if prediction1038 == 1 + _t1877 = parse_term(parser) + term1040 = _t1877 + _t1878 = Proto.RelTerm(rel_term_type=OneOf(:term, term1040)) + _t1876 = _t1878 else - if prediction1035 == 0 - _t1874 = parse_specialized_value(parser) - specialized_value1036 = _t1874 - _t1875 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1036)) - _t1873 = _t1875 + if prediction1038 == 0 + _t1880 = parse_specialized_value(parser) + specialized_value1039 = _t1880 + _t1881 = Proto.RelTerm(rel_term_type=OneOf(:specialized_value, specialized_value1039)) + _t1879 = _t1881 else throw(ParseError("Unexpected token in rel_term" * ": " * string(lookahead(parser, 0)))) end - _t1870 = _t1873 + _t1876 = _t1879 end - result1039 = _t1870 - record_span!(parser, span_start1038, "RelTerm") - return result1039 + result1042 = _t1876 + record_span!(parser, span_start1041, "RelTerm") + return result1042 end function parse_specialized_value(parser::ParserState)::Proto.Value - span_start1041 = span_start(parser) + span_start1044 = span_start(parser) consume_literal!(parser, "#") - _t1876 = parse_raw_value(parser) - raw_value1040 = _t1876 - result1042 = raw_value1040 - record_span!(parser, span_start1041, "Value") - return result1042 + _t1882 = parse_raw_value(parser) + raw_value1043 = _t1882 + result1045 = raw_value1043 + record_span!(parser, span_start1044, "Value") + return result1045 end function parse_rel_atom(parser::ParserState)::Proto.RelAtom - span_start1048 = span_start(parser) + span_start1051 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relatom") - _t1877 = parse_name(parser) - name1043 = _t1877 - xs1044 = Proto.RelTerm[] - cond1045 = ((((((((((((((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 cond1045 - _t1878 = parse_rel_term(parser) - item1046 = _t1878 - push!(xs1044, item1046) - cond1045 = ((((((((((((((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_terms1047 = xs1044 + _t1883 = parse_name(parser) + name1046 = _t1883 + xs1047 = Proto.RelTerm[] + cond1048 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + while cond1048 + _t1884 = parse_rel_term(parser) + item1049 = _t1884 + push!(xs1047, item1049) + cond1048 = ((((((((((((((match_lookahead_literal(parser, "#", 0) || match_lookahead_literal(parser, "(", 0)) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) || match_lookahead_terminal(parser, "SYMBOL", 0)) + end + rel_terms1050 = xs1047 consume_literal!(parser, ")") - _t1879 = Proto.RelAtom(name=name1043, terms=rel_terms1047) - result1049 = _t1879 - record_span!(parser, span_start1048, "RelAtom") - return result1049 + _t1885 = Proto.RelAtom(name=name1046, terms=rel_terms1050) + result1052 = _t1885 + record_span!(parser, span_start1051, "RelAtom") + return result1052 end function parse_cast(parser::ParserState)::Proto.Cast - span_start1052 = span_start(parser) + span_start1055 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "cast") - _t1880 = parse_term(parser) - term1050 = _t1880 - _t1881 = parse_term(parser) - term_31051 = _t1881 + _t1886 = parse_term(parser) + term1053 = _t1886 + _t1887 = parse_term(parser) + term_31054 = _t1887 consume_literal!(parser, ")") - _t1882 = Proto.Cast(input=term1050, result=term_31051) - result1053 = _t1882 - record_span!(parser, span_start1052, "Cast") - return result1053 + _t1888 = Proto.Cast(input=term1053, result=term_31054) + result1056 = _t1888 + record_span!(parser, span_start1055, "Cast") + return result1056 end function parse_attrs(parser::ParserState)::Vector{Proto.Attribute} consume_literal!(parser, "(") consume_literal!(parser, "attrs") - xs1054 = Proto.Attribute[] - cond1055 = match_lookahead_literal(parser, "(", 0) - while cond1055 - _t1883 = parse_attribute(parser) - item1056 = _t1883 - push!(xs1054, item1056) - cond1055 = match_lookahead_literal(parser, "(", 0) - end - attributes1057 = xs1054 + xs1057 = Proto.Attribute[] + cond1058 = match_lookahead_literal(parser, "(", 0) + while cond1058 + _t1889 = parse_attribute(parser) + item1059 = _t1889 + push!(xs1057, item1059) + cond1058 = match_lookahead_literal(parser, "(", 0) + end + attributes1060 = xs1057 consume_literal!(parser, ")") - return attributes1057 + return attributes1060 end function parse_attribute(parser::ParserState)::Proto.Attribute - span_start1063 = span_start(parser) + span_start1066 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "attribute") - _t1884 = parse_name(parser) - name1058 = _t1884 - xs1059 = Proto.Value[] - cond1060 = ((((((((((((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 cond1060 - _t1885 = parse_raw_value(parser) - item1061 = _t1885 - push!(xs1059, item1061) - cond1060 = ((((((((((((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_values1062 = xs1059 + _t1890 = parse_name(parser) + name1061 = _t1890 + xs1062 = Proto.Value[] + cond1063 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) + while cond1063 + _t1891 = parse_raw_value(parser) + item1064 = _t1891 + push!(xs1062, item1064) + cond1063 = ((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "false", 0)) || match_lookahead_literal(parser, "missing", 0)) || match_lookahead_literal(parser, "true", 0)) || match_lookahead_terminal(parser, "DECIMAL", 0)) || match_lookahead_terminal(parser, "FLOAT", 0)) || match_lookahead_terminal(parser, "FLOAT32", 0)) || match_lookahead_terminal(parser, "INT", 0)) || match_lookahead_terminal(parser, "INT128", 0)) || match_lookahead_terminal(parser, "INT32", 0)) || match_lookahead_terminal(parser, "STRING", 0)) || match_lookahead_terminal(parser, "UINT128", 0)) || match_lookahead_terminal(parser, "UINT32", 0)) + end + raw_values1065 = xs1062 consume_literal!(parser, ")") - _t1886 = Proto.Attribute(name=name1058, args=raw_values1062) - result1064 = _t1886 - record_span!(parser, span_start1063, "Attribute") - return result1064 + _t1892 = Proto.Attribute(name=name1061, args=raw_values1065) + result1067 = _t1892 + record_span!(parser, span_start1066, "Attribute") + return result1067 end function parse_algorithm(parser::ParserState)::Proto.Algorithm - span_start1071 = span_start(parser) + span_start1074 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "algorithm") - xs1065 = Proto.RelationId[] - cond1066 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1066 - _t1887 = parse_relation_id(parser) - item1067 = _t1887 - push!(xs1065, item1067) - cond1066 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1068 = xs1065 - _t1888 = parse_script(parser) - script1069 = _t1888 + xs1068 = Proto.RelationId[] + cond1069 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1069 + _t1893 = parse_relation_id(parser) + item1070 = _t1893 + push!(xs1068, item1070) + cond1069 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1071 = xs1068 + _t1894 = parse_script(parser) + script1072 = _t1894 if match_lookahead_literal(parser, "(", 0) - _t1890 = parse_attrs(parser) - _t1889 = _t1890 + _t1896 = parse_attrs(parser) + _t1895 = _t1896 else - _t1889 = nothing + _t1895 = nothing end - attrs1070 = _t1889 + attrs1073 = _t1895 consume_literal!(parser, ")") - _t1891 = Proto.Algorithm(var"#global"=relation_ids1068, body=script1069, attrs=(!isnothing(attrs1070) ? attrs1070 : Proto.Attribute[])) - result1072 = _t1891 - record_span!(parser, span_start1071, "Algorithm") - return result1072 + _t1897 = Proto.Algorithm(var"#global"=relation_ids1071, body=script1072, attrs=(!isnothing(attrs1073) ? attrs1073 : Proto.Attribute[])) + result1075 = _t1897 + record_span!(parser, span_start1074, "Algorithm") + return result1075 end function parse_script(parser::ParserState)::Proto.Script - span_start1077 = span_start(parser) + span_start1080 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "script") - xs1073 = Proto.Construct[] - cond1074 = match_lookahead_literal(parser, "(", 0) - while cond1074 - _t1892 = parse_construct(parser) - item1075 = _t1892 - push!(xs1073, item1075) - cond1074 = match_lookahead_literal(parser, "(", 0) - end - constructs1076 = xs1073 + xs1076 = Proto.Construct[] + cond1077 = match_lookahead_literal(parser, "(", 0) + while cond1077 + _t1898 = parse_construct(parser) + item1078 = _t1898 + push!(xs1076, item1078) + cond1077 = match_lookahead_literal(parser, "(", 0) + end + constructs1079 = xs1076 consume_literal!(parser, ")") - _t1893 = Proto.Script(constructs=constructs1076) - result1078 = _t1893 - record_span!(parser, span_start1077, "Script") - return result1078 + _t1899 = Proto.Script(constructs=constructs1079) + result1081 = _t1899 + record_span!(parser, span_start1080, "Script") + return result1081 end function parse_construct(parser::ParserState)::Proto.Construct - span_start1082 = span_start(parser) + span_start1085 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1895 = 1 + _t1901 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1896 = 1 + _t1902 = 1 else if match_lookahead_literal(parser, "monoid", 1) - _t1897 = 1 + _t1903 = 1 else if match_lookahead_literal(parser, "loop", 1) - _t1898 = 0 + _t1904 = 0 else if match_lookahead_literal(parser, "break", 1) - _t1899 = 1 + _t1905 = 1 else if match_lookahead_literal(parser, "assign", 1) - _t1900 = 1 + _t1906 = 1 else - _t1900 = -1 + _t1906 = -1 end - _t1899 = _t1900 + _t1905 = _t1906 end - _t1898 = _t1899 + _t1904 = _t1905 end - _t1897 = _t1898 + _t1903 = _t1904 end - _t1896 = _t1897 + _t1902 = _t1903 end - _t1895 = _t1896 + _t1901 = _t1902 end - _t1894 = _t1895 + _t1900 = _t1901 else - _t1894 = -1 - end - prediction1079 = _t1894 - if prediction1079 == 1 - _t1902 = parse_instruction(parser) - instruction1081 = _t1902 - _t1903 = Proto.Construct(construct_type=OneOf(:instruction, instruction1081)) - _t1901 = _t1903 + _t1900 = -1 + end + prediction1082 = _t1900 + if prediction1082 == 1 + _t1908 = parse_instruction(parser) + instruction1084 = _t1908 + _t1909 = Proto.Construct(construct_type=OneOf(:instruction, instruction1084)) + _t1907 = _t1909 else - if prediction1079 == 0 - _t1905 = parse_loop(parser) - loop1080 = _t1905 - _t1906 = Proto.Construct(construct_type=OneOf(:loop, loop1080)) - _t1904 = _t1906 + if prediction1082 == 0 + _t1911 = parse_loop(parser) + loop1083 = _t1911 + _t1912 = Proto.Construct(construct_type=OneOf(:loop, loop1083)) + _t1910 = _t1912 else throw(ParseError("Unexpected token in construct" * ": " * string(lookahead(parser, 0)))) end - _t1901 = _t1904 + _t1907 = _t1910 end - result1083 = _t1901 - record_span!(parser, span_start1082, "Construct") - return result1083 + result1086 = _t1907 + record_span!(parser, span_start1085, "Construct") + return result1086 end function parse_loop(parser::ParserState)::Proto.Loop - span_start1087 = span_start(parser) + span_start1090 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "loop") - _t1907 = parse_init(parser) - init1084 = _t1907 - _t1908 = parse_script(parser) - script1085 = _t1908 + _t1913 = parse_init(parser) + init1087 = _t1913 + _t1914 = parse_script(parser) + script1088 = _t1914 if match_lookahead_literal(parser, "(", 0) - _t1910 = parse_attrs(parser) - _t1909 = _t1910 + _t1916 = parse_attrs(parser) + _t1915 = _t1916 else - _t1909 = nothing + _t1915 = nothing end - attrs1086 = _t1909 + attrs1089 = _t1915 consume_literal!(parser, ")") - _t1911 = Proto.Loop(init=init1084, body=script1085, attrs=(!isnothing(attrs1086) ? attrs1086 : Proto.Attribute[])) - result1088 = _t1911 - record_span!(parser, span_start1087, "Loop") - return result1088 + _t1917 = Proto.Loop(init=init1087, body=script1088, attrs=(!isnothing(attrs1089) ? attrs1089 : Proto.Attribute[])) + result1091 = _t1917 + record_span!(parser, span_start1090, "Loop") + return result1091 end function parse_init(parser::ParserState)::Vector{Proto.Instruction} consume_literal!(parser, "(") consume_literal!(parser, "init") - xs1089 = Proto.Instruction[] - cond1090 = match_lookahead_literal(parser, "(", 0) - while cond1090 - _t1912 = parse_instruction(parser) - item1091 = _t1912 - push!(xs1089, item1091) - cond1090 = match_lookahead_literal(parser, "(", 0) - end - instructions1092 = xs1089 + xs1092 = Proto.Instruction[] + cond1093 = match_lookahead_literal(parser, "(", 0) + while cond1093 + _t1918 = parse_instruction(parser) + item1094 = _t1918 + push!(xs1092, item1094) + cond1093 = match_lookahead_literal(parser, "(", 0) + end + instructions1095 = xs1092 consume_literal!(parser, ")") - return instructions1092 + return instructions1095 end function parse_instruction(parser::ParserState)::Proto.Instruction - span_start1099 = span_start(parser) + span_start1102 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "upsert", 1) - _t1914 = 1 + _t1920 = 1 else if match_lookahead_literal(parser, "monus", 1) - _t1915 = 4 + _t1921 = 4 else if match_lookahead_literal(parser, "monoid", 1) - _t1916 = 3 + _t1922 = 3 else if match_lookahead_literal(parser, "break", 1) - _t1917 = 2 + _t1923 = 2 else if match_lookahead_literal(parser, "assign", 1) - _t1918 = 0 + _t1924 = 0 else - _t1918 = -1 + _t1924 = -1 end - _t1917 = _t1918 + _t1923 = _t1924 end - _t1916 = _t1917 + _t1922 = _t1923 end - _t1915 = _t1916 + _t1921 = _t1922 end - _t1914 = _t1915 + _t1920 = _t1921 end - _t1913 = _t1914 + _t1919 = _t1920 else - _t1913 = -1 - end - prediction1093 = _t1913 - if prediction1093 == 4 - _t1920 = parse_monus_def(parser) - monus_def1098 = _t1920 - _t1921 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1098)) - _t1919 = _t1921 + _t1919 = -1 + end + prediction1096 = _t1919 + if prediction1096 == 4 + _t1926 = parse_monus_def(parser) + monus_def1101 = _t1926 + _t1927 = Proto.Instruction(instr_type=OneOf(:monus_def, monus_def1101)) + _t1925 = _t1927 else - if prediction1093 == 3 - _t1923 = parse_monoid_def(parser) - monoid_def1097 = _t1923 - _t1924 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1097)) - _t1922 = _t1924 + if prediction1096 == 3 + _t1929 = parse_monoid_def(parser) + monoid_def1100 = _t1929 + _t1930 = Proto.Instruction(instr_type=OneOf(:monoid_def, monoid_def1100)) + _t1928 = _t1930 else - if prediction1093 == 2 - _t1926 = parse_break(parser) - break1096 = _t1926 - _t1927 = Proto.Instruction(instr_type=OneOf(:var"#break", break1096)) - _t1925 = _t1927 + if prediction1096 == 2 + _t1932 = parse_break(parser) + break1099 = _t1932 + _t1933 = Proto.Instruction(instr_type=OneOf(:var"#break", break1099)) + _t1931 = _t1933 else - if prediction1093 == 1 - _t1929 = parse_upsert(parser) - upsert1095 = _t1929 - _t1930 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1095)) - _t1928 = _t1930 + if prediction1096 == 1 + _t1935 = parse_upsert(parser) + upsert1098 = _t1935 + _t1936 = Proto.Instruction(instr_type=OneOf(:upsert, upsert1098)) + _t1934 = _t1936 else - if prediction1093 == 0 - _t1932 = parse_assign(parser) - assign1094 = _t1932 - _t1933 = Proto.Instruction(instr_type=OneOf(:assign, assign1094)) - _t1931 = _t1933 + if prediction1096 == 0 + _t1938 = parse_assign(parser) + assign1097 = _t1938 + _t1939 = Proto.Instruction(instr_type=OneOf(:assign, assign1097)) + _t1937 = _t1939 else throw(ParseError("Unexpected token in instruction" * ": " * string(lookahead(parser, 0)))) end - _t1928 = _t1931 + _t1934 = _t1937 end - _t1925 = _t1928 + _t1931 = _t1934 end - _t1922 = _t1925 + _t1928 = _t1931 end - _t1919 = _t1922 + _t1925 = _t1928 end - result1100 = _t1919 - record_span!(parser, span_start1099, "Instruction") - return result1100 + result1103 = _t1925 + record_span!(parser, span_start1102, "Instruction") + return result1103 end function parse_assign(parser::ParserState)::Proto.Assign - span_start1104 = span_start(parser) + span_start1107 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "assign") - _t1934 = parse_relation_id(parser) - relation_id1101 = _t1934 - _t1935 = parse_abstraction(parser) - abstraction1102 = _t1935 + _t1940 = parse_relation_id(parser) + relation_id1104 = _t1940 + _t1941 = parse_abstraction(parser) + abstraction1105 = _t1941 if match_lookahead_literal(parser, "(", 0) - _t1937 = parse_attrs(parser) - _t1936 = _t1937 + _t1943 = parse_attrs(parser) + _t1942 = _t1943 else - _t1936 = nothing + _t1942 = nothing end - attrs1103 = _t1936 + attrs1106 = _t1942 consume_literal!(parser, ")") - _t1938 = Proto.Assign(name=relation_id1101, body=abstraction1102, attrs=(!isnothing(attrs1103) ? attrs1103 : Proto.Attribute[])) - result1105 = _t1938 - record_span!(parser, span_start1104, "Assign") - return result1105 + _t1944 = Proto.Assign(name=relation_id1104, body=abstraction1105, attrs=(!isnothing(attrs1106) ? attrs1106 : Proto.Attribute[])) + result1108 = _t1944 + record_span!(parser, span_start1107, "Assign") + return result1108 end function parse_upsert(parser::ParserState)::Proto.Upsert - span_start1109 = span_start(parser) + span_start1112 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "upsert") - _t1939 = parse_relation_id(parser) - relation_id1106 = _t1939 - _t1940 = parse_abstraction_with_arity(parser) - abstraction_with_arity1107 = _t1940 + _t1945 = parse_relation_id(parser) + relation_id1109 = _t1945 + _t1946 = parse_abstraction_with_arity(parser) + abstraction_with_arity1110 = _t1946 if match_lookahead_literal(parser, "(", 0) - _t1942 = parse_attrs(parser) - _t1941 = _t1942 + _t1948 = parse_attrs(parser) + _t1947 = _t1948 else - _t1941 = nothing + _t1947 = nothing end - attrs1108 = _t1941 + attrs1111 = _t1947 consume_literal!(parser, ")") - _t1943 = Proto.Upsert(name=relation_id1106, body=abstraction_with_arity1107[1], attrs=(!isnothing(attrs1108) ? attrs1108 : Proto.Attribute[]), value_arity=abstraction_with_arity1107[2]) - result1110 = _t1943 - record_span!(parser, span_start1109, "Upsert") - return result1110 + _t1949 = Proto.Upsert(name=relation_id1109, body=abstraction_with_arity1110[1], attrs=(!isnothing(attrs1111) ? attrs1111 : Proto.Attribute[]), value_arity=abstraction_with_arity1110[2]) + result1113 = _t1949 + record_span!(parser, span_start1112, "Upsert") + return result1113 end function parse_abstraction_with_arity(parser::ParserState)::Tuple{Proto.Abstraction, Int64} consume_literal!(parser, "(") - _t1944 = parse_bindings(parser) - bindings1111 = _t1944 - _t1945 = parse_formula(parser) - formula1112 = _t1945 + _t1950 = parse_bindings(parser) + bindings1114 = _t1950 + _t1951 = parse_formula(parser) + formula1115 = _t1951 consume_literal!(parser, ")") - _t1946 = Proto.Abstraction(vars=vcat(bindings1111[1], !isnothing(bindings1111[2]) ? bindings1111[2] : []), value=formula1112) - return (_t1946, length(bindings1111[2]),) + _t1952 = Proto.Abstraction(vars=vcat(bindings1114[1], !isnothing(bindings1114[2]) ? bindings1114[2] : []), value=formula1115) + return (_t1952, length(bindings1114[2]),) end function parse_break(parser::ParserState)::Proto.Break - span_start1116 = span_start(parser) + span_start1119 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "break") - _t1947 = parse_relation_id(parser) - relation_id1113 = _t1947 - _t1948 = parse_abstraction(parser) - abstraction1114 = _t1948 + _t1953 = parse_relation_id(parser) + relation_id1116 = _t1953 + _t1954 = parse_abstraction(parser) + abstraction1117 = _t1954 if match_lookahead_literal(parser, "(", 0) - _t1950 = parse_attrs(parser) - _t1949 = _t1950 + _t1956 = parse_attrs(parser) + _t1955 = _t1956 else - _t1949 = nothing + _t1955 = nothing end - attrs1115 = _t1949 + attrs1118 = _t1955 consume_literal!(parser, ")") - _t1951 = Proto.Break(name=relation_id1113, body=abstraction1114, attrs=(!isnothing(attrs1115) ? attrs1115 : Proto.Attribute[])) - result1117 = _t1951 - record_span!(parser, span_start1116, "Break") - return result1117 + _t1957 = Proto.Break(name=relation_id1116, body=abstraction1117, attrs=(!isnothing(attrs1118) ? attrs1118 : Proto.Attribute[])) + result1120 = _t1957 + record_span!(parser, span_start1119, "Break") + return result1120 end function parse_monoid_def(parser::ParserState)::Proto.MonoidDef - span_start1122 = span_start(parser) + span_start1125 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monoid") - _t1952 = parse_monoid(parser) - monoid1118 = _t1952 - _t1953 = parse_relation_id(parser) - relation_id1119 = _t1953 - _t1954 = parse_abstraction_with_arity(parser) - abstraction_with_arity1120 = _t1954 + _t1958 = parse_monoid(parser) + monoid1121 = _t1958 + _t1959 = parse_relation_id(parser) + relation_id1122 = _t1959 + _t1960 = parse_abstraction_with_arity(parser) + abstraction_with_arity1123 = _t1960 if match_lookahead_literal(parser, "(", 0) - _t1956 = parse_attrs(parser) - _t1955 = _t1956 + _t1962 = parse_attrs(parser) + _t1961 = _t1962 else - _t1955 = nothing + _t1961 = nothing end - attrs1121 = _t1955 + attrs1124 = _t1961 consume_literal!(parser, ")") - _t1957 = Proto.MonoidDef(monoid=monoid1118, name=relation_id1119, body=abstraction_with_arity1120[1], attrs=(!isnothing(attrs1121) ? attrs1121 : Proto.Attribute[]), value_arity=abstraction_with_arity1120[2]) - result1123 = _t1957 - record_span!(parser, span_start1122, "MonoidDef") - return result1123 + _t1963 = Proto.MonoidDef(monoid=monoid1121, name=relation_id1122, body=abstraction_with_arity1123[1], attrs=(!isnothing(attrs1124) ? attrs1124 : Proto.Attribute[]), value_arity=abstraction_with_arity1123[2]) + result1126 = _t1963 + record_span!(parser, span_start1125, "MonoidDef") + return result1126 end function parse_monoid(parser::ParserState)::Proto.Monoid - span_start1129 = span_start(parser) + span_start1132 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "sum", 1) - _t1959 = 3 + _t1965 = 3 else if match_lookahead_literal(parser, "or", 1) - _t1960 = 0 + _t1966 = 0 else if match_lookahead_literal(parser, "min", 1) - _t1961 = 1 + _t1967 = 1 else if match_lookahead_literal(parser, "max", 1) - _t1962 = 2 + _t1968 = 2 else - _t1962 = -1 + _t1968 = -1 end - _t1961 = _t1962 + _t1967 = _t1968 end - _t1960 = _t1961 + _t1966 = _t1967 end - _t1959 = _t1960 + _t1965 = _t1966 end - _t1958 = _t1959 + _t1964 = _t1965 else - _t1958 = -1 - end - prediction1124 = _t1958 - if prediction1124 == 3 - _t1964 = parse_sum_monoid(parser) - sum_monoid1128 = _t1964 - _t1965 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1128)) - _t1963 = _t1965 + _t1964 = -1 + end + prediction1127 = _t1964 + if prediction1127 == 3 + _t1970 = parse_sum_monoid(parser) + sum_monoid1131 = _t1970 + _t1971 = Proto.Monoid(value=OneOf(:sum_monoid, sum_monoid1131)) + _t1969 = _t1971 else - if prediction1124 == 2 - _t1967 = parse_max_monoid(parser) - max_monoid1127 = _t1967 - _t1968 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1127)) - _t1966 = _t1968 + if prediction1127 == 2 + _t1973 = parse_max_monoid(parser) + max_monoid1130 = _t1973 + _t1974 = Proto.Monoid(value=OneOf(:max_monoid, max_monoid1130)) + _t1972 = _t1974 else - if prediction1124 == 1 - _t1970 = parse_min_monoid(parser) - min_monoid1126 = _t1970 - _t1971 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1126)) - _t1969 = _t1971 + if prediction1127 == 1 + _t1976 = parse_min_monoid(parser) + min_monoid1129 = _t1976 + _t1977 = Proto.Monoid(value=OneOf(:min_monoid, min_monoid1129)) + _t1975 = _t1977 else - if prediction1124 == 0 - _t1973 = parse_or_monoid(parser) - or_monoid1125 = _t1973 - _t1974 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1125)) - _t1972 = _t1974 + if prediction1127 == 0 + _t1979 = parse_or_monoid(parser) + or_monoid1128 = _t1979 + _t1980 = Proto.Monoid(value=OneOf(:or_monoid, or_monoid1128)) + _t1978 = _t1980 else throw(ParseError("Unexpected token in monoid" * ": " * string(lookahead(parser, 0)))) end - _t1969 = _t1972 + _t1975 = _t1978 end - _t1966 = _t1969 + _t1972 = _t1975 end - _t1963 = _t1966 + _t1969 = _t1972 end - result1130 = _t1963 - record_span!(parser, span_start1129, "Monoid") - return result1130 + result1133 = _t1969 + record_span!(parser, span_start1132, "Monoid") + return result1133 end function parse_or_monoid(parser::ParserState)::Proto.OrMonoid - span_start1131 = span_start(parser) + span_start1134 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "or") consume_literal!(parser, ")") - _t1975 = Proto.OrMonoid() - result1132 = _t1975 - record_span!(parser, span_start1131, "OrMonoid") - return result1132 + _t1981 = Proto.OrMonoid() + result1135 = _t1981 + record_span!(parser, span_start1134, "OrMonoid") + return result1135 end function parse_min_monoid(parser::ParserState)::Proto.MinMonoid - span_start1134 = span_start(parser) + span_start1137 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "min") - _t1976 = parse_type(parser) - type1133 = _t1976 + _t1982 = parse_type(parser) + type1136 = _t1982 consume_literal!(parser, ")") - _t1977 = Proto.MinMonoid(var"#type"=type1133) - result1135 = _t1977 - record_span!(parser, span_start1134, "MinMonoid") - return result1135 + _t1983 = Proto.MinMonoid(var"#type"=type1136) + result1138 = _t1983 + record_span!(parser, span_start1137, "MinMonoid") + return result1138 end function parse_max_monoid(parser::ParserState)::Proto.MaxMonoid - span_start1137 = span_start(parser) + span_start1140 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "max") - _t1978 = parse_type(parser) - type1136 = _t1978 + _t1984 = parse_type(parser) + type1139 = _t1984 consume_literal!(parser, ")") - _t1979 = Proto.MaxMonoid(var"#type"=type1136) - result1138 = _t1979 - record_span!(parser, span_start1137, "MaxMonoid") - return result1138 + _t1985 = Proto.MaxMonoid(var"#type"=type1139) + result1141 = _t1985 + record_span!(parser, span_start1140, "MaxMonoid") + return result1141 end function parse_sum_monoid(parser::ParserState)::Proto.SumMonoid - span_start1140 = span_start(parser) + span_start1143 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "sum") - _t1980 = parse_type(parser) - type1139 = _t1980 + _t1986 = parse_type(parser) + type1142 = _t1986 consume_literal!(parser, ")") - _t1981 = Proto.SumMonoid(var"#type"=type1139) - result1141 = _t1981 - record_span!(parser, span_start1140, "SumMonoid") - return result1141 + _t1987 = Proto.SumMonoid(var"#type"=type1142) + result1144 = _t1987 + record_span!(parser, span_start1143, "SumMonoid") + return result1144 end function parse_monus_def(parser::ParserState)::Proto.MonusDef - span_start1146 = span_start(parser) + span_start1149 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "monus") - _t1982 = parse_monoid(parser) - monoid1142 = _t1982 - _t1983 = parse_relation_id(parser) - relation_id1143 = _t1983 - _t1984 = parse_abstraction_with_arity(parser) - abstraction_with_arity1144 = _t1984 + _t1988 = parse_monoid(parser) + monoid1145 = _t1988 + _t1989 = parse_relation_id(parser) + relation_id1146 = _t1989 + _t1990 = parse_abstraction_with_arity(parser) + abstraction_with_arity1147 = _t1990 if match_lookahead_literal(parser, "(", 0) - _t1986 = parse_attrs(parser) - _t1985 = _t1986 + _t1992 = parse_attrs(parser) + _t1991 = _t1992 else - _t1985 = nothing + _t1991 = nothing end - attrs1145 = _t1985 + attrs1148 = _t1991 consume_literal!(parser, ")") - _t1987 = Proto.MonusDef(monoid=monoid1142, name=relation_id1143, body=abstraction_with_arity1144[1], attrs=(!isnothing(attrs1145) ? attrs1145 : Proto.Attribute[]), value_arity=abstraction_with_arity1144[2]) - result1147 = _t1987 - record_span!(parser, span_start1146, "MonusDef") - return result1147 + _t1993 = Proto.MonusDef(monoid=monoid1145, name=relation_id1146, body=abstraction_with_arity1147[1], attrs=(!isnothing(attrs1148) ? attrs1148 : Proto.Attribute[]), value_arity=abstraction_with_arity1147[2]) + result1150 = _t1993 + record_span!(parser, span_start1149, "MonusDef") + return result1150 end function parse_constraint(parser::ParserState)::Proto.Constraint - span_start1152 = span_start(parser) + span_start1155 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "functional_dependency") - _t1988 = parse_relation_id(parser) - relation_id1148 = _t1988 - _t1989 = parse_abstraction(parser) - abstraction1149 = _t1989 - _t1990 = parse_functional_dependency_keys(parser) - functional_dependency_keys1150 = _t1990 - _t1991 = parse_functional_dependency_values(parser) - functional_dependency_values1151 = _t1991 + _t1994 = parse_relation_id(parser) + relation_id1151 = _t1994 + _t1995 = parse_abstraction(parser) + abstraction1152 = _t1995 + _t1996 = parse_functional_dependency_keys(parser) + functional_dependency_keys1153 = _t1996 + _t1997 = parse_functional_dependency_values(parser) + functional_dependency_values1154 = _t1997 consume_literal!(parser, ")") - _t1992 = Proto.FunctionalDependency(guard=abstraction1149, keys=functional_dependency_keys1150, values=functional_dependency_values1151) - _t1993 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1992), name=relation_id1148) - result1153 = _t1993 - record_span!(parser, span_start1152, "Constraint") - return result1153 + _t1998 = Proto.FunctionalDependency(guard=abstraction1152, keys=functional_dependency_keys1153, values=functional_dependency_values1154) + _t1999 = Proto.Constraint(constraint_type=OneOf(:functional_dependency, _t1998), name=relation_id1151) + result1156 = _t1999 + record_span!(parser, span_start1155, "Constraint") + return result1156 end function parse_functional_dependency_keys(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1154 = Proto.Var[] - cond1155 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1155 - _t1994 = parse_var(parser) - item1156 = _t1994 - push!(xs1154, item1156) - cond1155 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1157 = xs1154 + xs1157 = Proto.Var[] + cond1158 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1158 + _t2000 = parse_var(parser) + item1159 = _t2000 + push!(xs1157, item1159) + cond1158 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1160 = xs1157 consume_literal!(parser, ")") - return vars1157 + return vars1160 end function parse_functional_dependency_values(parser::ParserState)::Vector{Proto.Var} consume_literal!(parser, "(") consume_literal!(parser, "values") - xs1158 = Proto.Var[] - cond1159 = match_lookahead_terminal(parser, "SYMBOL", 0) - while cond1159 - _t1995 = parse_var(parser) - item1160 = _t1995 - push!(xs1158, item1160) - cond1159 = match_lookahead_terminal(parser, "SYMBOL", 0) - end - vars1161 = xs1158 + xs1161 = Proto.Var[] + cond1162 = match_lookahead_terminal(parser, "SYMBOL", 0) + while cond1162 + _t2001 = parse_var(parser) + item1163 = _t2001 + push!(xs1161, item1163) + cond1162 = match_lookahead_terminal(parser, "SYMBOL", 0) + end + vars1164 = xs1161 consume_literal!(parser, ")") - return vars1161 + return vars1164 end function parse_data(parser::ParserState)::Proto.Data - span_start1167 = span_start(parser) + span_start1170 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "iceberg_data", 1) - _t1997 = 3 + _t2003 = 3 else if match_lookahead_literal(parser, "edb", 1) - _t1998 = 0 + _t2004 = 0 else if match_lookahead_literal(parser, "csv_data", 1) - _t1999 = 2 + _t2005 = 2 else if match_lookahead_literal(parser, "betree_relation", 1) - _t2000 = 1 + _t2006 = 1 else - _t2000 = -1 + _t2006 = -1 end - _t1999 = _t2000 + _t2005 = _t2006 end - _t1998 = _t1999 + _t2004 = _t2005 end - _t1997 = _t1998 + _t2003 = _t2004 end - _t1996 = _t1997 + _t2002 = _t2003 else - _t1996 = -1 - end - prediction1162 = _t1996 - if prediction1162 == 3 - _t2002 = parse_iceberg_data(parser) - iceberg_data1166 = _t2002 - _t2003 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1166)) - _t2001 = _t2003 + _t2002 = -1 + end + prediction1165 = _t2002 + if prediction1165 == 3 + _t2008 = parse_iceberg_data(parser) + iceberg_data1169 = _t2008 + _t2009 = Proto.Data(data_type=OneOf(:iceberg_data, iceberg_data1169)) + _t2007 = _t2009 else - if prediction1162 == 2 - _t2005 = parse_csv_data(parser) - csv_data1165 = _t2005 - _t2006 = Proto.Data(data_type=OneOf(:csv_data, csv_data1165)) - _t2004 = _t2006 + if prediction1165 == 2 + _t2011 = parse_csv_data(parser) + csv_data1168 = _t2011 + _t2012 = Proto.Data(data_type=OneOf(:csv_data, csv_data1168)) + _t2010 = _t2012 else - if prediction1162 == 1 - _t2008 = parse_betree_relation(parser) - betree_relation1164 = _t2008 - _t2009 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1164)) - _t2007 = _t2009 + if prediction1165 == 1 + _t2014 = parse_betree_relation(parser) + betree_relation1167 = _t2014 + _t2015 = Proto.Data(data_type=OneOf(:betree_relation, betree_relation1167)) + _t2013 = _t2015 else - if prediction1162 == 0 - _t2011 = parse_edb(parser) - edb1163 = _t2011 - _t2012 = Proto.Data(data_type=OneOf(:edb, edb1163)) - _t2010 = _t2012 + if prediction1165 == 0 + _t2017 = parse_edb(parser) + edb1166 = _t2017 + _t2018 = Proto.Data(data_type=OneOf(:edb, edb1166)) + _t2016 = _t2018 else throw(ParseError("Unexpected token in data" * ": " * string(lookahead(parser, 0)))) end - _t2007 = _t2010 + _t2013 = _t2016 end - _t2004 = _t2007 + _t2010 = _t2013 end - _t2001 = _t2004 + _t2007 = _t2010 end - result1168 = _t2001 - record_span!(parser, span_start1167, "Data") - return result1168 + result1171 = _t2007 + record_span!(parser, span_start1170, "Data") + return result1171 end function parse_edb(parser::ParserState)::Proto.EDB - span_start1172 = span_start(parser) + span_start1175 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "edb") - _t2013 = parse_relation_id(parser) - relation_id1169 = _t2013 - _t2014 = parse_edb_path(parser) - edb_path1170 = _t2014 - _t2015 = parse_edb_types(parser) - edb_types1171 = _t2015 + _t2019 = parse_relation_id(parser) + relation_id1172 = _t2019 + _t2020 = parse_edb_path(parser) + edb_path1173 = _t2020 + _t2021 = parse_edb_types(parser) + edb_types1174 = _t2021 consume_literal!(parser, ")") - _t2016 = Proto.EDB(target_id=relation_id1169, path=edb_path1170, types=edb_types1171) - result1173 = _t2016 - record_span!(parser, span_start1172, "EDB") - return result1173 + _t2022 = Proto.EDB(target_id=relation_id1172, path=edb_path1173, types=edb_types1174) + result1176 = _t2022 + record_span!(parser, span_start1175, "EDB") + return result1176 end function parse_edb_path(parser::ParserState)::Vector{String} consume_literal!(parser, "[") - xs1174 = String[] - cond1175 = match_lookahead_terminal(parser, "STRING", 0) - while cond1175 - item1176 = consume_terminal!(parser, "STRING") - push!(xs1174, item1176) - cond1175 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1177 = xs1174 + xs1177 = String[] + cond1178 = match_lookahead_terminal(parser, "STRING", 0) + while cond1178 + item1179 = consume_terminal!(parser, "STRING") + push!(xs1177, item1179) + cond1178 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1180 = xs1177 consume_literal!(parser, "]") - return strings1177 + return strings1180 end function parse_edb_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "[") - xs1178 = Proto.var"#Type"[] - cond1179 = (((((((((((((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 cond1179 - _t2017 = parse_type(parser) - item1180 = _t2017 - push!(xs1178, item1180) - cond1179 = (((((((((((((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 - types1181 = xs1178 + xs1181 = Proto.var"#Type"[] + cond1182 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1182 + _t2023 = parse_type(parser) + item1183 = _t2023 + push!(xs1181, item1183) + cond1182 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1184 = xs1181 consume_literal!(parser, "]") - return types1181 + return types1184 end function parse_betree_relation(parser::ParserState)::Proto.BeTreeRelation - span_start1184 = span_start(parser) + span_start1187 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_relation") - _t2018 = parse_relation_id(parser) - relation_id1182 = _t2018 - _t2019 = parse_betree_info(parser) - betree_info1183 = _t2019 + _t2024 = parse_relation_id(parser) + relation_id1185 = _t2024 + _t2025 = parse_betree_info(parser) + betree_info1186 = _t2025 consume_literal!(parser, ")") - _t2020 = Proto.BeTreeRelation(name=relation_id1182, relation_info=betree_info1183) - result1185 = _t2020 - record_span!(parser, span_start1184, "BeTreeRelation") - return result1185 + _t2026 = Proto.BeTreeRelation(name=relation_id1185, relation_info=betree_info1186) + result1188 = _t2026 + record_span!(parser, span_start1187, "BeTreeRelation") + return result1188 end function parse_betree_info(parser::ParserState)::Proto.BeTreeInfo - span_start1189 = span_start(parser) + span_start1192 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "betree_info") - _t2021 = parse_betree_info_key_types(parser) - betree_info_key_types1186 = _t2021 - _t2022 = parse_betree_info_value_types(parser) - betree_info_value_types1187 = _t2022 - _t2023 = parse_config_dict(parser) - config_dict1188 = _t2023 + _t2027 = parse_betree_info_key_types(parser) + betree_info_key_types1189 = _t2027 + _t2028 = parse_betree_info_value_types(parser) + betree_info_value_types1190 = _t2028 + _t2029 = parse_config_dict(parser) + config_dict1191 = _t2029 consume_literal!(parser, ")") - _t2024 = construct_betree_info(parser, betree_info_key_types1186, betree_info_value_types1187, config_dict1188) - result1190 = _t2024 - record_span!(parser, span_start1189, "BeTreeInfo") - return result1190 + _t2030 = construct_betree_info(parser, betree_info_key_types1189, betree_info_value_types1190, config_dict1191) + result1193 = _t2030 + record_span!(parser, span_start1192, "BeTreeInfo") + return result1193 end function parse_betree_info_key_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "key_types") - 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 - _t2025 = parse_type(parser) - item1193 = _t2025 - 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 + xs1194 = Proto.var"#Type"[] + cond1195 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1195 + _t2031 = parse_type(parser) + item1196 = _t2031 + push!(xs1194, item1196) + cond1195 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1197 = xs1194 consume_literal!(parser, ")") - return types1194 + return types1197 end function parse_betree_info_value_types(parser::ParserState)::Vector{Proto.var"#Type"} consume_literal!(parser, "(") consume_literal!(parser, "value_types") - xs1195 = Proto.var"#Type"[] - cond1196 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - while cond1196 - _t2026 = parse_type(parser) - item1197 = _t2026 - push!(xs1195, item1197) - cond1196 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) - end - types1198 = xs1195 + xs1198 = Proto.var"#Type"[] + cond1199 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1199 + _t2032 = parse_type(parser) + item1200 = _t2032 + push!(xs1198, item1200) + cond1199 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1201 = xs1198 consume_literal!(parser, ")") - return types1198 + return types1201 end function parse_csv_data(parser::ParserState)::Proto.CSVData - span_start1204 = span_start(parser) + span_start1207 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_data") - _t2027 = parse_csvlocator(parser) - csvlocator1199 = _t2027 - _t2028 = parse_csv_config(parser) - csv_config1200 = _t2028 + _t2033 = parse_csvlocator(parser) + csvlocator1202 = _t2033 + _t2034 = parse_csv_config(parser) + csv_config1203 = _t2034 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "columns", 1)) - _t2030 = parse_gnf_columns(parser) - _t2029 = _t2030 + _t2036 = parse_gnf_columns(parser) + _t2035 = _t2036 else - _t2029 = nothing + _t2035 = nothing end - gnf_columns1201 = _t2029 + gnf_columns1204 = _t2035 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "relations", 1)) - _t2032 = parse_target_relations(parser) - _t2031 = _t2032 + _t2038 = parse_target_relations(parser) + _t2037 = _t2038 else - _t2031 = nothing + _t2037 = nothing end - target_relations1202 = _t2031 - _t2033 = parse_csv_asof(parser) - csv_asof1203 = _t2033 + target_relations1205 = _t2037 + _t2039 = parse_csv_asof(parser) + csv_asof1206 = _t2039 consume_literal!(parser, ")") - _t2034 = construct_csv_data(parser, csvlocator1199, csv_config1200, gnf_columns1201, target_relations1202, csv_asof1203) - result1205 = _t2034 - record_span!(parser, span_start1204, "CSVData") - return result1205 + _t2040 = construct_csv_data(parser, csvlocator1202, csv_config1203, gnf_columns1204, target_relations1205, csv_asof1206) + result1208 = _t2040 + record_span!(parser, span_start1207, "CSVData") + return result1208 end function parse_csvlocator(parser::ParserState)::Proto.CSVLocator - span_start1208 = span_start(parser) + span_start1211 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_locator") if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "paths", 1)) - _t2036 = parse_csv_locator_paths(parser) - _t2035 = _t2036 + _t2042 = parse_csv_locator_paths(parser) + _t2041 = _t2042 else - _t2035 = nothing + _t2041 = nothing end - csv_locator_paths1206 = _t2035 + csv_locator_paths1209 = _t2041 if match_lookahead_literal(parser, "(", 0) - _t2038 = parse_csv_locator_inline_data(parser) - _t2037 = _t2038 + _t2044 = parse_csv_locator_inline_data(parser) + _t2043 = _t2044 else - _t2037 = nothing + _t2043 = nothing end - csv_locator_inline_data1207 = _t2037 + csv_locator_inline_data1210 = _t2043 consume_literal!(parser, ")") - _t2039 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1206) ? csv_locator_paths1206 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1207) ? csv_locator_inline_data1207 : ""))) - result1209 = _t2039 - record_span!(parser, span_start1208, "CSVLocator") - return result1209 + _t2045 = Proto.CSVLocator(paths=(!isnothing(csv_locator_paths1209) ? csv_locator_paths1209 : String[]), inline_data=Vector{UInt8}((!isnothing(csv_locator_inline_data1210) ? csv_locator_inline_data1210 : ""))) + result1212 = _t2045 + record_span!(parser, span_start1211, "CSVLocator") + return result1212 end function parse_csv_locator_paths(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "paths") - xs1210 = String[] - cond1211 = match_lookahead_terminal(parser, "STRING", 0) - while cond1211 - item1212 = consume_terminal!(parser, "STRING") - push!(xs1210, item1212) - cond1211 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1213 = xs1210 + xs1213 = String[] + cond1214 = match_lookahead_terminal(parser, "STRING", 0) + while cond1214 + item1215 = consume_terminal!(parser, "STRING") + push!(xs1213, item1215) + cond1214 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1216 = xs1213 consume_literal!(parser, ")") - return strings1213 + return strings1216 end function parse_csv_locator_inline_data(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "inline_data") - formatted_string1214 = consume_terminal!(parser, "STRING") + formatted_string1217 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return formatted_string1214 + return formatted_string1217 end function parse_csv_config(parser::ParserState)::Proto.CSVConfig - span_start1217 = span_start(parser) + span_start1220 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "csv_config") - _t2040 = parse_config_dict(parser) - config_dict1215 = _t2040 + _t2046 = parse_config_dict(parser) + config_dict1218 = _t2046 if match_lookahead_literal(parser, "(", 0) - _t2042 = parse__storage_integration(parser) - _t2041 = _t2042 + _t2048 = parse__storage_integration(parser) + _t2047 = _t2048 else - _t2041 = nothing + _t2047 = nothing end - _storage_integration1216 = _t2041 + _storage_integration1219 = _t2047 consume_literal!(parser, ")") - _t2043 = construct_csv_config(parser, config_dict1215, _storage_integration1216) - result1218 = _t2043 - record_span!(parser, span_start1217, "CSVConfig") - return result1218 + _t2049 = construct_csv_config(parser, config_dict1218, _storage_integration1219) + result1221 = _t2049 + record_span!(parser, span_start1220, "CSVConfig") + return result1221 end function parse__storage_integration(parser::ParserState)::Vector{Tuple{String, Proto.Value}} consume_literal!(parser, "(") consume_literal!(parser, "storage_integration") - _t2044 = parse_config_dict(parser) - config_dict1219 = _t2044 + _t2050 = parse_config_dict(parser) + config_dict1222 = _t2050 consume_literal!(parser, ")") - return config_dict1219 + return config_dict1222 end function parse_gnf_columns(parser::ParserState)::Vector{Proto.GNFColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1220 = Proto.GNFColumn[] - cond1221 = match_lookahead_literal(parser, "(", 0) - while cond1221 - _t2045 = parse_gnf_column(parser) - item1222 = _t2045 - push!(xs1220, item1222) - cond1221 = match_lookahead_literal(parser, "(", 0) - end - gnf_columns1223 = xs1220 + xs1223 = Proto.GNFColumn[] + cond1224 = match_lookahead_literal(parser, "(", 0) + while cond1224 + _t2051 = parse_gnf_column(parser) + item1225 = _t2051 + push!(xs1223, item1225) + cond1224 = match_lookahead_literal(parser, "(", 0) + end + gnf_columns1226 = xs1223 consume_literal!(parser, ")") - return gnf_columns1223 + return gnf_columns1226 end function parse_gnf_column(parser::ParserState)::Proto.GNFColumn - span_start1230 = span_start(parser) + span_start1233 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - _t2046 = parse_gnf_column_path(parser) - gnf_column_path1224 = _t2046 + _t2052 = parse_gnf_column_path(parser) + gnf_column_path1227 = _t2052 if (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - _t2048 = parse_relation_id(parser) - _t2047 = _t2048 + _t2054 = parse_relation_id(parser) + _t2053 = _t2054 else - _t2047 = nothing + _t2053 = nothing end - relation_id1225 = _t2047 + relation_id1228 = _t2053 consume_literal!(parser, "[") - xs1226 = Proto.var"#Type"[] - cond1227 = (((((((((((((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 cond1227 - _t2049 = parse_type(parser) - item1228 = _t2049 - push!(xs1226, item1228) - cond1227 = (((((((((((((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 - types1229 = xs1226 + xs1229 = Proto.var"#Type"[] + cond1230 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + while cond1230 + _t2055 = parse_type(parser) + item1231 = _t2055 + push!(xs1229, item1231) + cond1230 = (((((((((((((match_lookahead_literal(parser, "(", 0) || match_lookahead_literal(parser, "BOOLEAN", 0)) || match_lookahead_literal(parser, "DATE", 0)) || match_lookahead_literal(parser, "DATETIME", 0)) || match_lookahead_literal(parser, "FLOAT", 0)) || match_lookahead_literal(parser, "FLOAT32", 0)) || match_lookahead_literal(parser, "INT", 0)) || match_lookahead_literal(parser, "INT128", 0)) || match_lookahead_literal(parser, "INT32", 0)) || match_lookahead_literal(parser, "MISSING", 0)) || match_lookahead_literal(parser, "STRING", 0)) || match_lookahead_literal(parser, "UINT128", 0)) || match_lookahead_literal(parser, "UINT32", 0)) || match_lookahead_literal(parser, "UNKNOWN", 0)) + end + types1232 = xs1229 consume_literal!(parser, "]") consume_literal!(parser, ")") - _t2050 = Proto.GNFColumn(column_path=gnf_column_path1224, target_id=relation_id1225, types=types1229) - result1231 = _t2050 - record_span!(parser, span_start1230, "GNFColumn") - return result1231 + _t2056 = Proto.GNFColumn(column_path=gnf_column_path1227, target_id=relation_id1228, types=types1232) + result1234 = _t2056 + record_span!(parser, span_start1233, "GNFColumn") + return result1234 end function parse_gnf_column_path(parser::ParserState)::Vector{String} if match_lookahead_literal(parser, "[", 0) - _t2051 = 1 + _t2057 = 1 else if match_lookahead_terminal(parser, "STRING", 0) - _t2052 = 0 + _t2058 = 0 else - _t2052 = -1 + _t2058 = -1 end - _t2051 = _t2052 + _t2057 = _t2058 end - prediction1232 = _t2051 - if prediction1232 == 1 + prediction1235 = _t2057 + if prediction1235 == 1 consume_literal!(parser, "[") - xs1234 = String[] - cond1235 = match_lookahead_terminal(parser, "STRING", 0) - while cond1235 - item1236 = consume_terminal!(parser, "STRING") - push!(xs1234, item1236) - cond1235 = match_lookahead_terminal(parser, "STRING", 0) + xs1237 = String[] + cond1238 = match_lookahead_terminal(parser, "STRING", 0) + while cond1238 + item1239 = consume_terminal!(parser, "STRING") + push!(xs1237, item1239) + cond1238 = match_lookahead_terminal(parser, "STRING", 0) end - strings1237 = xs1234 + strings1240 = xs1237 consume_literal!(parser, "]") - _t2053 = strings1237 + _t2059 = strings1240 else - if prediction1232 == 0 - string1233 = consume_terminal!(parser, "STRING") - _t2054 = String[string1233] + if prediction1235 == 0 + string1236 = consume_terminal!(parser, "STRING") + _t2060 = String[string1236] else throw(ParseError("Unexpected token in gnf_column_path" * ": " * string(lookahead(parser, 0)))) end - _t2053 = _t2054 + _t2059 = _t2060 end - return _t2053 + return _t2059 end function parse_target_relations(parser::ParserState)::Proto.TargetRelations - span_start1240 = span_start(parser) + span_start1243 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relations") - _t2055 = parse_relation_keys(parser) - relation_keys1238 = _t2055 - _t2056 = parse_relation_body(parser) - relation_body1239 = _t2056 + _t2061 = parse_relation_keys(parser) + relation_keys1241 = _t2061 + _t2062 = parse_relation_body(parser) + relation_body1242 = _t2062 consume_literal!(parser, ")") - _t2057 = construct_relations(parser, relation_keys1238, relation_body1239) - result1241 = _t2057 - record_span!(parser, span_start1240, "TargetRelations") - return result1241 + _t2063 = construct_relations(parser, relation_keys1241, relation_body1242) + result1244 = _t2063 + record_span!(parser, span_start1243, "TargetRelations") + return result1244 end function parse_relation_keys(parser::ParserState)::Vector{Proto.NamedColumn} consume_literal!(parser, "(") consume_literal!(parser, "keys") - xs1242 = Proto.NamedColumn[] - cond1243 = match_lookahead_literal(parser, "(", 0) - while cond1243 - _t2058 = parse_named_column(parser) - item1244 = _t2058 - push!(xs1242, item1244) - cond1243 = match_lookahead_literal(parser, "(", 0) - end - named_columns1245 = xs1242 + xs1245 = Proto.NamedColumn[] + cond1246 = match_lookahead_literal(parser, "(", 0) + while cond1246 + _t2064 = parse_named_column(parser) + item1247 = _t2064 + push!(xs1245, item1247) + cond1246 = match_lookahead_literal(parser, "(", 0) + end + named_columns1248 = xs1245 consume_literal!(parser, ")") - return named_columns1245 + return named_columns1248 end function parse_named_column(parser::ParserState)::Proto.NamedColumn - span_start1248 = span_start(parser) + span_start1251 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1246 = consume_terminal!(parser, "STRING") - _t2059 = parse_type(parser) - type1247 = _t2059 + string1249 = consume_terminal!(parser, "STRING") + _t2065 = parse_type(parser) + type1250 = _t2065 consume_literal!(parser, ")") - _t2060 = Proto.NamedColumn(name=string1246, var"#type"=type1247) - result1249 = _t2060 - record_span!(parser, span_start1248, "NamedColumn") - return result1249 + _t2066 = Proto.NamedColumn(name=string1249, var"#type"=type1250) + result1252 = _t2066 + record_span!(parser, span_start1251, "NamedColumn") + return result1252 end function parse_relation_body(parser::ParserState)::Proto.TargetRelations - span_start1254 = span_start(parser) + span_start1257 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "relation", 1) - _t2062 = 0 + _t2068 = 0 else if match_lookahead_literal(parser, "inserts", 1) - _t2063 = 1 + _t2069 = 1 else - _t2063 = 0 + _t2069 = 0 end - _t2062 = _t2063 + _t2068 = _t2069 end - _t2061 = _t2062 + _t2067 = _t2068 else - _t2061 = 0 - end - prediction1250 = _t2061 - if prediction1250 == 1 - _t2065 = parse_cdc_inserts(parser) - cdc_inserts1252 = _t2065 - _t2066 = parse_cdc_deletes(parser) - cdc_deletes1253 = _t2066 - _t2067 = construct_cdc_relations(parser, cdc_inserts1252, cdc_deletes1253) - _t2064 = _t2067 + _t2067 = 0 + end + prediction1253 = _t2067 + if prediction1253 == 1 + _t2071 = parse_cdc_inserts(parser) + cdc_inserts1255 = _t2071 + _t2072 = parse_cdc_deletes(parser) + cdc_deletes1256 = _t2072 + _t2073 = construct_cdc_relations(parser, cdc_inserts1255, cdc_deletes1256) + _t2070 = _t2073 else - if prediction1250 == 0 - _t2069 = parse_non_cdc_relations(parser) - non_cdc_relations1251 = _t2069 - _t2070 = construct_non_cdc_relations(parser, non_cdc_relations1251) - _t2068 = _t2070 + if prediction1253 == 0 + _t2075 = parse_non_cdc_relations(parser) + non_cdc_relations1254 = _t2075 + _t2076 = construct_non_cdc_relations(parser, non_cdc_relations1254) + _t2074 = _t2076 else throw(ParseError("Unexpected token in relation_body" * ": " * string(lookahead(parser, 0)))) end - _t2064 = _t2068 + _t2070 = _t2074 end - result1255 = _t2064 - record_span!(parser, span_start1254, "TargetRelations") - return result1255 + result1258 = _t2070 + record_span!(parser, span_start1257, "TargetRelations") + return result1258 end function parse_non_cdc_relations(parser::ParserState)::Vector{Proto.TargetRelation} - xs1256 = Proto.TargetRelation[] - cond1257 = match_lookahead_literal(parser, "(", 0) - while cond1257 - _t2071 = parse_target_relation(parser) - item1258 = _t2071 - push!(xs1256, item1258) - cond1257 = match_lookahead_literal(parser, "(", 0) + xs1259 = Proto.TargetRelation[] + cond1260 = match_lookahead_literal(parser, "(", 0) + while cond1260 + _t2077 = parse_target_relation(parser) + item1261 = _t2077 + push!(xs1259, item1261) + cond1260 = match_lookahead_literal(parser, "(", 0) end - return xs1256 + return xs1259 end function parse_target_relation(parser::ParserState)::Proto.TargetRelation - span_start1264 = span_start(parser) + span_start1267 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "relation") - _t2072 = parse_relation_id(parser) - relation_id1259 = _t2072 - xs1260 = Proto.NamedColumn[] - cond1261 = match_lookahead_literal(parser, "(", 0) - while cond1261 - _t2073 = parse_named_column(parser) - item1262 = _t2073 - push!(xs1260, item1262) - cond1261 = match_lookahead_literal(parser, "(", 0) - end - named_columns1263 = xs1260 + _t2078 = parse_relation_id(parser) + relation_id1262 = _t2078 + xs1263 = Proto.NamedColumn[] + cond1264 = match_lookahead_literal(parser, "(", 0) + while cond1264 + _t2079 = parse_named_column(parser) + item1265 = _t2079 + push!(xs1263, item1265) + cond1264 = match_lookahead_literal(parser, "(", 0) + end + named_columns1266 = xs1263 consume_literal!(parser, ")") - _t2074 = Proto.TargetRelation(target_id=relation_id1259, values=named_columns1263) - result1265 = _t2074 - record_span!(parser, span_start1264, "TargetRelation") - return result1265 + _t2080 = Proto.TargetRelation(target_id=relation_id1262, values=named_columns1266) + result1268 = _t2080 + record_span!(parser, span_start1267, "TargetRelation") + return result1268 end function parse_cdc_inserts(parser::ParserState)::Vector{Proto.TargetRelation} consume_literal!(parser, "(") consume_literal!(parser, "inserts") - xs1266 = Proto.TargetRelation[] - cond1267 = match_lookahead_literal(parser, "(", 0) - while cond1267 - _t2075 = parse_target_relation(parser) - item1268 = _t2075 - push!(xs1266, item1268) - cond1267 = match_lookahead_literal(parser, "(", 0) - end - target_relations1269 = xs1266 + xs1269 = Proto.TargetRelation[] + cond1270 = match_lookahead_literal(parser, "(", 0) + while cond1270 + _t2081 = parse_target_relation(parser) + item1271 = _t2081 + push!(xs1269, item1271) + cond1270 = match_lookahead_literal(parser, "(", 0) + end + target_relations1272 = xs1269 consume_literal!(parser, ")") - return target_relations1269 + return target_relations1272 end function parse_cdc_deletes(parser::ParserState)::Vector{Proto.TargetRelation} consume_literal!(parser, "(") consume_literal!(parser, "deletes") - xs1270 = Proto.TargetRelation[] - cond1271 = match_lookahead_literal(parser, "(", 0) - while cond1271 - _t2076 = parse_target_relation(parser) - item1272 = _t2076 - push!(xs1270, item1272) - cond1271 = match_lookahead_literal(parser, "(", 0) - end - target_relations1273 = xs1270 + xs1273 = Proto.TargetRelation[] + cond1274 = match_lookahead_literal(parser, "(", 0) + while cond1274 + _t2082 = parse_target_relation(parser) + item1275 = _t2082 + push!(xs1273, item1275) + cond1274 = match_lookahead_literal(parser, "(", 0) + end + target_relations1276 = xs1273 consume_literal!(parser, ")") - return target_relations1273 + return target_relations1276 end function parse_csv_asof(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "asof") - string1274 = consume_terminal!(parser, "STRING") + string1277 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1274 + return string1277 end function parse_iceberg_data(parser::ParserState)::Proto.IcebergData - span_start1281 = span_start(parser) + span_start1284 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_data") - _t2077 = parse_iceberg_locator(parser) - iceberg_locator1275 = _t2077 - _t2078 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1276 = _t2078 - _t2079 = parse_gnf_columns(parser) - gnf_columns1277 = _t2079 + _t2083 = parse_iceberg_locator(parser) + iceberg_locator1278 = _t2083 + _t2084 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1279 = _t2084 + _t2085 = parse_gnf_columns(parser) + gnf_columns1280 = _t2085 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "from_snapshot", 1)) - _t2081 = parse_iceberg_from_snapshot(parser) - _t2080 = _t2081 + _t2087 = parse_iceberg_from_snapshot(parser) + _t2086 = _t2087 else - _t2080 = nothing + _t2086 = nothing end - iceberg_from_snapshot1278 = _t2080 + iceberg_from_snapshot1281 = _t2086 if match_lookahead_literal(parser, "(", 0) - _t2083 = parse_iceberg_to_snapshot(parser) - _t2082 = _t2083 + _t2089 = parse_iceberg_to_snapshot(parser) + _t2088 = _t2089 else - _t2082 = nothing + _t2088 = nothing end - iceberg_to_snapshot1279 = _t2082 - _t2084 = parse_boolean_value(parser) - boolean_value1280 = _t2084 + iceberg_to_snapshot1282 = _t2088 + _t2090 = parse_boolean_value(parser) + boolean_value1283 = _t2090 consume_literal!(parser, ")") - _t2085 = construct_iceberg_data(parser, iceberg_locator1275, iceberg_catalog_config1276, gnf_columns1277, iceberg_from_snapshot1278, iceberg_to_snapshot1279, boolean_value1280) - result1282 = _t2085 - record_span!(parser, span_start1281, "IcebergData") - return result1282 + _t2091 = construct_iceberg_data(parser, iceberg_locator1278, iceberg_catalog_config1279, gnf_columns1280, iceberg_from_snapshot1281, iceberg_to_snapshot1282, boolean_value1283) + result1285 = _t2091 + record_span!(parser, span_start1284, "IcebergData") + return result1285 end function parse_iceberg_locator(parser::ParserState)::Proto.IcebergLocator - span_start1286 = span_start(parser) + span_start1289 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_locator") - _t2086 = parse_iceberg_locator_table_name(parser) - iceberg_locator_table_name1283 = _t2086 - _t2087 = parse_iceberg_locator_namespace(parser) - iceberg_locator_namespace1284 = _t2087 - _t2088 = parse_iceberg_locator_warehouse(parser) - iceberg_locator_warehouse1285 = _t2088 + _t2092 = parse_iceberg_locator_table_name(parser) + iceberg_locator_table_name1286 = _t2092 + _t2093 = parse_iceberg_locator_namespace(parser) + iceberg_locator_namespace1287 = _t2093 + _t2094 = parse_iceberg_locator_warehouse(parser) + iceberg_locator_warehouse1288 = _t2094 consume_literal!(parser, ")") - _t2089 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1283, namespace=iceberg_locator_namespace1284, warehouse=iceberg_locator_warehouse1285) - result1287 = _t2089 - record_span!(parser, span_start1286, "IcebergLocator") - return result1287 + _t2095 = Proto.IcebergLocator(table_name=iceberg_locator_table_name1286, namespace=iceberg_locator_namespace1287, warehouse=iceberg_locator_warehouse1288) + result1290 = _t2095 + record_span!(parser, span_start1289, "IcebergLocator") + return result1290 end function parse_iceberg_locator_table_name(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "table_name") - string1288 = consume_terminal!(parser, "STRING") + string1291 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1288 + return string1291 end function parse_iceberg_locator_namespace(parser::ParserState)::Vector{String} consume_literal!(parser, "(") consume_literal!(parser, "namespace") - xs1289 = String[] - cond1290 = match_lookahead_terminal(parser, "STRING", 0) - while cond1290 - item1291 = consume_terminal!(parser, "STRING") - push!(xs1289, item1291) - cond1290 = match_lookahead_terminal(parser, "STRING", 0) - end - strings1292 = xs1289 + xs1292 = String[] + cond1293 = match_lookahead_terminal(parser, "STRING", 0) + while cond1293 + item1294 = consume_terminal!(parser, "STRING") + push!(xs1292, item1294) + cond1293 = match_lookahead_terminal(parser, "STRING", 0) + end + strings1295 = xs1292 consume_literal!(parser, ")") - return strings1292 + return strings1295 end function parse_iceberg_locator_warehouse(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "warehouse") - string1293 = consume_terminal!(parser, "STRING") + string1296 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1293 + return string1296 end function parse_iceberg_catalog_config(parser::ParserState)::Proto.IcebergCatalogConfig - span_start1298 = span_start(parser) + span_start1301 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "iceberg_catalog_config") - _t2090 = parse_iceberg_catalog_uri(parser) - iceberg_catalog_uri1294 = _t2090 + _t2096 = parse_iceberg_catalog_uri(parser) + iceberg_catalog_uri1297 = _t2096 if (match_lookahead_literal(parser, "(", 0) && match_lookahead_literal(parser, "scope", 1)) - _t2092 = parse_iceberg_catalog_config_scope(parser) - _t2091 = _t2092 + _t2098 = parse_iceberg_catalog_config_scope(parser) + _t2097 = _t2098 else - _t2091 = nothing + _t2097 = nothing end - iceberg_catalog_config_scope1295 = _t2091 - _t2093 = parse_iceberg_properties(parser) - iceberg_properties1296 = _t2093 - _t2094 = parse_iceberg_auth_properties(parser) - iceberg_auth_properties1297 = _t2094 + iceberg_catalog_config_scope1298 = _t2097 + _t2099 = parse_iceberg_properties(parser) + iceberg_properties1299 = _t2099 + _t2100 = parse_iceberg_auth_properties(parser) + iceberg_auth_properties1300 = _t2100 consume_literal!(parser, ")") - _t2095 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1294, iceberg_catalog_config_scope1295, iceberg_properties1296, iceberg_auth_properties1297) - result1299 = _t2095 - record_span!(parser, span_start1298, "IcebergCatalogConfig") - return result1299 + _t2101 = construct_iceberg_catalog_config(parser, iceberg_catalog_uri1297, iceberg_catalog_config_scope1298, iceberg_properties1299, iceberg_auth_properties1300) + result1302 = _t2101 + record_span!(parser, span_start1301, "IcebergCatalogConfig") + return result1302 end function parse_iceberg_catalog_uri(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "catalog_uri") - string1300 = consume_terminal!(parser, "STRING") + string1303 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1300 + return string1303 end function parse_iceberg_catalog_config_scope(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "scope") - string1301 = consume_terminal!(parser, "STRING") + string1304 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1301 + return string1304 end function parse_iceberg_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "properties") - xs1302 = Tuple{String, String}[] - cond1303 = match_lookahead_literal(parser, "(", 0) - while cond1303 - _t2096 = parse_iceberg_property_entry(parser) - item1304 = _t2096 - push!(xs1302, item1304) - cond1303 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1305 = xs1302 + xs1305 = Tuple{String, String}[] + cond1306 = match_lookahead_literal(parser, "(", 0) + while cond1306 + _t2102 = parse_iceberg_property_entry(parser) + item1307 = _t2102 + push!(xs1305, item1307) + cond1306 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1308 = xs1305 consume_literal!(parser, ")") - return iceberg_property_entrys1305 + return iceberg_property_entrys1308 end function parse_iceberg_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1306 = consume_terminal!(parser, "STRING") - string_31307 = consume_terminal!(parser, "STRING") + string1309 = consume_terminal!(parser, "STRING") + string_31310 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1306, string_31307,) + return (string1309, string_31310,) end function parse_iceberg_auth_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "auth_properties") - xs1308 = Tuple{String, String}[] - cond1309 = match_lookahead_literal(parser, "(", 0) - while cond1309 - _t2097 = parse_iceberg_masked_property_entry(parser) - item1310 = _t2097 - push!(xs1308, item1310) - cond1309 = match_lookahead_literal(parser, "(", 0) - end - iceberg_masked_property_entrys1311 = xs1308 + xs1311 = Tuple{String, String}[] + cond1312 = match_lookahead_literal(parser, "(", 0) + while cond1312 + _t2103 = parse_iceberg_masked_property_entry(parser) + item1313 = _t2103 + push!(xs1311, item1313) + cond1312 = match_lookahead_literal(parser, "(", 0) + end + iceberg_masked_property_entrys1314 = xs1311 consume_literal!(parser, ")") - return iceberg_masked_property_entrys1311 + return iceberg_masked_property_entrys1314 end function parse_iceberg_masked_property_entry(parser::ParserState)::Tuple{String, String} consume_literal!(parser, "(") consume_literal!(parser, "prop") - string1312 = consume_terminal!(parser, "STRING") - string_31313 = consume_terminal!(parser, "STRING") + string1315 = consume_terminal!(parser, "STRING") + string_31316 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return (string1312, string_31313,) + return (string1315, string_31316,) end function parse_iceberg_from_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "from_snapshot") - string1314 = consume_terminal!(parser, "STRING") + string1317 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1314 + return string1317 end function parse_iceberg_to_snapshot(parser::ParserState)::String consume_literal!(parser, "(") consume_literal!(parser, "to_snapshot") - string1315 = consume_terminal!(parser, "STRING") + string1318 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - return string1315 + return string1318 end function parse_undefine(parser::ParserState)::Proto.Undefine - span_start1317 = span_start(parser) + span_start1320 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "undefine") - _t2098 = parse_fragment_id(parser) - fragment_id1316 = _t2098 + _t2104 = parse_fragment_id(parser) + fragment_id1319 = _t2104 consume_literal!(parser, ")") - _t2099 = Proto.Undefine(fragment_id=fragment_id1316) - result1318 = _t2099 - record_span!(parser, span_start1317, "Undefine") - return result1318 + _t2105 = Proto.Undefine(fragment_id=fragment_id1319) + result1321 = _t2105 + record_span!(parser, span_start1320, "Undefine") + return result1321 end function parse_context(parser::ParserState)::Proto.Context - span_start1323 = span_start(parser) + span_start1326 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "context") - xs1319 = Proto.RelationId[] - cond1320 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - while cond1320 - _t2100 = parse_relation_id(parser) - item1321 = _t2100 - push!(xs1319, item1321) - cond1320 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) - end - relation_ids1322 = xs1319 + xs1322 = Proto.RelationId[] + cond1323 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + while cond1323 + _t2106 = parse_relation_id(parser) + item1324 = _t2106 + push!(xs1322, item1324) + cond1323 = (match_lookahead_literal(parser, ":", 0) || match_lookahead_terminal(parser, "UINT128", 0)) + end + relation_ids1325 = xs1322 consume_literal!(parser, ")") - _t2101 = Proto.Context(relations=relation_ids1322) - result1324 = _t2101 - record_span!(parser, span_start1323, "Context") - return result1324 + _t2107 = Proto.Context(relations=relation_ids1325) + result1327 = _t2107 + record_span!(parser, span_start1326, "Context") + return result1327 end function parse_snapshot(parser::ParserState)::Proto.Snapshot - span_start1330 = span_start(parser) + span_start1333 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "snapshot") - _t2102 = parse_edb_path(parser) - edb_path1325 = _t2102 - xs1326 = Proto.SnapshotMapping[] - cond1327 = match_lookahead_literal(parser, "[", 0) - while cond1327 - _t2103 = parse_snapshot_mapping(parser) - item1328 = _t2103 - push!(xs1326, item1328) - cond1327 = match_lookahead_literal(parser, "[", 0) - end - snapshot_mappings1329 = xs1326 + _t2108 = parse_edb_path(parser) + edb_path1328 = _t2108 + xs1329 = Proto.SnapshotMapping[] + cond1330 = match_lookahead_literal(parser, "[", 0) + while cond1330 + _t2109 = parse_snapshot_mapping(parser) + item1331 = _t2109 + push!(xs1329, item1331) + cond1330 = match_lookahead_literal(parser, "[", 0) + end + snapshot_mappings1332 = xs1329 consume_literal!(parser, ")") - _t2104 = Proto.Snapshot(mappings=snapshot_mappings1329, prefix=edb_path1325) - result1331 = _t2104 - record_span!(parser, span_start1330, "Snapshot") - return result1331 + _t2110 = Proto.Snapshot(mappings=snapshot_mappings1332, prefix=edb_path1328) + result1334 = _t2110 + record_span!(parser, span_start1333, "Snapshot") + return result1334 end function parse_snapshot_mapping(parser::ParserState)::Proto.SnapshotMapping - span_start1334 = span_start(parser) - _t2105 = parse_edb_path(parser) - edb_path1332 = _t2105 - _t2106 = parse_relation_id(parser) - relation_id1333 = _t2106 - _t2107 = Proto.SnapshotMapping(destination_path=edb_path1332, source_relation=relation_id1333) - result1335 = _t2107 - record_span!(parser, span_start1334, "SnapshotMapping") - return result1335 + span_start1337 = span_start(parser) + _t2111 = parse_edb_path(parser) + edb_path1335 = _t2111 + _t2112 = parse_relation_id(parser) + relation_id1336 = _t2112 + _t2113 = Proto.SnapshotMapping(destination_path=edb_path1335, source_relation=relation_id1336) + result1338 = _t2113 + record_span!(parser, span_start1337, "SnapshotMapping") + return result1338 end function parse_epoch_reads(parser::ParserState)::Vector{Proto.Read} consume_literal!(parser, "(") consume_literal!(parser, "reads") - xs1336 = Proto.Read[] - cond1337 = match_lookahead_literal(parser, "(", 0) - while cond1337 - _t2108 = parse_read(parser) - item1338 = _t2108 - push!(xs1336, item1338) - cond1337 = match_lookahead_literal(parser, "(", 0) - end - reads1339 = xs1336 + xs1339 = Proto.Read[] + cond1340 = match_lookahead_literal(parser, "(", 0) + while cond1340 + _t2114 = parse_read(parser) + item1341 = _t2114 + push!(xs1339, item1341) + cond1340 = match_lookahead_literal(parser, "(", 0) + end + reads1342 = xs1339 consume_literal!(parser, ")") - return reads1339 + return reads1342 end function parse_read(parser::ParserState)::Proto.Read - span_start1346 = span_start(parser) + span_start1349 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "what_if", 1) - _t2110 = 2 + _t2116 = 2 else if match_lookahead_literal(parser, "output", 1) - _t2111 = 1 + _t2117 = 1 else if match_lookahead_literal(parser, "export_iceberg", 1) - _t2112 = 4 + _t2118 = 4 else if match_lookahead_literal(parser, "export", 1) - _t2113 = 4 + _t2119 = 4 else if match_lookahead_literal(parser, "demand", 1) - _t2114 = 0 + _t2120 = 0 else if match_lookahead_literal(parser, "abort", 1) - _t2115 = 3 + _t2121 = 3 else - _t2115 = -1 + _t2121 = -1 end - _t2114 = _t2115 + _t2120 = _t2121 end - _t2113 = _t2114 + _t2119 = _t2120 end - _t2112 = _t2113 + _t2118 = _t2119 end - _t2111 = _t2112 + _t2117 = _t2118 end - _t2110 = _t2111 + _t2116 = _t2117 end - _t2109 = _t2110 + _t2115 = _t2116 else - _t2109 = -1 - end - prediction1340 = _t2109 - if prediction1340 == 4 - _t2117 = parse_export(parser) - export1345 = _t2117 - _t2118 = Proto.Read(read_type=OneOf(:var"#export", export1345)) - _t2116 = _t2118 + _t2115 = -1 + end + prediction1343 = _t2115 + if prediction1343 == 4 + _t2123 = parse_export(parser) + export1348 = _t2123 + _t2124 = Proto.Read(read_type=OneOf(:var"#export", export1348)) + _t2122 = _t2124 else - if prediction1340 == 3 - _t2120 = parse_abort(parser) - abort1344 = _t2120 - _t2121 = Proto.Read(read_type=OneOf(:abort, abort1344)) - _t2119 = _t2121 + if prediction1343 == 3 + _t2126 = parse_abort(parser) + abort1347 = _t2126 + _t2127 = Proto.Read(read_type=OneOf(:abort, abort1347)) + _t2125 = _t2127 else - if prediction1340 == 2 - _t2123 = parse_what_if(parser) - what_if1343 = _t2123 - _t2124 = Proto.Read(read_type=OneOf(:what_if, what_if1343)) - _t2122 = _t2124 + if prediction1343 == 2 + _t2129 = parse_what_if(parser) + what_if1346 = _t2129 + _t2130 = Proto.Read(read_type=OneOf(:what_if, what_if1346)) + _t2128 = _t2130 else - if prediction1340 == 1 - _t2126 = parse_output(parser) - output1342 = _t2126 - _t2127 = Proto.Read(read_type=OneOf(:output, output1342)) - _t2125 = _t2127 + if prediction1343 == 1 + _t2132 = parse_output(parser) + output1345 = _t2132 + _t2133 = Proto.Read(read_type=OneOf(:output, output1345)) + _t2131 = _t2133 else - if prediction1340 == 0 - _t2129 = parse_demand(parser) - demand1341 = _t2129 - _t2130 = Proto.Read(read_type=OneOf(:demand, demand1341)) - _t2128 = _t2130 + if prediction1343 == 0 + _t2135 = parse_demand(parser) + demand1344 = _t2135 + _t2136 = Proto.Read(read_type=OneOf(:demand, demand1344)) + _t2134 = _t2136 else throw(ParseError("Unexpected token in read" * ": " * string(lookahead(parser, 0)))) end - _t2125 = _t2128 + _t2131 = _t2134 end - _t2122 = _t2125 + _t2128 = _t2131 end - _t2119 = _t2122 + _t2125 = _t2128 end - _t2116 = _t2119 + _t2122 = _t2125 end - result1347 = _t2116 - record_span!(parser, span_start1346, "Read") - return result1347 + result1350 = _t2122 + record_span!(parser, span_start1349, "Read") + return result1350 end function parse_demand(parser::ParserState)::Proto.Demand - span_start1349 = span_start(parser) + span_start1352 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "demand") - _t2131 = parse_relation_id(parser) - relation_id1348 = _t2131 + _t2137 = parse_relation_id(parser) + relation_id1351 = _t2137 consume_literal!(parser, ")") - _t2132 = Proto.Demand(relation_id=relation_id1348) - result1350 = _t2132 - record_span!(parser, span_start1349, "Demand") - return result1350 + _t2138 = Proto.Demand(relation_id=relation_id1351) + result1353 = _t2138 + record_span!(parser, span_start1352, "Demand") + return result1353 end function parse_output(parser::ParserState)::Proto.Output - span_start1353 = span_start(parser) + span_start1356 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "output") - _t2133 = parse_name(parser) - name1351 = _t2133 - _t2134 = parse_relation_id(parser) - relation_id1352 = _t2134 + _t2139 = parse_name(parser) + name1354 = _t2139 + _t2140 = parse_relation_id(parser) + relation_id1355 = _t2140 consume_literal!(parser, ")") - _t2135 = Proto.Output(name=name1351, relation_id=relation_id1352) - result1354 = _t2135 - record_span!(parser, span_start1353, "Output") - return result1354 + _t2141 = Proto.Output(name=name1354, relation_id=relation_id1355) + result1357 = _t2141 + record_span!(parser, span_start1356, "Output") + return result1357 end function parse_what_if(parser::ParserState)::Proto.WhatIf - span_start1357 = span_start(parser) + span_start1360 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "what_if") - _t2136 = parse_name(parser) - name1355 = _t2136 - _t2137 = parse_epoch(parser) - epoch1356 = _t2137 + _t2142 = parse_name(parser) + name1358 = _t2142 + _t2143 = parse_epoch(parser) + epoch1359 = _t2143 consume_literal!(parser, ")") - _t2138 = Proto.WhatIf(branch=name1355, epoch=epoch1356) - result1358 = _t2138 - record_span!(parser, span_start1357, "WhatIf") - return result1358 + _t2144 = Proto.WhatIf(branch=name1358, epoch=epoch1359) + result1361 = _t2144 + record_span!(parser, span_start1360, "WhatIf") + return result1361 end function parse_abort(parser::ParserState)::Proto.Abort - span_start1361 = span_start(parser) + span_start1364 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "abort") if (match_lookahead_literal(parser, ":", 0) && match_lookahead_terminal(parser, "SYMBOL", 1)) - _t2140 = parse_name(parser) - _t2139 = _t2140 + _t2146 = parse_name(parser) + _t2145 = _t2146 else - _t2139 = nothing + _t2145 = nothing end - name1359 = _t2139 - _t2141 = parse_relation_id(parser) - relation_id1360 = _t2141 + name1362 = _t2145 + _t2147 = parse_relation_id(parser) + relation_id1363 = _t2147 consume_literal!(parser, ")") - _t2142 = Proto.Abort(name=(!isnothing(name1359) ? name1359 : "abort"), relation_id=relation_id1360) - result1362 = _t2142 - record_span!(parser, span_start1361, "Abort") - return result1362 + _t2148 = Proto.Abort(name=(!isnothing(name1362) ? name1362 : "abort"), relation_id=relation_id1363) + result1365 = _t2148 + record_span!(parser, span_start1364, "Abort") + return result1365 end function parse_export(parser::ParserState)::Proto.Export - span_start1366 = span_start(parser) + span_start1369 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_iceberg", 1) - _t2144 = 1 + _t2150 = 1 else if match_lookahead_literal(parser, "export", 1) - _t2145 = 0 + _t2151 = 0 else - _t2145 = -1 + _t2151 = -1 end - _t2144 = _t2145 + _t2150 = _t2151 end - _t2143 = _t2144 + _t2149 = _t2150 else - _t2143 = -1 + _t2149 = -1 end - prediction1363 = _t2143 - if prediction1363 == 1 + prediction1366 = _t2149 + if prediction1366 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg") - _t2147 = parse_export_iceberg_config(parser) - export_iceberg_config1365 = _t2147 + _t2153 = parse_export_iceberg_config(parser) + export_iceberg_config1368 = _t2153 consume_literal!(parser, ")") - _t2148 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1365)) - _t2146 = _t2148 + _t2154 = Proto.Export(export_config=OneOf(:iceberg_config, export_iceberg_config1368)) + _t2152 = _t2154 else - if prediction1363 == 0 + if prediction1366 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export") - _t2150 = parse_export_csv_config(parser) - export_csv_config1364 = _t2150 + _t2156 = parse_export_csv_config(parser) + export_csv_config1367 = _t2156 consume_literal!(parser, ")") - _t2151 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1364)) - _t2149 = _t2151 + _t2157 = Proto.Export(export_config=OneOf(:csv_config, export_csv_config1367)) + _t2155 = _t2157 else throw(ParseError("Unexpected token in export" * ": " * string(lookahead(parser, 0)))) end - _t2146 = _t2149 + _t2152 = _t2155 end - result1367 = _t2146 - record_span!(parser, span_start1366, "Export") - return result1367 + result1370 = _t2152 + record_span!(parser, span_start1369, "Export") + return result1370 end function parse_export_csv_config(parser::ParserState)::Proto.ExportCSVConfig - span_start1375 = span_start(parser) + span_start1378 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "export_csv_config_v2", 1) - _t2153 = 0 + _t2159 = 0 else if match_lookahead_literal(parser, "export_csv_config", 1) - _t2154 = 1 + _t2160 = 1 else - _t2154 = -1 + _t2160 = -1 end - _t2153 = _t2154 + _t2159 = _t2160 end - _t2152 = _t2153 + _t2158 = _t2159 else - _t2152 = -1 + _t2158 = -1 end - prediction1368 = _t2152 - if prediction1368 == 1 + prediction1371 = _t2158 + if prediction1371 == 1 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config") - _t2156 = parse_export_csv_path(parser) - export_csv_path1372 = _t2156 - _t2157 = parse_export_csv_columns_list(parser) - export_csv_columns_list1373 = _t2157 - _t2158 = parse_config_dict(parser) - config_dict1374 = _t2158 + _t2162 = parse_export_csv_path(parser) + export_csv_path1375 = _t2162 + _t2163 = parse_export_csv_columns_list(parser) + export_csv_columns_list1376 = _t2163 + _t2164 = parse_config_dict(parser) + config_dict1377 = _t2164 consume_literal!(parser, ")") - _t2159 = construct_export_csv_config(parser, export_csv_path1372, export_csv_columns_list1373, config_dict1374) - _t2155 = _t2159 + _t2165 = construct_export_csv_config(parser, export_csv_path1375, export_csv_columns_list1376, config_dict1377) + _t2161 = _t2165 else - if prediction1368 == 0 + if prediction1371 == 0 consume_literal!(parser, "(") consume_literal!(parser, "export_csv_config_v2") - _t2161 = parse_export_csv_path(parser) - export_csv_path1369 = _t2161 - _t2162 = parse_export_csv_source(parser) - export_csv_source1370 = _t2162 - _t2163 = parse_csv_config(parser) - csv_config1371 = _t2163 + _t2167 = parse_export_csv_output_location(parser) + export_csv_output_location1372 = _t2167 + _t2168 = parse_export_csv_source(parser) + export_csv_source1373 = _t2168 + _t2169 = parse_csv_config(parser) + csv_config1374 = _t2169 consume_literal!(parser, ")") - _t2164 = construct_export_csv_config_with_source(parser, export_csv_path1369, export_csv_source1370, csv_config1371) - _t2160 = _t2164 + _t2170 = construct_export_csv_config_with_location(parser, export_csv_output_location1372, export_csv_source1373, csv_config1374) + _t2166 = _t2170 else throw(ParseError("Unexpected token in export_csv_config" * ": " * string(lookahead(parser, 0)))) end - _t2155 = _t2160 + _t2161 = _t2166 end - result1376 = _t2155 - record_span!(parser, span_start1375, "ExportCSVConfig") - return result1376 + result1379 = _t2161 + record_span!(parser, span_start1378, "ExportCSVConfig") + return result1379 end -function parse_export_csv_path(parser::ParserState)::String - consume_literal!(parser, "(") - consume_literal!(parser, "path") - string1377 = consume_terminal!(parser, "STRING") - consume_literal!(parser, ")") - return string1377 +function parse_export_csv_output_location(parser::ParserState)::Tuple{String, String} + if match_lookahead_literal(parser, "(", 0) + if match_lookahead_literal(parser, "transaction_output_name", 1) + _t2172 = 1 + else + if match_lookahead_literal(parser, "path", 1) + _t2173 = 0 + else + _t2173 = -1 + end + _t2172 = _t2173 + end + _t2171 = _t2172 + else + _t2171 = -1 + end + prediction1380 = _t2171 + if prediction1380 == 1 + consume_literal!(parser, "(") + consume_literal!(parser, "transaction_output_name") + _t2175 = parse_name(parser) + name1382 = _t2175 + consume_literal!(parser, ")") + _t2174 = ("", name1382,) + else + if prediction1380 == 0 + consume_literal!(parser, "(") + consume_literal!(parser, "path") + string1381 = consume_terminal!(parser, "STRING") + consume_literal!(parser, ")") + _t2176 = (string1381, "",) + else + throw(ParseError("Unexpected token in export_csv_output_location" * ": " * string(lookahead(parser, 0)))) + end + _t2174 = _t2176 + end + return _t2174 end function parse_export_csv_source(parser::ParserState)::Proto.ExportCSVSource - span_start1384 = span_start(parser) + span_start1389 = span_start(parser) if match_lookahead_literal(parser, "(", 0) if match_lookahead_literal(parser, "table_def", 1) - _t2166 = 1 + _t2178 = 1 else if match_lookahead_literal(parser, "gnf_columns", 1) - _t2167 = 0 + _t2179 = 0 else - _t2167 = -1 + _t2179 = -1 end - _t2166 = _t2167 + _t2178 = _t2179 end - _t2165 = _t2166 + _t2177 = _t2178 else - _t2165 = -1 + _t2177 = -1 end - prediction1378 = _t2165 - if prediction1378 == 1 + prediction1383 = _t2177 + if prediction1383 == 1 consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2169 = parse_relation_id(parser) - relation_id1383 = _t2169 + _t2181 = parse_relation_id(parser) + relation_id1388 = _t2181 consume_literal!(parser, ")") - _t2170 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1383)) - _t2168 = _t2170 + _t2182 = Proto.ExportCSVSource(csv_source=OneOf(:table_def, relation_id1388)) + _t2180 = _t2182 else - if prediction1378 == 0 + if prediction1383 == 0 consume_literal!(parser, "(") consume_literal!(parser, "gnf_columns") - xs1379 = Proto.ExportCSVColumn[] - cond1380 = match_lookahead_literal(parser, "(", 0) - while cond1380 - _t2172 = parse_export_csv_column(parser) - item1381 = _t2172 - push!(xs1379, item1381) - cond1380 = match_lookahead_literal(parser, "(", 0) + xs1384 = Proto.ExportCSVColumn[] + cond1385 = match_lookahead_literal(parser, "(", 0) + while cond1385 + _t2184 = parse_export_csv_column(parser) + item1386 = _t2184 + push!(xs1384, item1386) + cond1385 = match_lookahead_literal(parser, "(", 0) end - export_csv_columns1382 = xs1379 + export_csv_columns1387 = xs1384 consume_literal!(parser, ")") - _t2173 = Proto.ExportCSVColumns(columns=export_csv_columns1382) - _t2174 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2173)) - _t2171 = _t2174 + _t2185 = Proto.ExportCSVColumns(columns=export_csv_columns1387) + _t2186 = Proto.ExportCSVSource(csv_source=OneOf(:gnf_columns, _t2185)) + _t2183 = _t2186 else throw(ParseError("Unexpected token in export_csv_source" * ": " * string(lookahead(parser, 0)))) end - _t2168 = _t2171 + _t2180 = _t2183 end - result1385 = _t2168 - record_span!(parser, span_start1384, "ExportCSVSource") - return result1385 + result1390 = _t2180 + record_span!(parser, span_start1389, "ExportCSVSource") + return result1390 end function parse_export_csv_column(parser::ParserState)::Proto.ExportCSVColumn - span_start1388 = span_start(parser) + span_start1393 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "column") - string1386 = consume_terminal!(parser, "STRING") - _t2175 = parse_relation_id(parser) - relation_id1387 = _t2175 + string1391 = consume_terminal!(parser, "STRING") + _t2187 = parse_relation_id(parser) + relation_id1392 = _t2187 + consume_literal!(parser, ")") + _t2188 = Proto.ExportCSVColumn(column_name=string1391, column_data=relation_id1392) + result1394 = _t2188 + record_span!(parser, span_start1393, "ExportCSVColumn") + return result1394 +end + +function parse_export_csv_path(parser::ParserState)::String + consume_literal!(parser, "(") + consume_literal!(parser, "path") + string1395 = consume_terminal!(parser, "STRING") consume_literal!(parser, ")") - _t2176 = Proto.ExportCSVColumn(column_name=string1386, column_data=relation_id1387) - result1389 = _t2176 - record_span!(parser, span_start1388, "ExportCSVColumn") - return result1389 + return string1395 end function parse_export_csv_columns_list(parser::ParserState)::Vector{Proto.ExportCSVColumn} consume_literal!(parser, "(") consume_literal!(parser, "columns") - xs1390 = Proto.ExportCSVColumn[] - cond1391 = match_lookahead_literal(parser, "(", 0) - while cond1391 - _t2177 = parse_export_csv_column(parser) - item1392 = _t2177 - push!(xs1390, item1392) - cond1391 = match_lookahead_literal(parser, "(", 0) - end - export_csv_columns1393 = xs1390 + xs1396 = Proto.ExportCSVColumn[] + cond1397 = match_lookahead_literal(parser, "(", 0) + while cond1397 + _t2189 = parse_export_csv_column(parser) + item1398 = _t2189 + push!(xs1396, item1398) + cond1397 = match_lookahead_literal(parser, "(", 0) + end + export_csv_columns1399 = xs1396 consume_literal!(parser, ")") - return export_csv_columns1393 + return export_csv_columns1399 end function parse_export_iceberg_config(parser::ParserState)::Proto.ExportIcebergConfig - span_start1399 = span_start(parser) + span_start1405 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "export_iceberg_config") - _t2178 = parse_iceberg_locator(parser) - iceberg_locator1394 = _t2178 - _t2179 = parse_iceberg_catalog_config(parser) - iceberg_catalog_config1395 = _t2179 - _t2180 = parse_export_iceberg_table_def(parser) - export_iceberg_table_def1396 = _t2180 - _t2181 = parse_iceberg_table_properties(parser) - iceberg_table_properties1397 = _t2181 + _t2190 = parse_iceberg_locator(parser) + iceberg_locator1400 = _t2190 + _t2191 = parse_iceberg_catalog_config(parser) + iceberg_catalog_config1401 = _t2191 + _t2192 = parse_export_iceberg_table_def(parser) + export_iceberg_table_def1402 = _t2192 + _t2193 = parse_iceberg_table_properties(parser) + iceberg_table_properties1403 = _t2193 if match_lookahead_literal(parser, "{", 0) - _t2183 = parse_config_dict(parser) - _t2182 = _t2183 + _t2195 = parse_config_dict(parser) + _t2194 = _t2195 else - _t2182 = nothing + _t2194 = nothing end - config_dict1398 = _t2182 + config_dict1404 = _t2194 consume_literal!(parser, ")") - _t2184 = construct_export_iceberg_config_full(parser, iceberg_locator1394, iceberg_catalog_config1395, export_iceberg_table_def1396, iceberg_table_properties1397, config_dict1398) - result1400 = _t2184 - record_span!(parser, span_start1399, "ExportIcebergConfig") - return result1400 + _t2196 = construct_export_iceberg_config_full(parser, iceberg_locator1400, iceberg_catalog_config1401, export_iceberg_table_def1402, iceberg_table_properties1403, config_dict1404) + result1406 = _t2196 + record_span!(parser, span_start1405, "ExportIcebergConfig") + return result1406 end function parse_export_iceberg_table_def(parser::ParserState)::Proto.RelationId - span_start1402 = span_start(parser) + span_start1408 = span_start(parser) consume_literal!(parser, "(") consume_literal!(parser, "table_def") - _t2185 = parse_relation_id(parser) - relation_id1401 = _t2185 + _t2197 = parse_relation_id(parser) + relation_id1407 = _t2197 consume_literal!(parser, ")") - result1403 = relation_id1401 - record_span!(parser, span_start1402, "RelationId") - return result1403 + result1409 = relation_id1407 + record_span!(parser, span_start1408, "RelationId") + return result1409 end function parse_iceberg_table_properties(parser::ParserState)::Vector{Tuple{String, String}} consume_literal!(parser, "(") consume_literal!(parser, "table_properties") - xs1404 = Tuple{String, String}[] - cond1405 = match_lookahead_literal(parser, "(", 0) - while cond1405 - _t2186 = parse_iceberg_property_entry(parser) - item1406 = _t2186 - push!(xs1404, item1406) - cond1405 = match_lookahead_literal(parser, "(", 0) - end - iceberg_property_entrys1407 = xs1404 + xs1410 = Tuple{String, String}[] + cond1411 = match_lookahead_literal(parser, "(", 0) + while cond1411 + _t2198 = parse_iceberg_property_entry(parser) + item1412 = _t2198 + push!(xs1410, item1412) + cond1411 = match_lookahead_literal(parser, "(", 0) + end + iceberg_property_entrys1413 = xs1410 consume_literal!(parser, ")") - return iceberg_property_entrys1407 + return iceberg_property_entrys1413 end diff --git a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl index b5d1f2ca..3ae409df 100644 --- a/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl +++ b/sdks/julia/LogicalQueryProtocol.jl/src/pretty.jl @@ -380,7 +380,7 @@ function deconstruct_csv_data_columns_optional(pp::PrettyPrinter, msg::Proto.CSV if _has_proto_field(msg, Symbol("relations")) return nothing else - _t1876 = nothing + _t1889 = nothing end return msg.columns end @@ -389,95 +389,99 @@ function deconstruct_csv_data_relations_optional(pp::PrettyPrinter, msg::Proto.C if _has_proto_field(msg, Symbol("relations")) return msg.relations else - _t1877 = nothing + _t1890 = nothing end return nothing end +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 - _t1878 = Proto.Value(value=OneOf(:int32_value, v)) - return _t1878 + _t1891 = Proto.Value(value=OneOf(:int32_value, v)) + return _t1891 end function _make_value_int64(pp::PrettyPrinter, v::Int64)::Proto.Value - _t1879 = Proto.Value(value=OneOf(:int_value, v)) - return _t1879 + _t1892 = Proto.Value(value=OneOf(:int_value, v)) + return _t1892 end function _make_value_float64(pp::PrettyPrinter, v::Float64)::Proto.Value - _t1880 = Proto.Value(value=OneOf(:float_value, v)) - return _t1880 + _t1893 = Proto.Value(value=OneOf(:float_value, v)) + return _t1893 end function _make_value_string(pp::PrettyPrinter, v::String)::Proto.Value - _t1881 = Proto.Value(value=OneOf(:string_value, v)) - return _t1881 + _t1894 = Proto.Value(value=OneOf(:string_value, v)) + return _t1894 end function _make_value_boolean(pp::PrettyPrinter, v::Bool)::Proto.Value - _t1882 = Proto.Value(value=OneOf(:boolean_value, v)) - return _t1882 + _t1895 = Proto.Value(value=OneOf(:boolean_value, v)) + return _t1895 end function _make_value_uint128(pp::PrettyPrinter, v::Proto.UInt128Value)::Proto.Value - _t1883 = Proto.Value(value=OneOf(:uint128_value, v)) - return _t1883 + _t1896 = Proto.Value(value=OneOf(:uint128_value, v)) + return _t1896 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 - _t1884 = _make_value_string(pp, "auto") - push!(result, ("ivm.maintenance_level", _t1884,)) + _t1897 = _make_value_string(pp, "auto") + push!(result, ("ivm.maintenance_level", _t1897,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_ALL - _t1885 = _make_value_string(pp, "all") - push!(result, ("ivm.maintenance_level", _t1885,)) + _t1898 = _make_value_string(pp, "all") + push!(result, ("ivm.maintenance_level", _t1898,)) else if msg.ivm_config.level == Proto.MaintenanceLevel.MAINTENANCE_LEVEL_OFF - _t1886 = _make_value_string(pp, "off") - push!(result, ("ivm.maintenance_level", _t1886,)) + _t1899 = _make_value_string(pp, "off") + push!(result, ("ivm.maintenance_level", _t1899,)) end end end - _t1887 = _make_value_int64(pp, msg.semantics_version) - push!(result, ("semantics_version", _t1887,)) + _t1900 = _make_value_int64(pp, msg.semantics_version) + push!(result, ("semantics_version", _t1900,)) return sort(result) end function deconstruct_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig)::Vector{Tuple{String, Proto.Value}} result = Tuple{String, Proto.Value}[] - _t1888 = _make_value_int32(pp, msg.header_row) - push!(result, ("csv_header_row", _t1888,)) - _t1889 = _make_value_int64(pp, msg.skip) - push!(result, ("csv_skip", _t1889,)) + _t1901 = _make_value_int32(pp, msg.header_row) + push!(result, ("csv_header_row", _t1901,)) + _t1902 = _make_value_int64(pp, msg.skip) + push!(result, ("csv_skip", _t1902,)) if msg.new_line != "" - _t1890 = _make_value_string(pp, msg.new_line) - push!(result, ("csv_new_line", _t1890,)) - end - _t1891 = _make_value_string(pp, msg.delimiter) - push!(result, ("csv_delimiter", _t1891,)) - _t1892 = _make_value_string(pp, msg.quotechar) - push!(result, ("csv_quotechar", _t1892,)) - _t1893 = _make_value_string(pp, msg.escapechar) - push!(result, ("csv_escapechar", _t1893,)) + _t1903 = _make_value_string(pp, msg.new_line) + push!(result, ("csv_new_line", _t1903,)) + end + _t1904 = _make_value_string(pp, msg.delimiter) + push!(result, ("csv_delimiter", _t1904,)) + _t1905 = _make_value_string(pp, msg.quotechar) + push!(result, ("csv_quotechar", _t1905,)) + _t1906 = _make_value_string(pp, msg.escapechar) + push!(result, ("csv_escapechar", _t1906,)) if msg.comment != "" - _t1894 = _make_value_string(pp, msg.comment) - push!(result, ("csv_comment", _t1894,)) + _t1907 = _make_value_string(pp, msg.comment) + push!(result, ("csv_comment", _t1907,)) end for missing_string in msg.missing_strings - _t1895 = _make_value_string(pp, missing_string) - push!(result, ("csv_missing_strings", _t1895,)) - end - _t1896 = _make_value_string(pp, msg.decimal_separator) - push!(result, ("csv_decimal_separator", _t1896,)) - _t1897 = _make_value_string(pp, msg.encoding) - push!(result, ("csv_encoding", _t1897,)) - _t1898 = _make_value_string(pp, msg.compression) - push!(result, ("csv_compression", _t1898,)) + _t1908 = _make_value_string(pp, missing_string) + push!(result, ("csv_missing_strings", _t1908,)) + end + _t1909 = _make_value_string(pp, msg.decimal_separator) + push!(result, ("csv_decimal_separator", _t1909,)) + _t1910 = _make_value_string(pp, msg.encoding) + push!(result, ("csv_encoding", _t1910,)) + _t1911 = _make_value_string(pp, msg.compression) + push!(result, ("csv_compression", _t1911,)) if msg.partition_size_mb != 0 - _t1899 = _make_value_int64(pp, msg.partition_size_mb) - push!(result, ("csv_partition_size_mb", _t1899,)) + _t1912 = _make_value_int64(pp, msg.partition_size_mb) + push!(result, ("csv_partition_size_mb", _t1912,)) end return sort(result) end @@ -486,91 +490,91 @@ function deconstruct_csv_storage_integration_optional(pp::PrettyPrinter, msg::Pr if !_has_proto_field(msg, Symbol("storage_integration")) return nothing else - _t1900 = nothing + _t1913 = nothing end si = msg.storage_integration result = Tuple{String, Proto.Value}[] if si.provider != "" - _t1901 = _make_value_string(pp, si.provider) - push!(result, ("provider", _t1901,)) + _t1914 = _make_value_string(pp, si.provider) + push!(result, ("provider", _t1914,)) end if si.azure_sas_token != "" - _t1902 = _make_value_string(pp, "***") - push!(result, ("azure_sas_token", _t1902,)) + _t1915 = _make_value_string(pp, "***") + push!(result, ("azure_sas_token", _t1915,)) end if si.s3_region != "" - _t1903 = _make_value_string(pp, si.s3_region) - push!(result, ("s3_region", _t1903,)) + _t1916 = _make_value_string(pp, si.s3_region) + push!(result, ("s3_region", _t1916,)) end if si.s3_access_key_id != "" - _t1904 = _make_value_string(pp, "***") - push!(result, ("s3_access_key_id", _t1904,)) + _t1917 = _make_value_string(pp, "***") + push!(result, ("s3_access_key_id", _t1917,)) end if si.s3_secret_access_key != "" - _t1905 = _make_value_string(pp, "***") - push!(result, ("s3_secret_access_key", _t1905,)) + _t1918 = _make_value_string(pp, "***") + push!(result, ("s3_secret_access_key", _t1918,)) 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}[] - _t1906 = _make_value_float64(pp, msg.storage_config.epsilon) - push!(result, ("betree_config_epsilon", _t1906,)) - _t1907 = _make_value_int64(pp, msg.storage_config.max_pivots) - push!(result, ("betree_config_max_pivots", _t1907,)) - _t1908 = _make_value_int64(pp, msg.storage_config.max_deltas) - push!(result, ("betree_config_max_deltas", _t1908,)) - _t1909 = _make_value_int64(pp, msg.storage_config.max_leaf) - push!(result, ("betree_config_max_leaf", _t1909,)) + _t1919 = _make_value_float64(pp, msg.storage_config.epsilon) + push!(result, ("betree_config_epsilon", _t1919,)) + _t1920 = _make_value_int64(pp, msg.storage_config.max_pivots) + push!(result, ("betree_config_max_pivots", _t1920,)) + _t1921 = _make_value_int64(pp, msg.storage_config.max_deltas) + push!(result, ("betree_config_max_deltas", _t1921,)) + _t1922 = _make_value_int64(pp, msg.storage_config.max_leaf) + push!(result, ("betree_config_max_leaf", _t1922,)) if _has_proto_field(msg.relation_locator, Symbol("root_pageid")) if !isnothing(_get_oneof_field(msg.relation_locator, :root_pageid)) - _t1910 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) - push!(result, ("betree_locator_root_pageid", _t1910,)) + _t1923 = _make_value_uint128(pp, _get_oneof_field(msg.relation_locator, :root_pageid)) + push!(result, ("betree_locator_root_pageid", _t1923,)) end end if _has_proto_field(msg.relation_locator, Symbol("inline_data")) if !isnothing(_get_oneof_field(msg.relation_locator, :inline_data)) - _t1911 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) - push!(result, ("betree_locator_inline_data", _t1911,)) + _t1924 = _make_value_string(pp, String(copy(_get_oneof_field(msg.relation_locator, :inline_data)))) + push!(result, ("betree_locator_inline_data", _t1924,)) end end - _t1912 = _make_value_int64(pp, msg.relation_locator.element_count) - push!(result, ("betree_locator_element_count", _t1912,)) - _t1913 = _make_value_int64(pp, msg.relation_locator.tree_height) - push!(result, ("betree_locator_tree_height", _t1913,)) + _t1925 = _make_value_int64(pp, msg.relation_locator.element_count) + push!(result, ("betree_locator_element_count", _t1925,)) + _t1926 = _make_value_int64(pp, msg.relation_locator.tree_height) + push!(result, ("betree_locator_tree_height", _t1926,)) 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) - _t1914 = _make_value_int64(pp, msg.partition_size) - push!(result, ("partition_size", _t1914,)) + _t1927 = _make_value_int64(pp, msg.partition_size) + push!(result, ("partition_size", _t1927,)) end if !isnothing(msg.compression) - _t1915 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1915,)) + _t1928 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1928,)) end if !isnothing(msg.syntax_header_row) - _t1916 = _make_value_boolean(pp, msg.syntax_header_row) - push!(result, ("syntax_header_row", _t1916,)) + _t1929 = _make_value_boolean(pp, msg.syntax_header_row) + push!(result, ("syntax_header_row", _t1929,)) end if !isnothing(msg.syntax_missing_string) - _t1917 = _make_value_string(pp, msg.syntax_missing_string) - push!(result, ("syntax_missing_string", _t1917,)) + _t1930 = _make_value_string(pp, msg.syntax_missing_string) + push!(result, ("syntax_missing_string", _t1930,)) end if !isnothing(msg.syntax_delim) - _t1918 = _make_value_string(pp, msg.syntax_delim) - push!(result, ("syntax_delim", _t1918,)) + _t1931 = _make_value_string(pp, msg.syntax_delim) + push!(result, ("syntax_delim", _t1931,)) end if !isnothing(msg.syntax_quotechar) - _t1919 = _make_value_string(pp, msg.syntax_quotechar) - push!(result, ("syntax_quotechar", _t1919,)) + _t1932 = _make_value_string(pp, msg.syntax_quotechar) + push!(result, ("syntax_quotechar", _t1932,)) end if !isnothing(msg.syntax_escapechar) - _t1920 = _make_value_string(pp, msg.syntax_escapechar) - push!(result, ("syntax_escapechar", _t1920,)) + _t1933 = _make_value_string(pp, msg.syntax_escapechar) + push!(result, ("syntax_escapechar", _t1933,)) end return sort(result) end @@ -583,7 +587,7 @@ function deconstruct_iceberg_catalog_config_scope_optional(pp::PrettyPrinter, ms if msg.scope != "" return msg.scope else - _t1921 = nothing + _t1934 = nothing end return nothing end @@ -592,7 +596,7 @@ function deconstruct_iceberg_data_from_snapshot_optional(pp::PrettyPrinter, msg: if msg.from_snapshot != "" return msg.from_snapshot else - _t1922 = nothing + _t1935 = nothing end return nothing end @@ -601,7 +605,7 @@ function deconstruct_iceberg_data_to_snapshot_optional(pp::PrettyPrinter, msg::P if msg.to_snapshot != "" return msg.to_snapshot else - _t1923 = nothing + _t1936 = nothing end return nothing end @@ -609,21 +613,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 != "" - _t1924 = _make_value_string(pp, msg.prefix) - push!(result, ("prefix", _t1924,)) + _t1937 = _make_value_string(pp, msg.prefix) + push!(result, ("prefix", _t1937,)) end if msg.target_file_size_bytes != 0 - _t1925 = _make_value_int64(pp, msg.target_file_size_bytes) - push!(result, ("target_file_size_bytes", _t1925,)) + _t1938 = _make_value_int64(pp, msg.target_file_size_bytes) + push!(result, ("target_file_size_bytes", _t1938,)) end if msg.compression != "" - _t1926 = _make_value_string(pp, msg.compression) - push!(result, ("compression", _t1926,)) + _t1939 = _make_value_string(pp, msg.compression) + push!(result, ("compression", _t1939,)) end if length(result) == 0 return nothing else - _t1927 = nothing + _t1940 = nothing end return sort(result) end @@ -638,7 +642,7 @@ function deconstruct_relation_id_uint128(pp::PrettyPrinter, msg::Proto.RelationI if isnothing(name) return relation_id_to_uint128(pp, msg) else - _t1928 = nothing + _t1941 = nothing end return nothing end @@ -657,47 +661,47 @@ end # --- Pretty-print functions --- function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) - flat851 = try_flat(pp, msg, pretty_transaction) - if !isnothing(flat851) - write(pp, flat851) + flat856 = try_flat(pp, msg, pretty_transaction) + if !isnothing(flat856) + write(pp, flat856) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("configure")) - _t1684 = _dollar_dollar.configure + _t1694 = _dollar_dollar.configure else - _t1684 = nothing + _t1694 = nothing end if _has_proto_field(_dollar_dollar, Symbol("sync")) - _t1685 = _dollar_dollar.sync + _t1695 = _dollar_dollar.sync else - _t1685 = nothing + _t1695 = nothing end - fields842 = (_t1684, _t1685, _dollar_dollar.epochs,) - unwrapped_fields843 = fields842 + fields847 = (_t1694, _t1695, _dollar_dollar.epochs,) + unwrapped_fields848 = fields847 write(pp, "(transaction") indent_sexp!(pp) - field844 = unwrapped_fields843[1] - if !isnothing(field844) + field849 = unwrapped_fields848[1] + if !isnothing(field849) newline(pp) - opt_val845 = field844 - pretty_configure(pp, opt_val845) + opt_val850 = field849 + pretty_configure(pp, opt_val850) end - field846 = unwrapped_fields843[2] - if !isnothing(field846) + field851 = unwrapped_fields848[2] + if !isnothing(field851) newline(pp) - opt_val847 = field846 - pretty_sync(pp, opt_val847) + opt_val852 = field851 + pretty_sync(pp, opt_val852) end - field848 = unwrapped_fields843[3] - if !isempty(field848) + field853 = unwrapped_fields848[3] + if !isempty(field853) newline(pp) - for (i1686, elem849) in enumerate(field848) - i850 = i1686 - 1 - if (i850 > 0) + for (i1696, elem854) in enumerate(field853) + i855 = i1696 - 1 + if (i855 > 0) newline(pp) end - pretty_epoch(pp, elem849) + pretty_epoch(pp, elem854) end end dedent!(pp) @@ -707,19 +711,19 @@ function pretty_transaction(pp::PrettyPrinter, msg::Proto.Transaction) end function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) - flat854 = try_flat(pp, msg, pretty_configure) - if !isnothing(flat854) - write(pp, flat854) + flat859 = try_flat(pp, msg, pretty_configure) + if !isnothing(flat859) + write(pp, flat859) return nothing else _dollar_dollar = msg - _t1687 = deconstruct_configure(pp, _dollar_dollar) - fields852 = _t1687 - unwrapped_fields853 = fields852 + _t1697 = deconstruct_configure(pp, _dollar_dollar) + fields857 = _t1697 + unwrapped_fields858 = fields857 write(pp, "(configure") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, unwrapped_fields853) + pretty_config_dict(pp, unwrapped_fields858) dedent!(pp) write(pp, ")") end @@ -727,22 +731,22 @@ function pretty_configure(pp::PrettyPrinter, msg::Proto.Configure) end function pretty_config_dict(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat858 = try_flat(pp, msg, pretty_config_dict) - if !isnothing(flat858) - write(pp, flat858) + flat863 = try_flat(pp, msg, pretty_config_dict) + if !isnothing(flat863) + write(pp, flat863) return nothing else - fields855 = msg + fields860 = msg write(pp, "{") indent!(pp) - if !isempty(fields855) + if !isempty(fields860) newline(pp) - for (i1688, elem856) in enumerate(fields855) - i857 = i1688 - 1 - if (i857 > 0) + for (i1698, elem861) in enumerate(fields860) + i862 = i1698 - 1 + if (i862 > 0) newline(pp) end - pretty_config_key_value(pp, elem856) + pretty_config_key_value(pp, elem861) end end dedent!(pp) @@ -752,163 +756,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}) - flat863 = try_flat(pp, msg, pretty_config_key_value) - if !isnothing(flat863) - write(pp, flat863) + flat868 = try_flat(pp, msg, pretty_config_key_value) + if !isnothing(flat868) + write(pp, flat868) return nothing else _dollar_dollar = msg - fields859 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields860 = fields859 + fields864 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields865 = fields864 write(pp, ":") - field861 = unwrapped_fields860[1] - write(pp, field861) + field866 = unwrapped_fields865[1] + write(pp, field866) write(pp, " ") - field862 = unwrapped_fields860[2] - pretty_raw_value(pp, field862) + field867 = unwrapped_fields865[2] + pretty_raw_value(pp, field867) end return nothing end function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) - flat889 = try_flat(pp, msg, pretty_raw_value) - if !isnothing(flat889) - write(pp, flat889) + flat894 = try_flat(pp, msg, pretty_raw_value) + if !isnothing(flat894) + write(pp, flat894) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1689 = _get_oneof_field(_dollar_dollar, :date_value) + _t1699 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1689 = nothing + _t1699 = nothing end - deconstruct_result887 = _t1689 - if !isnothing(deconstruct_result887) - unwrapped888 = deconstruct_result887 - pretty_raw_date(pp, unwrapped888) + deconstruct_result892 = _t1699 + if !isnothing(deconstruct_result892) + unwrapped893 = deconstruct_result892 + pretty_raw_date(pp, unwrapped893) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1690 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1700 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1690 = nothing + _t1700 = nothing end - deconstruct_result885 = _t1690 - if !isnothing(deconstruct_result885) - unwrapped886 = deconstruct_result885 - pretty_raw_datetime(pp, unwrapped886) + deconstruct_result890 = _t1700 + if !isnothing(deconstruct_result890) + unwrapped891 = deconstruct_result890 + pretty_raw_datetime(pp, unwrapped891) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1691 = _get_oneof_field(_dollar_dollar, :string_value) + _t1701 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1691 = nothing + _t1701 = nothing end - deconstruct_result883 = _t1691 - if !isnothing(deconstruct_result883) - unwrapped884 = deconstruct_result883 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped884)) + deconstruct_result888 = _t1701 + if !isnothing(deconstruct_result888) + unwrapped889 = deconstruct_result888 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped889)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1692 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1702 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1692 = nothing + _t1702 = nothing end - deconstruct_result881 = _t1692 - if !isnothing(deconstruct_result881) - unwrapped882 = deconstruct_result881 - write(pp, (string(Int64(unwrapped882)) * "i32")) + deconstruct_result886 = _t1702 + if !isnothing(deconstruct_result886) + unwrapped887 = deconstruct_result886 + write(pp, (string(Int64(unwrapped887)) * "i32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1693 = _get_oneof_field(_dollar_dollar, :int_value) + _t1703 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1693 = nothing + _t1703 = nothing end - deconstruct_result879 = _t1693 - if !isnothing(deconstruct_result879) - unwrapped880 = deconstruct_result879 - write(pp, string(unwrapped880)) + deconstruct_result884 = _t1703 + if !isnothing(deconstruct_result884) + unwrapped885 = deconstruct_result884 + write(pp, string(unwrapped885)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1694 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1704 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1694 = nothing + _t1704 = nothing end - deconstruct_result877 = _t1694 - if !isnothing(deconstruct_result877) - unwrapped878 = deconstruct_result877 - write(pp, format_float32_literal(unwrapped878)) + deconstruct_result882 = _t1704 + if !isnothing(deconstruct_result882) + unwrapped883 = deconstruct_result882 + write(pp, format_float32_literal(unwrapped883)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1695 = _get_oneof_field(_dollar_dollar, :float_value) + _t1705 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1695 = nothing + _t1705 = nothing end - deconstruct_result875 = _t1695 - if !isnothing(deconstruct_result875) - unwrapped876 = deconstruct_result875 - write(pp, lowercase(string(unwrapped876))) + deconstruct_result880 = _t1705 + if !isnothing(deconstruct_result880) + unwrapped881 = deconstruct_result880 + write(pp, lowercase(string(unwrapped881))) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1696 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1706 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1696 = nothing + _t1706 = nothing end - deconstruct_result873 = _t1696 - if !isnothing(deconstruct_result873) - unwrapped874 = deconstruct_result873 - write(pp, (string(Int64(unwrapped874)) * "u32")) + deconstruct_result878 = _t1706 + if !isnothing(deconstruct_result878) + unwrapped879 = deconstruct_result878 + write(pp, (string(Int64(unwrapped879)) * "u32")) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1697 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1707 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1697 = nothing + _t1707 = nothing end - deconstruct_result871 = _t1697 - if !isnothing(deconstruct_result871) - unwrapped872 = deconstruct_result871 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped872)) + deconstruct_result876 = _t1707 + if !isnothing(deconstruct_result876) + unwrapped877 = deconstruct_result876 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped877)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1698 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1708 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1698 = nothing + _t1708 = nothing end - deconstruct_result869 = _t1698 - if !isnothing(deconstruct_result869) - unwrapped870 = deconstruct_result869 - write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped870)) + deconstruct_result874 = _t1708 + if !isnothing(deconstruct_result874) + unwrapped875 = deconstruct_result874 + write(pp, format_int128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped875)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1699 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1709 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1699 = nothing + _t1709 = nothing end - deconstruct_result867 = _t1699 - if !isnothing(deconstruct_result867) - unwrapped868 = deconstruct_result867 - write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped868)) + deconstruct_result872 = _t1709 + if !isnothing(deconstruct_result872) + unwrapped873 = deconstruct_result872 + write(pp, format_decimal(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped873)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1700 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1710 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1700 = nothing + _t1710 = nothing end - deconstruct_result865 = _t1700 - if !isnothing(deconstruct_result865) - unwrapped866 = deconstruct_result865 - pretty_boolean_value(pp, unwrapped866) + deconstruct_result870 = _t1710 + if !isnothing(deconstruct_result870) + unwrapped871 = deconstruct_result870 + pretty_boolean_value(pp, unwrapped871) else - fields864 = msg + fields869 = msg write(pp, "missing") end end @@ -927,25 +931,25 @@ function pretty_raw_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat895 = try_flat(pp, msg, pretty_raw_date) - if !isnothing(flat895) - write(pp, flat895) + flat900 = try_flat(pp, msg, pretty_raw_date) + if !isnothing(flat900) + write(pp, flat900) return nothing else _dollar_dollar = msg - fields890 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields891 = fields890 + fields895 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields896 = fields895 write(pp, "(date") indent_sexp!(pp) newline(pp) - field892 = unwrapped_fields891[1] - write(pp, string(field892)) + field897 = unwrapped_fields896[1] + write(pp, string(field897)) newline(pp) - field893 = unwrapped_fields891[2] - write(pp, string(field893)) + field898 = unwrapped_fields896[2] + write(pp, string(field898)) newline(pp) - field894 = unwrapped_fields891[3] - write(pp, string(field894)) + field899 = unwrapped_fields896[3] + write(pp, string(field899)) dedent!(pp) write(pp, ")") end @@ -953,39 +957,39 @@ function pretty_raw_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_raw_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat906 = try_flat(pp, msg, pretty_raw_datetime) - if !isnothing(flat906) - write(pp, flat906) + flat911 = try_flat(pp, msg, pretty_raw_datetime) + if !isnothing(flat911) + write(pp, flat911) return nothing else _dollar_dollar = msg - fields896 = (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_fields897 = fields896 + fields901 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),) + unwrapped_fields902 = fields901 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field898 = unwrapped_fields897[1] - write(pp, string(field898)) + field903 = unwrapped_fields902[1] + write(pp, string(field903)) newline(pp) - field899 = unwrapped_fields897[2] - write(pp, string(field899)) + field904 = unwrapped_fields902[2] + write(pp, string(field904)) newline(pp) - field900 = unwrapped_fields897[3] - write(pp, string(field900)) + field905 = unwrapped_fields902[3] + write(pp, string(field905)) newline(pp) - field901 = unwrapped_fields897[4] - write(pp, string(field901)) + field906 = unwrapped_fields902[4] + write(pp, string(field906)) newline(pp) - field902 = unwrapped_fields897[5] - write(pp, string(field902)) + field907 = unwrapped_fields902[5] + write(pp, string(field907)) newline(pp) - field903 = unwrapped_fields897[6] - write(pp, string(field903)) - field904 = unwrapped_fields897[7] - if !isnothing(field904) + field908 = unwrapped_fields902[6] + write(pp, string(field908)) + field909 = unwrapped_fields902[7] + if !isnothing(field909) newline(pp) - opt_val905 = field904 - write(pp, string(opt_val905)) + opt_val910 = field909 + write(pp, string(opt_val910)) end dedent!(pp) write(pp, ")") @@ -996,24 +1000,24 @@ end function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) _dollar_dollar = msg if _dollar_dollar - _t1701 = () + _t1711 = () else - _t1701 = nothing + _t1711 = nothing end - deconstruct_result909 = _t1701 - if !isnothing(deconstruct_result909) - unwrapped910 = deconstruct_result909 + deconstruct_result914 = _t1711 + if !isnothing(deconstruct_result914) + unwrapped915 = deconstruct_result914 write(pp, "true") else _dollar_dollar = msg if !_dollar_dollar - _t1702 = () + _t1712 = () else - _t1702 = nothing + _t1712 = nothing end - deconstruct_result907 = _t1702 - if !isnothing(deconstruct_result907) - unwrapped908 = deconstruct_result907 + deconstruct_result912 = _t1712 + if !isnothing(deconstruct_result912) + unwrapped913 = deconstruct_result912 write(pp, "false") else throw(ParseError("No matching rule for boolean_value")) @@ -1023,24 +1027,24 @@ function pretty_boolean_value(pp::PrettyPrinter, msg::Bool) end function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) - flat915 = try_flat(pp, msg, pretty_sync) - if !isnothing(flat915) - write(pp, flat915) + flat920 = try_flat(pp, msg, pretty_sync) + if !isnothing(flat920) + write(pp, flat920) return nothing else _dollar_dollar = msg - fields911 = _dollar_dollar.fragments - unwrapped_fields912 = fields911 + fields916 = _dollar_dollar.fragments + unwrapped_fields917 = fields916 write(pp, "(sync") indent_sexp!(pp) - if !isempty(unwrapped_fields912) + if !isempty(unwrapped_fields917) newline(pp) - for (i1703, elem913) in enumerate(unwrapped_fields912) - i914 = i1703 - 1 - if (i914 > 0) + for (i1713, elem918) in enumerate(unwrapped_fields917) + i919 = i1713 - 1 + if (i919 > 0) newline(pp) end - pretty_fragment_id(pp, elem913) + pretty_fragment_id(pp, elem918) end end dedent!(pp) @@ -1050,52 +1054,52 @@ function pretty_sync(pp::PrettyPrinter, msg::Proto.Sync) end function pretty_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat918 = try_flat(pp, msg, pretty_fragment_id) - if !isnothing(flat918) - write(pp, flat918) + flat923 = try_flat(pp, msg, pretty_fragment_id) + if !isnothing(flat923) + write(pp, flat923) return nothing else _dollar_dollar = msg - fields916 = fragment_id_to_string(pp, _dollar_dollar) - unwrapped_fields917 = fields916 + fields921 = fragment_id_to_string(pp, _dollar_dollar) + unwrapped_fields922 = fields921 write(pp, ":") - write(pp, unwrapped_fields917) + write(pp, unwrapped_fields922) end return nothing end function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) - flat925 = try_flat(pp, msg, pretty_epoch) - if !isnothing(flat925) - write(pp, flat925) + flat930 = try_flat(pp, msg, pretty_epoch) + if !isnothing(flat930) + write(pp, flat930) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.writes) - _t1704 = _dollar_dollar.writes + _t1714 = _dollar_dollar.writes else - _t1704 = nothing + _t1714 = nothing end if !isempty(_dollar_dollar.reads) - _t1705 = _dollar_dollar.reads + _t1715 = _dollar_dollar.reads else - _t1705 = nothing + _t1715 = nothing end - fields919 = (_t1704, _t1705,) - unwrapped_fields920 = fields919 + fields924 = (_t1714, _t1715,) + unwrapped_fields925 = fields924 write(pp, "(epoch") indent_sexp!(pp) - field921 = unwrapped_fields920[1] - if !isnothing(field921) + field926 = unwrapped_fields925[1] + if !isnothing(field926) newline(pp) - opt_val922 = field921 - pretty_epoch_writes(pp, opt_val922) + opt_val927 = field926 + pretty_epoch_writes(pp, opt_val927) end - field923 = unwrapped_fields920[2] - if !isnothing(field923) + field928 = unwrapped_fields925[2] + if !isnothing(field928) newline(pp) - opt_val924 = field923 - pretty_epoch_reads(pp, opt_val924) + opt_val929 = field928 + pretty_epoch_reads(pp, opt_val929) end dedent!(pp) write(pp, ")") @@ -1104,22 +1108,22 @@ function pretty_epoch(pp::PrettyPrinter, msg::Proto.Epoch) end function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) - flat929 = try_flat(pp, msg, pretty_epoch_writes) - if !isnothing(flat929) - write(pp, flat929) + flat934 = try_flat(pp, msg, pretty_epoch_writes) + if !isnothing(flat934) + write(pp, flat934) return nothing else - fields926 = msg + fields931 = msg write(pp, "(writes") indent_sexp!(pp) - if !isempty(fields926) + if !isempty(fields931) newline(pp) - for (i1706, elem927) in enumerate(fields926) - i928 = i1706 - 1 - if (i928 > 0) + for (i1716, elem932) in enumerate(fields931) + i933 = i1716 - 1 + if (i933 > 0) newline(pp) end - pretty_write(pp, elem927) + pretty_write(pp, elem932) end end dedent!(pp) @@ -1129,54 +1133,54 @@ function pretty_epoch_writes(pp::PrettyPrinter, msg::Vector{Proto.Write}) end function pretty_write(pp::PrettyPrinter, msg::Proto.Write) - flat938 = try_flat(pp, msg, pretty_write) - if !isnothing(flat938) - write(pp, flat938) + flat943 = try_flat(pp, msg, pretty_write) + if !isnothing(flat943) + write(pp, flat943) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("define")) - _t1707 = _get_oneof_field(_dollar_dollar, :define) + _t1717 = _get_oneof_field(_dollar_dollar, :define) else - _t1707 = nothing + _t1717 = nothing end - deconstruct_result936 = _t1707 - if !isnothing(deconstruct_result936) - unwrapped937 = deconstruct_result936 - pretty_define(pp, unwrapped937) + deconstruct_result941 = _t1717 + if !isnothing(deconstruct_result941) + unwrapped942 = deconstruct_result941 + pretty_define(pp, unwrapped942) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("undefine")) - _t1708 = _get_oneof_field(_dollar_dollar, :undefine) + _t1718 = _get_oneof_field(_dollar_dollar, :undefine) else - _t1708 = nothing + _t1718 = nothing end - deconstruct_result934 = _t1708 - if !isnothing(deconstruct_result934) - unwrapped935 = deconstruct_result934 - pretty_undefine(pp, unwrapped935) + deconstruct_result939 = _t1718 + if !isnothing(deconstruct_result939) + unwrapped940 = deconstruct_result939 + pretty_undefine(pp, unwrapped940) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("context")) - _t1709 = _get_oneof_field(_dollar_dollar, :context) + _t1719 = _get_oneof_field(_dollar_dollar, :context) else - _t1709 = nothing + _t1719 = nothing end - deconstruct_result932 = _t1709 - if !isnothing(deconstruct_result932) - unwrapped933 = deconstruct_result932 - pretty_context(pp, unwrapped933) + deconstruct_result937 = _t1719 + if !isnothing(deconstruct_result937) + unwrapped938 = deconstruct_result937 + pretty_context(pp, unwrapped938) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("snapshot")) - _t1710 = _get_oneof_field(_dollar_dollar, :snapshot) + _t1720 = _get_oneof_field(_dollar_dollar, :snapshot) else - _t1710 = nothing + _t1720 = nothing end - deconstruct_result930 = _t1710 - if !isnothing(deconstruct_result930) - unwrapped931 = deconstruct_result930 - pretty_snapshot(pp, unwrapped931) + deconstruct_result935 = _t1720 + if !isnothing(deconstruct_result935) + unwrapped936 = deconstruct_result935 + pretty_snapshot(pp, unwrapped936) else throw(ParseError("No matching rule for write")) end @@ -1188,18 +1192,18 @@ function pretty_write(pp::PrettyPrinter, msg::Proto.Write) end function pretty_define(pp::PrettyPrinter, msg::Proto.Define) - flat941 = try_flat(pp, msg, pretty_define) - if !isnothing(flat941) - write(pp, flat941) + flat946 = try_flat(pp, msg, pretty_define) + if !isnothing(flat946) + write(pp, flat946) return nothing else _dollar_dollar = msg - fields939 = _dollar_dollar.fragment - unwrapped_fields940 = fields939 + fields944 = _dollar_dollar.fragment + unwrapped_fields945 = fields944 write(pp, "(define") indent_sexp!(pp) newline(pp) - pretty_fragment(pp, unwrapped_fields940) + pretty_fragment(pp, unwrapped_fields945) dedent!(pp) write(pp, ")") end @@ -1207,29 +1211,29 @@ function pretty_define(pp::PrettyPrinter, msg::Proto.Define) end function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) - flat948 = try_flat(pp, msg, pretty_fragment) - if !isnothing(flat948) - write(pp, flat948) + flat953 = try_flat(pp, msg, pretty_fragment) + if !isnothing(flat953) + write(pp, flat953) return nothing else _dollar_dollar = msg start_pretty_fragment(pp, _dollar_dollar) - fields942 = (_dollar_dollar.id, _dollar_dollar.declarations,) - unwrapped_fields943 = fields942 + fields947 = (_dollar_dollar.id, _dollar_dollar.declarations,) + unwrapped_fields948 = fields947 write(pp, "(fragment") indent_sexp!(pp) newline(pp) - field944 = unwrapped_fields943[1] - pretty_new_fragment_id(pp, field944) - field945 = unwrapped_fields943[2] - if !isempty(field945) + field949 = unwrapped_fields948[1] + pretty_new_fragment_id(pp, field949) + field950 = unwrapped_fields948[2] + if !isempty(field950) newline(pp) - for (i1711, elem946) in enumerate(field945) - i947 = i1711 - 1 - if (i947 > 0) + for (i1721, elem951) in enumerate(field950) + i952 = i1721 - 1 + if (i952 > 0) newline(pp) end - pretty_declaration(pp, elem946) + pretty_declaration(pp, elem951) end end dedent!(pp) @@ -1239,66 +1243,66 @@ function pretty_fragment(pp::PrettyPrinter, msg::Proto.Fragment) end function pretty_new_fragment_id(pp::PrettyPrinter, msg::Proto.FragmentId) - flat950 = try_flat(pp, msg, pretty_new_fragment_id) - if !isnothing(flat950) - write(pp, flat950) + flat955 = try_flat(pp, msg, pretty_new_fragment_id) + if !isnothing(flat955) + write(pp, flat955) return nothing else - fields949 = msg - pretty_fragment_id(pp, fields949) + fields954 = msg + pretty_fragment_id(pp, fields954) end return nothing end function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) - flat959 = try_flat(pp, msg, pretty_declaration) - if !isnothing(flat959) - write(pp, flat959) + flat964 = try_flat(pp, msg, pretty_declaration) + if !isnothing(flat964) + write(pp, flat964) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("def")) - _t1712 = _get_oneof_field(_dollar_dollar, :def) + _t1722 = _get_oneof_field(_dollar_dollar, :def) else - _t1712 = nothing + _t1722 = nothing end - deconstruct_result957 = _t1712 - if !isnothing(deconstruct_result957) - unwrapped958 = deconstruct_result957 - pretty_def(pp, unwrapped958) + deconstruct_result962 = _t1722 + if !isnothing(deconstruct_result962) + unwrapped963 = deconstruct_result962 + pretty_def(pp, unwrapped963) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("algorithm")) - _t1713 = _get_oneof_field(_dollar_dollar, :algorithm) + _t1723 = _get_oneof_field(_dollar_dollar, :algorithm) else - _t1713 = nothing + _t1723 = nothing end - deconstruct_result955 = _t1713 - if !isnothing(deconstruct_result955) - unwrapped956 = deconstruct_result955 - pretty_algorithm(pp, unwrapped956) + deconstruct_result960 = _t1723 + if !isnothing(deconstruct_result960) + unwrapped961 = deconstruct_result960 + pretty_algorithm(pp, unwrapped961) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constraint")) - _t1714 = _get_oneof_field(_dollar_dollar, :constraint) + _t1724 = _get_oneof_field(_dollar_dollar, :constraint) else - _t1714 = nothing + _t1724 = nothing end - deconstruct_result953 = _t1714 - if !isnothing(deconstruct_result953) - unwrapped954 = deconstruct_result953 - pretty_constraint(pp, unwrapped954) + deconstruct_result958 = _t1724 + if !isnothing(deconstruct_result958) + unwrapped959 = deconstruct_result958 + pretty_constraint(pp, unwrapped959) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("data")) - _t1715 = _get_oneof_field(_dollar_dollar, :data) + _t1725 = _get_oneof_field(_dollar_dollar, :data) else - _t1715 = nothing + _t1725 = nothing end - deconstruct_result951 = _t1715 - if !isnothing(deconstruct_result951) - unwrapped952 = deconstruct_result951 - pretty_data(pp, unwrapped952) + deconstruct_result956 = _t1725 + if !isnothing(deconstruct_result956) + unwrapped957 = deconstruct_result956 + pretty_data(pp, unwrapped957) else throw(ParseError("No matching rule for declaration")) end @@ -1310,32 +1314,32 @@ function pretty_declaration(pp::PrettyPrinter, msg::Proto.Declaration) end function pretty_def(pp::PrettyPrinter, msg::Proto.Def) - flat966 = try_flat(pp, msg, pretty_def) - if !isnothing(flat966) - write(pp, flat966) + flat971 = try_flat(pp, msg, pretty_def) + if !isnothing(flat971) + write(pp, flat971) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1716 = _dollar_dollar.attrs + _t1726 = _dollar_dollar.attrs else - _t1716 = nothing + _t1726 = nothing end - fields960 = (_dollar_dollar.name, _dollar_dollar.body, _t1716,) - unwrapped_fields961 = fields960 + fields965 = (_dollar_dollar.name, _dollar_dollar.body, _t1726,) + unwrapped_fields966 = fields965 write(pp, "(def") indent_sexp!(pp) newline(pp) - field962 = unwrapped_fields961[1] - pretty_relation_id(pp, field962) + field967 = unwrapped_fields966[1] + pretty_relation_id(pp, field967) newline(pp) - field963 = unwrapped_fields961[2] - pretty_abstraction(pp, field963) - field964 = unwrapped_fields961[3] - if !isnothing(field964) + field968 = unwrapped_fields966[2] + pretty_abstraction(pp, field968) + field969 = unwrapped_fields966[3] + if !isnothing(field969) newline(pp) - opt_val965 = field964 - pretty_attrs(pp, opt_val965) + opt_val970 = field969 + pretty_attrs(pp, opt_val970) end dedent!(pp) write(pp, ")") @@ -1344,30 +1348,30 @@ function pretty_def(pp::PrettyPrinter, msg::Proto.Def) end function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) - flat971 = try_flat(pp, msg, pretty_relation_id) - if !isnothing(flat971) - write(pp, flat971) + flat976 = try_flat(pp, msg, pretty_relation_id) + if !isnothing(flat976) + write(pp, flat976) return nothing else _dollar_dollar = msg if !isnothing(relation_id_to_string(pp, _dollar_dollar)) - _t1718 = deconstruct_relation_id_string(pp, _dollar_dollar) - _t1717 = _t1718 + _t1728 = deconstruct_relation_id_string(pp, _dollar_dollar) + _t1727 = _t1728 else - _t1717 = nothing + _t1727 = nothing end - deconstruct_result969 = _t1717 - if !isnothing(deconstruct_result969) - unwrapped970 = deconstruct_result969 + deconstruct_result974 = _t1727 + if !isnothing(deconstruct_result974) + unwrapped975 = deconstruct_result974 write(pp, ":") - write(pp, unwrapped970) + write(pp, unwrapped975) else _dollar_dollar = msg - _t1719 = deconstruct_relation_id_uint128(pp, _dollar_dollar) - deconstruct_result967 = _t1719 - if !isnothing(deconstruct_result967) - unwrapped968 = deconstruct_result967 - write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped968)) + _t1729 = deconstruct_relation_id_uint128(pp, _dollar_dollar) + deconstruct_result972 = _t1729 + if !isnothing(deconstruct_result972) + unwrapped973 = deconstruct_result972 + write(pp, format_uint128(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped973)) else throw(ParseError("No matching rule for relation_id")) end @@ -1377,22 +1381,22 @@ function pretty_relation_id(pp::PrettyPrinter, msg::Proto.RelationId) end function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) - flat976 = try_flat(pp, msg, pretty_abstraction) - if !isnothing(flat976) - write(pp, flat976) + flat981 = try_flat(pp, msg, pretty_abstraction) + if !isnothing(flat981) + write(pp, flat981) return nothing else _dollar_dollar = msg - _t1720 = deconstruct_bindings(pp, _dollar_dollar) - fields972 = (_t1720, _dollar_dollar.value,) - unwrapped_fields973 = fields972 + _t1730 = deconstruct_bindings(pp, _dollar_dollar) + fields977 = (_t1730, _dollar_dollar.value,) + unwrapped_fields978 = fields977 write(pp, "(") indent!(pp) - field974 = unwrapped_fields973[1] - pretty_bindings(pp, field974) + field979 = unwrapped_fields978[1] + pretty_bindings(pp, field979) newline(pp) - field975 = unwrapped_fields973[2] - pretty_formula(pp, field975) + field980 = unwrapped_fields978[2] + pretty_formula(pp, field980) dedent!(pp) write(pp, ")") end @@ -1400,34 +1404,34 @@ function pretty_abstraction(pp::PrettyPrinter, msg::Proto.Abstraction) end function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Vector{Proto.Binding}}) - flat984 = try_flat(pp, msg, pretty_bindings) - if !isnothing(flat984) - write(pp, flat984) + flat989 = try_flat(pp, msg, pretty_bindings) + if !isnothing(flat989) + write(pp, flat989) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar[2]) - _t1721 = _dollar_dollar[2] + _t1731 = _dollar_dollar[2] else - _t1721 = nothing + _t1731 = nothing end - fields977 = (_dollar_dollar[1], _t1721,) - unwrapped_fields978 = fields977 + fields982 = (_dollar_dollar[1], _t1731,) + unwrapped_fields983 = fields982 write(pp, "[") indent!(pp) - field979 = unwrapped_fields978[1] - for (i1722, elem980) in enumerate(field979) - i981 = i1722 - 1 - if (i981 > 0) + field984 = unwrapped_fields983[1] + for (i1732, elem985) in enumerate(field984) + i986 = i1732 - 1 + if (i986 > 0) newline(pp) end - pretty_binding(pp, elem980) + pretty_binding(pp, elem985) end - field982 = unwrapped_fields978[2] - if !isnothing(field982) + field987 = unwrapped_fields983[2] + if !isnothing(field987) newline(pp) - opt_val983 = field982 - pretty_value_bindings(pp, opt_val983) + opt_val988 = field987 + pretty_value_bindings(pp, opt_val988) end dedent!(pp) write(pp, "]") @@ -1436,182 +1440,182 @@ function pretty_bindings(pp::PrettyPrinter, msg::Tuple{Vector{Proto.Binding}, Ve end function pretty_binding(pp::PrettyPrinter, msg::Proto.Binding) - flat989 = try_flat(pp, msg, pretty_binding) - if !isnothing(flat989) - write(pp, flat989) + flat994 = try_flat(pp, msg, pretty_binding) + if !isnothing(flat994) + write(pp, flat994) return nothing else _dollar_dollar = msg - fields985 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) - unwrapped_fields986 = fields985 - field987 = unwrapped_fields986[1] - write(pp, field987) + fields990 = (_dollar_dollar.var.name, _dollar_dollar.var"#type",) + unwrapped_fields991 = fields990 + field992 = unwrapped_fields991[1] + write(pp, field992) write(pp, "::") - field988 = unwrapped_fields986[2] - pretty_type(pp, field988) + field993 = unwrapped_fields991[2] + pretty_type(pp, field993) end return nothing end function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") - flat1018 = try_flat(pp, msg, pretty_type) - if !isnothing(flat1018) - write(pp, flat1018) + flat1023 = try_flat(pp, msg, pretty_type) + if !isnothing(flat1023) + write(pp, flat1023) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("unspecified_type")) - _t1723 = _get_oneof_field(_dollar_dollar, :unspecified_type) + _t1733 = _get_oneof_field(_dollar_dollar, :unspecified_type) else - _t1723 = nothing + _t1733 = nothing end - deconstruct_result1016 = _t1723 - if !isnothing(deconstruct_result1016) - unwrapped1017 = deconstruct_result1016 - pretty_unspecified_type(pp, unwrapped1017) + deconstruct_result1021 = _t1733 + if !isnothing(deconstruct_result1021) + unwrapped1022 = deconstruct_result1021 + pretty_unspecified_type(pp, unwrapped1022) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_type")) - _t1724 = _get_oneof_field(_dollar_dollar, :string_type) + _t1734 = _get_oneof_field(_dollar_dollar, :string_type) else - _t1724 = nothing + _t1734 = nothing end - deconstruct_result1014 = _t1724 - if !isnothing(deconstruct_result1014) - unwrapped1015 = deconstruct_result1014 - pretty_string_type(pp, unwrapped1015) + deconstruct_result1019 = _t1734 + if !isnothing(deconstruct_result1019) + unwrapped1020 = deconstruct_result1019 + pretty_string_type(pp, unwrapped1020) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_type")) - _t1725 = _get_oneof_field(_dollar_dollar, :int_type) + _t1735 = _get_oneof_field(_dollar_dollar, :int_type) else - _t1725 = nothing + _t1735 = nothing end - deconstruct_result1012 = _t1725 - if !isnothing(deconstruct_result1012) - unwrapped1013 = deconstruct_result1012 - pretty_int_type(pp, unwrapped1013) + deconstruct_result1017 = _t1735 + if !isnothing(deconstruct_result1017) + unwrapped1018 = deconstruct_result1017 + pretty_int_type(pp, unwrapped1018) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_type")) - _t1726 = _get_oneof_field(_dollar_dollar, :float_type) + _t1736 = _get_oneof_field(_dollar_dollar, :float_type) else - _t1726 = nothing + _t1736 = nothing end - deconstruct_result1010 = _t1726 - if !isnothing(deconstruct_result1010) - unwrapped1011 = deconstruct_result1010 - pretty_float_type(pp, unwrapped1011) + deconstruct_result1015 = _t1736 + if !isnothing(deconstruct_result1015) + unwrapped1016 = deconstruct_result1015 + pretty_float_type(pp, unwrapped1016) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_type")) - _t1727 = _get_oneof_field(_dollar_dollar, :uint128_type) + _t1737 = _get_oneof_field(_dollar_dollar, :uint128_type) else - _t1727 = nothing + _t1737 = nothing end - deconstruct_result1008 = _t1727 - if !isnothing(deconstruct_result1008) - unwrapped1009 = deconstruct_result1008 - pretty_uint128_type(pp, unwrapped1009) + deconstruct_result1013 = _t1737 + if !isnothing(deconstruct_result1013) + unwrapped1014 = deconstruct_result1013 + pretty_uint128_type(pp, unwrapped1014) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_type")) - _t1728 = _get_oneof_field(_dollar_dollar, :int128_type) + _t1738 = _get_oneof_field(_dollar_dollar, :int128_type) else - _t1728 = nothing + _t1738 = nothing end - deconstruct_result1006 = _t1728 - if !isnothing(deconstruct_result1006) - unwrapped1007 = deconstruct_result1006 - pretty_int128_type(pp, unwrapped1007) + deconstruct_result1011 = _t1738 + if !isnothing(deconstruct_result1011) + unwrapped1012 = deconstruct_result1011 + pretty_int128_type(pp, unwrapped1012) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_type")) - _t1729 = _get_oneof_field(_dollar_dollar, :date_type) + _t1739 = _get_oneof_field(_dollar_dollar, :date_type) else - _t1729 = nothing + _t1739 = nothing end - deconstruct_result1004 = _t1729 - if !isnothing(deconstruct_result1004) - unwrapped1005 = deconstruct_result1004 - pretty_date_type(pp, unwrapped1005) + deconstruct_result1009 = _t1739 + if !isnothing(deconstruct_result1009) + unwrapped1010 = deconstruct_result1009 + pretty_date_type(pp, unwrapped1010) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_type")) - _t1730 = _get_oneof_field(_dollar_dollar, :datetime_type) + _t1740 = _get_oneof_field(_dollar_dollar, :datetime_type) else - _t1730 = nothing + _t1740 = nothing end - deconstruct_result1002 = _t1730 - if !isnothing(deconstruct_result1002) - unwrapped1003 = deconstruct_result1002 - pretty_datetime_type(pp, unwrapped1003) + deconstruct_result1007 = _t1740 + if !isnothing(deconstruct_result1007) + unwrapped1008 = deconstruct_result1007 + pretty_datetime_type(pp, unwrapped1008) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("missing_type")) - _t1731 = _get_oneof_field(_dollar_dollar, :missing_type) + _t1741 = _get_oneof_field(_dollar_dollar, :missing_type) else - _t1731 = nothing + _t1741 = nothing end - deconstruct_result1000 = _t1731 - if !isnothing(deconstruct_result1000) - unwrapped1001 = deconstruct_result1000 - pretty_missing_type(pp, unwrapped1001) + deconstruct_result1005 = _t1741 + if !isnothing(deconstruct_result1005) + unwrapped1006 = deconstruct_result1005 + pretty_missing_type(pp, unwrapped1006) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_type")) - _t1732 = _get_oneof_field(_dollar_dollar, :decimal_type) + _t1742 = _get_oneof_field(_dollar_dollar, :decimal_type) else - _t1732 = nothing + _t1742 = nothing end - deconstruct_result998 = _t1732 - if !isnothing(deconstruct_result998) - unwrapped999 = deconstruct_result998 - pretty_decimal_type(pp, unwrapped999) + deconstruct_result1003 = _t1742 + if !isnothing(deconstruct_result1003) + unwrapped1004 = deconstruct_result1003 + pretty_decimal_type(pp, unwrapped1004) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_type")) - _t1733 = _get_oneof_field(_dollar_dollar, :boolean_type) + _t1743 = _get_oneof_field(_dollar_dollar, :boolean_type) else - _t1733 = nothing + _t1743 = nothing end - deconstruct_result996 = _t1733 - if !isnothing(deconstruct_result996) - unwrapped997 = deconstruct_result996 - pretty_boolean_type(pp, unwrapped997) + deconstruct_result1001 = _t1743 + if !isnothing(deconstruct_result1001) + unwrapped1002 = deconstruct_result1001 + pretty_boolean_type(pp, unwrapped1002) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_type")) - _t1734 = _get_oneof_field(_dollar_dollar, :int32_type) + _t1744 = _get_oneof_field(_dollar_dollar, :int32_type) else - _t1734 = nothing + _t1744 = nothing end - deconstruct_result994 = _t1734 - if !isnothing(deconstruct_result994) - unwrapped995 = deconstruct_result994 - pretty_int32_type(pp, unwrapped995) + deconstruct_result999 = _t1744 + if !isnothing(deconstruct_result999) + unwrapped1000 = deconstruct_result999 + pretty_int32_type(pp, unwrapped1000) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_type")) - _t1735 = _get_oneof_field(_dollar_dollar, :float32_type) + _t1745 = _get_oneof_field(_dollar_dollar, :float32_type) else - _t1735 = nothing + _t1745 = nothing end - deconstruct_result992 = _t1735 - if !isnothing(deconstruct_result992) - unwrapped993 = deconstruct_result992 - pretty_float32_type(pp, unwrapped993) + deconstruct_result997 = _t1745 + if !isnothing(deconstruct_result997) + unwrapped998 = deconstruct_result997 + pretty_float32_type(pp, unwrapped998) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_type")) - _t1736 = _get_oneof_field(_dollar_dollar, :uint32_type) + _t1746 = _get_oneof_field(_dollar_dollar, :uint32_type) else - _t1736 = nothing + _t1746 = nothing end - deconstruct_result990 = _t1736 - if !isnothing(deconstruct_result990) - unwrapped991 = deconstruct_result990 - pretty_uint32_type(pp, unwrapped991) + deconstruct_result995 = _t1746 + if !isnothing(deconstruct_result995) + unwrapped996 = deconstruct_result995 + pretty_uint32_type(pp, unwrapped996) else throw(ParseError("No matching rule for type")) end @@ -1633,76 +1637,76 @@ function pretty_type(pp::PrettyPrinter, msg::Proto.var"#Type") end function pretty_unspecified_type(pp::PrettyPrinter, msg::Proto.UnspecifiedType) - fields1019 = msg + fields1024 = msg write(pp, "UNKNOWN") return nothing end function pretty_string_type(pp::PrettyPrinter, msg::Proto.StringType) - fields1020 = msg + fields1025 = msg write(pp, "STRING") return nothing end function pretty_int_type(pp::PrettyPrinter, msg::Proto.IntType) - fields1021 = msg + fields1026 = msg write(pp, "INT") return nothing end function pretty_float_type(pp::PrettyPrinter, msg::Proto.FloatType) - fields1022 = msg + fields1027 = msg write(pp, "FLOAT") return nothing end function pretty_uint128_type(pp::PrettyPrinter, msg::Proto.UInt128Type) - fields1023 = msg + fields1028 = msg write(pp, "UINT128") return nothing end function pretty_int128_type(pp::PrettyPrinter, msg::Proto.Int128Type) - fields1024 = msg + fields1029 = msg write(pp, "INT128") return nothing end function pretty_date_type(pp::PrettyPrinter, msg::Proto.DateType) - fields1025 = msg + fields1030 = msg write(pp, "DATE") return nothing end function pretty_datetime_type(pp::PrettyPrinter, msg::Proto.DateTimeType) - fields1026 = msg + fields1031 = msg write(pp, "DATETIME") return nothing end function pretty_missing_type(pp::PrettyPrinter, msg::Proto.MissingType) - fields1027 = msg + fields1032 = msg write(pp, "MISSING") return nothing end function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) - flat1032 = try_flat(pp, msg, pretty_decimal_type) - if !isnothing(flat1032) - write(pp, flat1032) + flat1037 = try_flat(pp, msg, pretty_decimal_type) + if !isnothing(flat1037) + write(pp, flat1037) return nothing else _dollar_dollar = msg - fields1028 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) - unwrapped_fields1029 = fields1028 + fields1033 = (Int64(_dollar_dollar.precision), Int64(_dollar_dollar.scale),) + unwrapped_fields1034 = fields1033 write(pp, "(DECIMAL") indent_sexp!(pp) newline(pp) - field1030 = unwrapped_fields1029[1] - write(pp, string(field1030)) + field1035 = unwrapped_fields1034[1] + write(pp, string(field1035)) newline(pp) - field1031 = unwrapped_fields1029[2] - write(pp, string(field1031)) + field1036 = unwrapped_fields1034[2] + write(pp, string(field1036)) dedent!(pp) write(pp, ")") end @@ -1710,45 +1714,45 @@ function pretty_decimal_type(pp::PrettyPrinter, msg::Proto.DecimalType) end function pretty_boolean_type(pp::PrettyPrinter, msg::Proto.BooleanType) - fields1033 = msg + fields1038 = msg write(pp, "BOOLEAN") return nothing end function pretty_int32_type(pp::PrettyPrinter, msg::Proto.Int32Type) - fields1034 = msg + fields1039 = msg write(pp, "INT32") return nothing end function pretty_float32_type(pp::PrettyPrinter, msg::Proto.Float32Type) - fields1035 = msg + fields1040 = msg write(pp, "FLOAT32") return nothing end function pretty_uint32_type(pp::PrettyPrinter, msg::Proto.UInt32Type) - fields1036 = msg + fields1041 = msg write(pp, "UINT32") return nothing end function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) - flat1040 = try_flat(pp, msg, pretty_value_bindings) - if !isnothing(flat1040) - write(pp, flat1040) + flat1045 = try_flat(pp, msg, pretty_value_bindings) + if !isnothing(flat1045) + write(pp, flat1045) return nothing else - fields1037 = msg + fields1042 = msg write(pp, "|") - if !isempty(fields1037) + if !isempty(fields1042) write(pp, " ") - for (i1737, elem1038) in enumerate(fields1037) - i1039 = i1737 - 1 - if (i1039 > 0) + for (i1747, elem1043) in enumerate(fields1042) + i1044 = i1747 - 1 + if (i1044 > 0) newline(pp) end - pretty_binding(pp, elem1038) + pretty_binding(pp, elem1043) end end end @@ -1756,153 +1760,153 @@ function pretty_value_bindings(pp::PrettyPrinter, msg::Vector{Proto.Binding}) end function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) - flat1067 = try_flat(pp, msg, pretty_formula) - if !isnothing(flat1067) - write(pp, flat1067) + flat1072 = try_flat(pp, msg, pretty_formula) + if !isnothing(flat1072) + write(pp, flat1072) return nothing else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1738 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1748 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1738 = nothing + _t1748 = nothing end - deconstruct_result1065 = _t1738 - if !isnothing(deconstruct_result1065) - unwrapped1066 = deconstruct_result1065 - pretty_true(pp, unwrapped1066) + deconstruct_result1070 = _t1748 + if !isnothing(deconstruct_result1070) + unwrapped1071 = deconstruct_result1070 + pretty_true(pp, unwrapped1071) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1739 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1749 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1739 = nothing + _t1749 = nothing end - deconstruct_result1063 = _t1739 - if !isnothing(deconstruct_result1063) - unwrapped1064 = deconstruct_result1063 - pretty_false(pp, unwrapped1064) + deconstruct_result1068 = _t1749 + if !isnothing(deconstruct_result1068) + unwrapped1069 = deconstruct_result1068 + pretty_false(pp, unwrapped1069) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("exists")) - _t1740 = _get_oneof_field(_dollar_dollar, :exists) + _t1750 = _get_oneof_field(_dollar_dollar, :exists) else - _t1740 = nothing + _t1750 = nothing end - deconstruct_result1061 = _t1740 - if !isnothing(deconstruct_result1061) - unwrapped1062 = deconstruct_result1061 - pretty_exists(pp, unwrapped1062) + deconstruct_result1066 = _t1750 + if !isnothing(deconstruct_result1066) + unwrapped1067 = deconstruct_result1066 + pretty_exists(pp, unwrapped1067) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("reduce")) - _t1741 = _get_oneof_field(_dollar_dollar, :reduce) + _t1751 = _get_oneof_field(_dollar_dollar, :reduce) else - _t1741 = nothing + _t1751 = nothing end - deconstruct_result1059 = _t1741 - if !isnothing(deconstruct_result1059) - unwrapped1060 = deconstruct_result1059 - pretty_reduce(pp, unwrapped1060) + deconstruct_result1064 = _t1751 + if !isnothing(deconstruct_result1064) + unwrapped1065 = deconstruct_result1064 + pretty_reduce(pp, unwrapped1065) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("conjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :conjunction).args)) - _t1742 = _get_oneof_field(_dollar_dollar, :conjunction) + _t1752 = _get_oneof_field(_dollar_dollar, :conjunction) else - _t1742 = nothing + _t1752 = nothing end - deconstruct_result1057 = _t1742 - if !isnothing(deconstruct_result1057) - unwrapped1058 = deconstruct_result1057 - pretty_conjunction(pp, unwrapped1058) + deconstruct_result1062 = _t1752 + if !isnothing(deconstruct_result1062) + unwrapped1063 = deconstruct_result1062 + pretty_conjunction(pp, unwrapped1063) else _dollar_dollar = msg if (_has_proto_field(_dollar_dollar, Symbol("disjunction")) && !isempty(_get_oneof_field(_dollar_dollar, :disjunction).args)) - _t1743 = _get_oneof_field(_dollar_dollar, :disjunction) + _t1753 = _get_oneof_field(_dollar_dollar, :disjunction) else - _t1743 = nothing + _t1753 = nothing end - deconstruct_result1055 = _t1743 - if !isnothing(deconstruct_result1055) - unwrapped1056 = deconstruct_result1055 - pretty_disjunction(pp, unwrapped1056) + deconstruct_result1060 = _t1753 + if !isnothing(deconstruct_result1060) + unwrapped1061 = deconstruct_result1060 + pretty_disjunction(pp, unwrapped1061) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("not")) - _t1744 = _get_oneof_field(_dollar_dollar, :not) + _t1754 = _get_oneof_field(_dollar_dollar, :not) else - _t1744 = nothing + _t1754 = nothing end - deconstruct_result1053 = _t1744 - if !isnothing(deconstruct_result1053) - unwrapped1054 = deconstruct_result1053 - pretty_not(pp, unwrapped1054) + deconstruct_result1058 = _t1754 + if !isnothing(deconstruct_result1058) + unwrapped1059 = deconstruct_result1058 + pretty_not(pp, unwrapped1059) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("ffi")) - _t1745 = _get_oneof_field(_dollar_dollar, :ffi) + _t1755 = _get_oneof_field(_dollar_dollar, :ffi) else - _t1745 = nothing + _t1755 = nothing end - deconstruct_result1051 = _t1745 - if !isnothing(deconstruct_result1051) - unwrapped1052 = deconstruct_result1051 - pretty_ffi(pp, unwrapped1052) + deconstruct_result1056 = _t1755 + if !isnothing(deconstruct_result1056) + unwrapped1057 = deconstruct_result1056 + pretty_ffi(pp, unwrapped1057) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("atom")) - _t1746 = _get_oneof_field(_dollar_dollar, :atom) + _t1756 = _get_oneof_field(_dollar_dollar, :atom) else - _t1746 = nothing + _t1756 = nothing end - deconstruct_result1049 = _t1746 - if !isnothing(deconstruct_result1049) - unwrapped1050 = deconstruct_result1049 - pretty_atom(pp, unwrapped1050) + deconstruct_result1054 = _t1756 + if !isnothing(deconstruct_result1054) + unwrapped1055 = deconstruct_result1054 + pretty_atom(pp, unwrapped1055) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("pragma")) - _t1747 = _get_oneof_field(_dollar_dollar, :pragma) + _t1757 = _get_oneof_field(_dollar_dollar, :pragma) else - _t1747 = nothing + _t1757 = nothing end - deconstruct_result1047 = _t1747 - if !isnothing(deconstruct_result1047) - unwrapped1048 = deconstruct_result1047 - pretty_pragma(pp, unwrapped1048) + deconstruct_result1052 = _t1757 + if !isnothing(deconstruct_result1052) + unwrapped1053 = deconstruct_result1052 + pretty_pragma(pp, unwrapped1053) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("primitive")) - _t1748 = _get_oneof_field(_dollar_dollar, :primitive) + _t1758 = _get_oneof_field(_dollar_dollar, :primitive) else - _t1748 = nothing + _t1758 = nothing end - deconstruct_result1045 = _t1748 - if !isnothing(deconstruct_result1045) - unwrapped1046 = deconstruct_result1045 - pretty_primitive(pp, unwrapped1046) + deconstruct_result1050 = _t1758 + if !isnothing(deconstruct_result1050) + unwrapped1051 = deconstruct_result1050 + pretty_primitive(pp, unwrapped1051) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("rel_atom")) - _t1749 = _get_oneof_field(_dollar_dollar, :rel_atom) + _t1759 = _get_oneof_field(_dollar_dollar, :rel_atom) else - _t1749 = nothing + _t1759 = nothing end - deconstruct_result1043 = _t1749 - if !isnothing(deconstruct_result1043) - unwrapped1044 = deconstruct_result1043 - pretty_rel_atom(pp, unwrapped1044) + deconstruct_result1048 = _t1759 + if !isnothing(deconstruct_result1048) + unwrapped1049 = deconstruct_result1048 + pretty_rel_atom(pp, unwrapped1049) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cast")) - _t1750 = _get_oneof_field(_dollar_dollar, :cast) + _t1760 = _get_oneof_field(_dollar_dollar, :cast) else - _t1750 = nothing + _t1760 = nothing end - deconstruct_result1041 = _t1750 - if !isnothing(deconstruct_result1041) - unwrapped1042 = deconstruct_result1041 - pretty_cast(pp, unwrapped1042) + deconstruct_result1046 = _t1760 + if !isnothing(deconstruct_result1046) + unwrapped1047 = deconstruct_result1046 + pretty_cast(pp, unwrapped1047) else throw(ParseError("No matching rule for formula")) end @@ -1923,35 +1927,35 @@ function pretty_formula(pp::PrettyPrinter, msg::Proto.Formula) end function pretty_true(pp::PrettyPrinter, msg::Proto.Conjunction) - fields1068 = msg + fields1073 = msg write(pp, "(true)") return nothing end function pretty_false(pp::PrettyPrinter, msg::Proto.Disjunction) - fields1069 = msg + fields1074 = msg write(pp, "(false)") return nothing end function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) - flat1074 = try_flat(pp, msg, pretty_exists) - if !isnothing(flat1074) - write(pp, flat1074) + flat1079 = try_flat(pp, msg, pretty_exists) + if !isnothing(flat1079) + write(pp, flat1079) return nothing else _dollar_dollar = msg - _t1751 = deconstruct_bindings(pp, _dollar_dollar.body) - fields1070 = (_t1751, _dollar_dollar.body.value,) - unwrapped_fields1071 = fields1070 + _t1761 = deconstruct_bindings(pp, _dollar_dollar.body) + fields1075 = (_t1761, _dollar_dollar.body.value,) + unwrapped_fields1076 = fields1075 write(pp, "(exists") indent_sexp!(pp) newline(pp) - field1072 = unwrapped_fields1071[1] - pretty_bindings(pp, field1072) + field1077 = unwrapped_fields1076[1] + pretty_bindings(pp, field1077) newline(pp) - field1073 = unwrapped_fields1071[2] - pretty_formula(pp, field1073) + field1078 = unwrapped_fields1076[2] + pretty_formula(pp, field1078) dedent!(pp) write(pp, ")") end @@ -1959,25 +1963,25 @@ function pretty_exists(pp::PrettyPrinter, msg::Proto.Exists) end function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) - flat1080 = try_flat(pp, msg, pretty_reduce) - if !isnothing(flat1080) - write(pp, flat1080) + flat1085 = try_flat(pp, msg, pretty_reduce) + if !isnothing(flat1085) + write(pp, flat1085) return nothing else _dollar_dollar = msg - fields1075 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - unwrapped_fields1076 = fields1075 + fields1080 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) + unwrapped_fields1081 = fields1080 write(pp, "(reduce") indent_sexp!(pp) newline(pp) - field1077 = unwrapped_fields1076[1] - pretty_abstraction(pp, field1077) + field1082 = unwrapped_fields1081[1] + pretty_abstraction(pp, field1082) newline(pp) - field1078 = unwrapped_fields1076[2] - pretty_abstraction(pp, field1078) + field1083 = unwrapped_fields1081[2] + pretty_abstraction(pp, field1083) newline(pp) - field1079 = unwrapped_fields1076[3] - pretty_terms(pp, field1079) + field1084 = unwrapped_fields1081[3] + pretty_terms(pp, field1084) dedent!(pp) write(pp, ")") end @@ -1985,22 +1989,22 @@ function pretty_reduce(pp::PrettyPrinter, msg::Proto.Reduce) end function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) - flat1084 = try_flat(pp, msg, pretty_terms) - if !isnothing(flat1084) - write(pp, flat1084) + flat1089 = try_flat(pp, msg, pretty_terms) + if !isnothing(flat1089) + write(pp, flat1089) return nothing else - fields1081 = msg + fields1086 = msg write(pp, "(terms") indent_sexp!(pp) - if !isempty(fields1081) + if !isempty(fields1086) newline(pp) - for (i1752, elem1082) in enumerate(fields1081) - i1083 = i1752 - 1 - if (i1083 > 0) + for (i1762, elem1087) in enumerate(fields1086) + i1088 = i1762 - 1 + if (i1088 > 0) newline(pp) end - pretty_term(pp, elem1082) + pretty_term(pp, elem1087) end end dedent!(pp) @@ -2010,32 +2014,32 @@ function pretty_terms(pp::PrettyPrinter, msg::Vector{Proto.Term}) end function pretty_term(pp::PrettyPrinter, msg::Proto.Term) - flat1089 = try_flat(pp, msg, pretty_term) - if !isnothing(flat1089) - write(pp, flat1089) + flat1094 = try_flat(pp, msg, pretty_term) + if !isnothing(flat1094) + write(pp, flat1094) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("var")) - _t1753 = _get_oneof_field(_dollar_dollar, :var) + _t1763 = _get_oneof_field(_dollar_dollar, :var) else - _t1753 = nothing + _t1763 = nothing end - deconstruct_result1087 = _t1753 - if !isnothing(deconstruct_result1087) - unwrapped1088 = deconstruct_result1087 - pretty_var(pp, unwrapped1088) + deconstruct_result1092 = _t1763 + if !isnothing(deconstruct_result1092) + unwrapped1093 = deconstruct_result1092 + pretty_var(pp, unwrapped1093) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("constant")) - _t1754 = _get_oneof_field(_dollar_dollar, :constant) + _t1764 = _get_oneof_field(_dollar_dollar, :constant) else - _t1754 = nothing + _t1764 = nothing end - deconstruct_result1085 = _t1754 - if !isnothing(deconstruct_result1085) - unwrapped1086 = deconstruct_result1085 - pretty_value(pp, unwrapped1086) + deconstruct_result1090 = _t1764 + if !isnothing(deconstruct_result1090) + unwrapped1091 = deconstruct_result1090 + pretty_value(pp, unwrapped1091) else throw(ParseError("No matching rule for term")) end @@ -2045,158 +2049,158 @@ function pretty_term(pp::PrettyPrinter, msg::Proto.Term) end function pretty_var(pp::PrettyPrinter, msg::Proto.Var) - flat1092 = try_flat(pp, msg, pretty_var) - if !isnothing(flat1092) - write(pp, flat1092) + flat1097 = try_flat(pp, msg, pretty_var) + if !isnothing(flat1097) + write(pp, flat1097) return nothing else _dollar_dollar = msg - fields1090 = _dollar_dollar.name - unwrapped_fields1091 = fields1090 - write(pp, unwrapped_fields1091) + fields1095 = _dollar_dollar.name + unwrapped_fields1096 = fields1095 + write(pp, unwrapped_fields1096) end return nothing end function pretty_value(pp::PrettyPrinter, msg::Proto.Value) - flat1118 = try_flat(pp, msg, pretty_value) - if !isnothing(flat1118) - write(pp, flat1118) + flat1123 = try_flat(pp, msg, pretty_value) + if !isnothing(flat1123) + write(pp, flat1123) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("date_value")) - _t1755 = _get_oneof_field(_dollar_dollar, :date_value) + _t1765 = _get_oneof_field(_dollar_dollar, :date_value) else - _t1755 = nothing + _t1765 = nothing end - deconstruct_result1116 = _t1755 - if !isnothing(deconstruct_result1116) - unwrapped1117 = deconstruct_result1116 - pretty_date(pp, unwrapped1117) + deconstruct_result1121 = _t1765 + if !isnothing(deconstruct_result1121) + unwrapped1122 = deconstruct_result1121 + pretty_date(pp, unwrapped1122) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("datetime_value")) - _t1756 = _get_oneof_field(_dollar_dollar, :datetime_value) + _t1766 = _get_oneof_field(_dollar_dollar, :datetime_value) else - _t1756 = nothing + _t1766 = nothing end - deconstruct_result1114 = _t1756 - if !isnothing(deconstruct_result1114) - unwrapped1115 = deconstruct_result1114 - pretty_datetime(pp, unwrapped1115) + deconstruct_result1119 = _t1766 + if !isnothing(deconstruct_result1119) + unwrapped1120 = deconstruct_result1119 + pretty_datetime(pp, unwrapped1120) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("string_value")) - _t1757 = _get_oneof_field(_dollar_dollar, :string_value) + _t1767 = _get_oneof_field(_dollar_dollar, :string_value) else - _t1757 = nothing + _t1767 = nothing end - deconstruct_result1112 = _t1757 - if !isnothing(deconstruct_result1112) - unwrapped1113 = deconstruct_result1112 - write(pp, format_string(pp, unwrapped1113)) + deconstruct_result1117 = _t1767 + if !isnothing(deconstruct_result1117) + unwrapped1118 = deconstruct_result1117 + write(pp, format_string(pp, unwrapped1118)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int32_value")) - _t1758 = _get_oneof_field(_dollar_dollar, :int32_value) + _t1768 = _get_oneof_field(_dollar_dollar, :int32_value) else - _t1758 = nothing + _t1768 = nothing end - deconstruct_result1110 = _t1758 - if !isnothing(deconstruct_result1110) - unwrapped1111 = deconstruct_result1110 - write(pp, format_int32(pp, unwrapped1111)) + deconstruct_result1115 = _t1768 + if !isnothing(deconstruct_result1115) + unwrapped1116 = deconstruct_result1115 + write(pp, format_int32(pp, unwrapped1116)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int_value")) - _t1759 = _get_oneof_field(_dollar_dollar, :int_value) + _t1769 = _get_oneof_field(_dollar_dollar, :int_value) else - _t1759 = nothing + _t1769 = nothing end - deconstruct_result1108 = _t1759 - if !isnothing(deconstruct_result1108) - unwrapped1109 = deconstruct_result1108 - write(pp, format_int(pp, unwrapped1109)) + deconstruct_result1113 = _t1769 + if !isnothing(deconstruct_result1113) + unwrapped1114 = deconstruct_result1113 + write(pp, format_int(pp, unwrapped1114)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float32_value")) - _t1760 = _get_oneof_field(_dollar_dollar, :float32_value) + _t1770 = _get_oneof_field(_dollar_dollar, :float32_value) else - _t1760 = nothing + _t1770 = nothing end - deconstruct_result1106 = _t1760 - if !isnothing(deconstruct_result1106) - unwrapped1107 = deconstruct_result1106 - write(pp, format_float32(pp, unwrapped1107)) + deconstruct_result1111 = _t1770 + if !isnothing(deconstruct_result1111) + unwrapped1112 = deconstruct_result1111 + write(pp, format_float32(pp, unwrapped1112)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("float_value")) - _t1761 = _get_oneof_field(_dollar_dollar, :float_value) + _t1771 = _get_oneof_field(_dollar_dollar, :float_value) else - _t1761 = nothing + _t1771 = nothing end - deconstruct_result1104 = _t1761 - if !isnothing(deconstruct_result1104) - unwrapped1105 = deconstruct_result1104 - write(pp, format_float(pp, unwrapped1105)) + deconstruct_result1109 = _t1771 + if !isnothing(deconstruct_result1109) + unwrapped1110 = deconstruct_result1109 + write(pp, format_float(pp, unwrapped1110)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint32_value")) - _t1762 = _get_oneof_field(_dollar_dollar, :uint32_value) + _t1772 = _get_oneof_field(_dollar_dollar, :uint32_value) else - _t1762 = nothing + _t1772 = nothing end - deconstruct_result1102 = _t1762 - if !isnothing(deconstruct_result1102) - unwrapped1103 = deconstruct_result1102 - write(pp, format_uint32(pp, unwrapped1103)) + deconstruct_result1107 = _t1772 + if !isnothing(deconstruct_result1107) + unwrapped1108 = deconstruct_result1107 + write(pp, format_uint32(pp, unwrapped1108)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("uint128_value")) - _t1763 = _get_oneof_field(_dollar_dollar, :uint128_value) + _t1773 = _get_oneof_field(_dollar_dollar, :uint128_value) else - _t1763 = nothing + _t1773 = nothing end - deconstruct_result1100 = _t1763 - if !isnothing(deconstruct_result1100) - unwrapped1101 = deconstruct_result1100 - write(pp, format_uint128(pp, unwrapped1101)) + deconstruct_result1105 = _t1773 + if !isnothing(deconstruct_result1105) + unwrapped1106 = deconstruct_result1105 + write(pp, format_uint128(pp, unwrapped1106)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("int128_value")) - _t1764 = _get_oneof_field(_dollar_dollar, :int128_value) + _t1774 = _get_oneof_field(_dollar_dollar, :int128_value) else - _t1764 = nothing + _t1774 = nothing end - deconstruct_result1098 = _t1764 - if !isnothing(deconstruct_result1098) - unwrapped1099 = deconstruct_result1098 - write(pp, format_int128(pp, unwrapped1099)) + deconstruct_result1103 = _t1774 + if !isnothing(deconstruct_result1103) + unwrapped1104 = deconstruct_result1103 + write(pp, format_int128(pp, unwrapped1104)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("decimal_value")) - _t1765 = _get_oneof_field(_dollar_dollar, :decimal_value) + _t1775 = _get_oneof_field(_dollar_dollar, :decimal_value) else - _t1765 = nothing + _t1775 = nothing end - deconstruct_result1096 = _t1765 - if !isnothing(deconstruct_result1096) - unwrapped1097 = deconstruct_result1096 - write(pp, format_decimal(pp, unwrapped1097)) + deconstruct_result1101 = _t1775 + if !isnothing(deconstruct_result1101) + unwrapped1102 = deconstruct_result1101 + write(pp, format_decimal(pp, unwrapped1102)) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("boolean_value")) - _t1766 = _get_oneof_field(_dollar_dollar, :boolean_value) + _t1776 = _get_oneof_field(_dollar_dollar, :boolean_value) else - _t1766 = nothing + _t1776 = nothing end - deconstruct_result1094 = _t1766 - if !isnothing(deconstruct_result1094) - unwrapped1095 = deconstruct_result1094 - pretty_boolean_value(pp, unwrapped1095) + deconstruct_result1099 = _t1776 + if !isnothing(deconstruct_result1099) + unwrapped1100 = deconstruct_result1099 + pretty_boolean_value(pp, unwrapped1100) else - fields1093 = msg + fields1098 = msg write(pp, "missing") end end @@ -2215,25 +2219,25 @@ function pretty_value(pp::PrettyPrinter, msg::Proto.Value) end function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) - flat1124 = try_flat(pp, msg, pretty_date) - if !isnothing(flat1124) - write(pp, flat1124) + flat1129 = try_flat(pp, msg, pretty_date) + if !isnothing(flat1129) + write(pp, flat1129) return nothing else _dollar_dollar = msg - fields1119 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) - unwrapped_fields1120 = fields1119 + fields1124 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day),) + unwrapped_fields1125 = fields1124 write(pp, "(date") indent_sexp!(pp) newline(pp) - field1121 = unwrapped_fields1120[1] - write(pp, format_int(pp, field1121)) + field1126 = unwrapped_fields1125[1] + write(pp, format_int(pp, field1126)) newline(pp) - field1122 = unwrapped_fields1120[2] - write(pp, format_int(pp, field1122)) + field1127 = unwrapped_fields1125[2] + write(pp, format_int(pp, field1127)) newline(pp) - field1123 = unwrapped_fields1120[3] - write(pp, format_int(pp, field1123)) + field1128 = unwrapped_fields1125[3] + write(pp, format_int(pp, field1128)) dedent!(pp) write(pp, ")") end @@ -2241,39 +2245,39 @@ function pretty_date(pp::PrettyPrinter, msg::Proto.DateValue) end function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) - flat1135 = try_flat(pp, msg, pretty_datetime) - if !isnothing(flat1135) - write(pp, flat1135) + flat1140 = try_flat(pp, msg, pretty_datetime) + if !isnothing(flat1140) + write(pp, flat1140) return nothing else _dollar_dollar = msg - fields1125 = (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_fields1126 = fields1125 + fields1130 = (Int64(_dollar_dollar.year), Int64(_dollar_dollar.month), Int64(_dollar_dollar.day), Int64(_dollar_dollar.hour), Int64(_dollar_dollar.minute), Int64(_dollar_dollar.second), Int64(_dollar_dollar.microsecond),) + unwrapped_fields1131 = fields1130 write(pp, "(datetime") indent_sexp!(pp) newline(pp) - field1127 = unwrapped_fields1126[1] - write(pp, format_int(pp, field1127)) + field1132 = unwrapped_fields1131[1] + write(pp, format_int(pp, field1132)) newline(pp) - field1128 = unwrapped_fields1126[2] - write(pp, format_int(pp, field1128)) + field1133 = unwrapped_fields1131[2] + write(pp, format_int(pp, field1133)) newline(pp) - field1129 = unwrapped_fields1126[3] - write(pp, format_int(pp, field1129)) + field1134 = unwrapped_fields1131[3] + write(pp, format_int(pp, field1134)) newline(pp) - field1130 = unwrapped_fields1126[4] - write(pp, format_int(pp, field1130)) + field1135 = unwrapped_fields1131[4] + write(pp, format_int(pp, field1135)) newline(pp) - field1131 = unwrapped_fields1126[5] - write(pp, format_int(pp, field1131)) + field1136 = unwrapped_fields1131[5] + write(pp, format_int(pp, field1136)) newline(pp) - field1132 = unwrapped_fields1126[6] - write(pp, format_int(pp, field1132)) - field1133 = unwrapped_fields1126[7] - if !isnothing(field1133) + field1137 = unwrapped_fields1131[6] + write(pp, format_int(pp, field1137)) + field1138 = unwrapped_fields1131[7] + if !isnothing(field1138) newline(pp) - opt_val1134 = field1133 - write(pp, format_int(pp, opt_val1134)) + opt_val1139 = field1138 + write(pp, format_int(pp, opt_val1139)) end dedent!(pp) write(pp, ")") @@ -2282,24 +2286,24 @@ function pretty_datetime(pp::PrettyPrinter, msg::Proto.DateTimeValue) end function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) - flat1140 = try_flat(pp, msg, pretty_conjunction) - if !isnothing(flat1140) - write(pp, flat1140) + flat1145 = try_flat(pp, msg, pretty_conjunction) + if !isnothing(flat1145) + write(pp, flat1145) return nothing else _dollar_dollar = msg - fields1136 = _dollar_dollar.args - unwrapped_fields1137 = fields1136 + fields1141 = _dollar_dollar.args + unwrapped_fields1142 = fields1141 write(pp, "(and") indent_sexp!(pp) - if !isempty(unwrapped_fields1137) + if !isempty(unwrapped_fields1142) newline(pp) - for (i1767, elem1138) in enumerate(unwrapped_fields1137) - i1139 = i1767 - 1 - if (i1139 > 0) + for (i1777, elem1143) in enumerate(unwrapped_fields1142) + i1144 = i1777 - 1 + if (i1144 > 0) newline(pp) end - pretty_formula(pp, elem1138) + pretty_formula(pp, elem1143) end end dedent!(pp) @@ -2309,24 +2313,24 @@ function pretty_conjunction(pp::PrettyPrinter, msg::Proto.Conjunction) end function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) - flat1145 = try_flat(pp, msg, pretty_disjunction) - if !isnothing(flat1145) - write(pp, flat1145) + flat1150 = try_flat(pp, msg, pretty_disjunction) + if !isnothing(flat1150) + write(pp, flat1150) return nothing else _dollar_dollar = msg - fields1141 = _dollar_dollar.args - unwrapped_fields1142 = fields1141 + fields1146 = _dollar_dollar.args + unwrapped_fields1147 = fields1146 write(pp, "(or") indent_sexp!(pp) - if !isempty(unwrapped_fields1142) + if !isempty(unwrapped_fields1147) newline(pp) - for (i1768, elem1143) in enumerate(unwrapped_fields1142) - i1144 = i1768 - 1 - if (i1144 > 0) + for (i1778, elem1148) in enumerate(unwrapped_fields1147) + i1149 = i1778 - 1 + if (i1149 > 0) newline(pp) end - pretty_formula(pp, elem1143) + pretty_formula(pp, elem1148) end end dedent!(pp) @@ -2336,18 +2340,18 @@ function pretty_disjunction(pp::PrettyPrinter, msg::Proto.Disjunction) end function pretty_not(pp::PrettyPrinter, msg::Proto.Not) - flat1148 = try_flat(pp, msg, pretty_not) - if !isnothing(flat1148) - write(pp, flat1148) + flat1153 = try_flat(pp, msg, pretty_not) + if !isnothing(flat1153) + write(pp, flat1153) return nothing else _dollar_dollar = msg - fields1146 = _dollar_dollar.arg - unwrapped_fields1147 = fields1146 + fields1151 = _dollar_dollar.arg + unwrapped_fields1152 = fields1151 write(pp, "(not") indent_sexp!(pp) newline(pp) - pretty_formula(pp, unwrapped_fields1147) + pretty_formula(pp, unwrapped_fields1152) dedent!(pp) write(pp, ")") end @@ -2355,25 +2359,25 @@ function pretty_not(pp::PrettyPrinter, msg::Proto.Not) end function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) - flat1154 = try_flat(pp, msg, pretty_ffi) - if !isnothing(flat1154) - write(pp, flat1154) + flat1159 = try_flat(pp, msg, pretty_ffi) + if !isnothing(flat1159) + write(pp, flat1159) return nothing else _dollar_dollar = msg - fields1149 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - unwrapped_fields1150 = fields1149 + fields1154 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) + unwrapped_fields1155 = fields1154 write(pp, "(ffi") indent_sexp!(pp) newline(pp) - field1151 = unwrapped_fields1150[1] - pretty_name(pp, field1151) + field1156 = unwrapped_fields1155[1] + pretty_name(pp, field1156) newline(pp) - field1152 = unwrapped_fields1150[2] - pretty_ffi_args(pp, field1152) + field1157 = unwrapped_fields1155[2] + pretty_ffi_args(pp, field1157) newline(pp) - field1153 = unwrapped_fields1150[3] - pretty_terms(pp, field1153) + field1158 = unwrapped_fields1155[3] + pretty_terms(pp, field1158) dedent!(pp) write(pp, ")") end @@ -2381,35 +2385,35 @@ function pretty_ffi(pp::PrettyPrinter, msg::Proto.FFI) end function pretty_name(pp::PrettyPrinter, msg::String) - flat1156 = try_flat(pp, msg, pretty_name) - if !isnothing(flat1156) - write(pp, flat1156) + flat1161 = try_flat(pp, msg, pretty_name) + if !isnothing(flat1161) + write(pp, flat1161) return nothing else - fields1155 = msg + fields1160 = msg write(pp, ":") - write(pp, fields1155) + write(pp, fields1160) end return nothing end function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) - flat1160 = try_flat(pp, msg, pretty_ffi_args) - if !isnothing(flat1160) - write(pp, flat1160) + flat1165 = try_flat(pp, msg, pretty_ffi_args) + if !isnothing(flat1165) + write(pp, flat1165) return nothing else - fields1157 = msg + fields1162 = msg write(pp, "(args") indent_sexp!(pp) - if !isempty(fields1157) + if !isempty(fields1162) newline(pp) - for (i1769, elem1158) in enumerate(fields1157) - i1159 = i1769 - 1 - if (i1159 > 0) + for (i1779, elem1163) in enumerate(fields1162) + i1164 = i1779 - 1 + if (i1164 > 0) newline(pp) end - pretty_abstraction(pp, elem1158) + pretty_abstraction(pp, elem1163) end end dedent!(pp) @@ -2419,28 +2423,28 @@ function pretty_ffi_args(pp::PrettyPrinter, msg::Vector{Proto.Abstraction}) end function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) - flat1167 = try_flat(pp, msg, pretty_atom) - if !isnothing(flat1167) - write(pp, flat1167) + flat1172 = try_flat(pp, msg, pretty_atom) + if !isnothing(flat1172) + write(pp, flat1172) return nothing else _dollar_dollar = msg - fields1161 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1162 = fields1161 + fields1166 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1167 = fields1166 write(pp, "(atom") indent_sexp!(pp) newline(pp) - field1163 = unwrapped_fields1162[1] - pretty_relation_id(pp, field1163) - field1164 = unwrapped_fields1162[2] - if !isempty(field1164) + field1168 = unwrapped_fields1167[1] + pretty_relation_id(pp, field1168) + field1169 = unwrapped_fields1167[2] + if !isempty(field1169) newline(pp) - for (i1770, elem1165) in enumerate(field1164) - i1166 = i1770 - 1 - if (i1166 > 0) + for (i1780, elem1170) in enumerate(field1169) + i1171 = i1780 - 1 + if (i1171 > 0) newline(pp) end - pretty_term(pp, elem1165) + pretty_term(pp, elem1170) end end dedent!(pp) @@ -2450,28 +2454,28 @@ function pretty_atom(pp::PrettyPrinter, msg::Proto.Atom) end function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) - flat1174 = try_flat(pp, msg, pretty_pragma) - if !isnothing(flat1174) - write(pp, flat1174) + flat1179 = try_flat(pp, msg, pretty_pragma) + if !isnothing(flat1179) + write(pp, flat1179) return nothing else _dollar_dollar = msg - fields1168 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1169 = fields1168 + fields1173 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1174 = fields1173 write(pp, "(pragma") indent_sexp!(pp) newline(pp) - field1170 = unwrapped_fields1169[1] - pretty_name(pp, field1170) - field1171 = unwrapped_fields1169[2] - if !isempty(field1171) + field1175 = unwrapped_fields1174[1] + pretty_name(pp, field1175) + field1176 = unwrapped_fields1174[2] + if !isempty(field1176) newline(pp) - for (i1771, elem1172) in enumerate(field1171) - i1173 = i1771 - 1 - if (i1173 > 0) + for (i1781, elem1177) in enumerate(field1176) + i1178 = i1781 - 1 + if (i1178 > 0) newline(pp) end - pretty_term(pp, elem1172) + pretty_term(pp, elem1177) end end dedent!(pp) @@ -2481,118 +2485,118 @@ function pretty_pragma(pp::PrettyPrinter, msg::Proto.Pragma) end function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) - flat1190 = try_flat(pp, msg, pretty_primitive) - if !isnothing(flat1190) - write(pp, flat1190) + flat1195 = try_flat(pp, msg, pretty_primitive) + if !isnothing(flat1195) + write(pp, flat1195) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_eq" - _t1772 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1782 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1772 = nothing + _t1782 = nothing end - guard_result1189 = _t1772 - if !isnothing(guard_result1189) + guard_result1194 = _t1782 + if !isnothing(guard_result1194) pretty_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1773 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1783 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1773 = nothing + _t1783 = nothing end - guard_result1188 = _t1773 - if !isnothing(guard_result1188) + guard_result1193 = _t1783 + if !isnothing(guard_result1193) pretty_lt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1774 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1784 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1774 = nothing + _t1784 = nothing end - guard_result1187 = _t1774 - if !isnothing(guard_result1187) + guard_result1192 = _t1784 + if !isnothing(guard_result1192) pretty_lt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1775 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1785 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1775 = nothing + _t1785 = nothing end - guard_result1186 = _t1775 - if !isnothing(guard_result1186) + guard_result1191 = _t1785 + if !isnothing(guard_result1191) pretty_gt(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1776 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + _t1786 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1776 = nothing + _t1786 = nothing end - guard_result1185 = _t1776 - if !isnothing(guard_result1185) + guard_result1190 = _t1786 + if !isnothing(guard_result1190) pretty_gt_eq(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1777 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1787 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1777 = nothing + _t1787 = nothing end - guard_result1184 = _t1777 - if !isnothing(guard_result1184) + guard_result1189 = _t1787 + if !isnothing(guard_result1189) pretty_add(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1778 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1788 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1778 = nothing + _t1788 = nothing end - guard_result1183 = _t1778 - if !isnothing(guard_result1183) + guard_result1188 = _t1788 + if !isnothing(guard_result1188) pretty_minus(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1779 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1789 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1779 = nothing + _t1789 = nothing end - guard_result1182 = _t1779 - if !isnothing(guard_result1182) + guard_result1187 = _t1789 + if !isnothing(guard_result1187) pretty_multiply(pp, msg) else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1780 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1790 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1780 = nothing + _t1790 = nothing end - guard_result1181 = _t1780 - if !isnothing(guard_result1181) + guard_result1186 = _t1790 + if !isnothing(guard_result1186) pretty_divide(pp, msg) else _dollar_dollar = msg - fields1175 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1176 = fields1175 + fields1180 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1181 = fields1180 write(pp, "(primitive") indent_sexp!(pp) newline(pp) - field1177 = unwrapped_fields1176[1] - pretty_name(pp, field1177) - field1178 = unwrapped_fields1176[2] - if !isempty(field1178) + field1182 = unwrapped_fields1181[1] + pretty_name(pp, field1182) + field1183 = unwrapped_fields1181[2] + if !isempty(field1183) newline(pp) - for (i1781, elem1179) in enumerate(field1178) - i1180 = i1781 - 1 - if (i1180 > 0) + for (i1791, elem1184) in enumerate(field1183) + i1185 = i1791 - 1 + if (i1185 > 0) newline(pp) end - pretty_rel_term(pp, elem1179) + pretty_rel_term(pp, elem1184) end end dedent!(pp) @@ -2611,48 +2615,20 @@ function pretty_primitive(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1195 = try_flat(pp, msg, pretty_eq) - if !isnothing(flat1195) - write(pp, flat1195) - return nothing - else - _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_eq" - _t1782 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) - else - _t1782 = nothing - end - fields1191 = _t1782 - unwrapped_fields1192 = fields1191 - write(pp, "(=") - indent_sexp!(pp) - newline(pp) - field1193 = unwrapped_fields1192[1] - pretty_term(pp, field1193) - newline(pp) - field1194 = unwrapped_fields1192[2] - pretty_term(pp, field1194) - dedent!(pp) - write(pp, ")") - end - return nothing -end - -function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1200 = try_flat(pp, msg, pretty_lt) + flat1200 = try_flat(pp, msg, pretty_eq) if !isnothing(flat1200) write(pp, flat1200) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_monotype" - _t1783 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + if _dollar_dollar.name == "rel_primitive_eq" + _t1792 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1783 = nothing + _t1792 = nothing end - fields1196 = _t1783 + fields1196 = _t1792 unwrapped_fields1197 = fields1196 - write(pp, "(<") + write(pp, "(=") indent_sexp!(pp) newline(pp) field1198 = unwrapped_fields1197[1] @@ -2666,21 +2642,21 @@ function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1205 = try_flat(pp, msg, pretty_lt_eq) +function pretty_lt(pp::PrettyPrinter, msg::Proto.Primitive) + flat1205 = try_flat(pp, msg, pretty_lt) if !isnothing(flat1205) write(pp, flat1205) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" - _t1784 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + if _dollar_dollar.name == "rel_primitive_lt_monotype" + _t1793 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1784 = nothing + _t1793 = nothing end - fields1201 = _t1784 + fields1201 = _t1793 unwrapped_fields1202 = fields1201 - write(pp, "(<=") + write(pp, "(<") indent_sexp!(pp) newline(pp) field1203 = unwrapped_fields1202[1] @@ -2694,21 +2670,21 @@ function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) - flat1210 = try_flat(pp, msg, pretty_gt) +function pretty_lt_eq(pp::PrettyPrinter, msg::Proto.Primitive) + flat1210 = try_flat(pp, msg, pretty_lt_eq) if !isnothing(flat1210) write(pp, flat1210) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_monotype" - _t1785 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + if _dollar_dollar.name == "rel_primitive_lt_eq_monotype" + _t1794 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1785 = nothing + _t1794 = nothing end - fields1206 = _t1785 + fields1206 = _t1794 unwrapped_fields1207 = fields1206 - write(pp, "(>") + write(pp, "(<=") indent_sexp!(pp) newline(pp) field1208 = unwrapped_fields1207[1] @@ -2722,21 +2698,21 @@ function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) - flat1215 = try_flat(pp, msg, pretty_gt_eq) +function pretty_gt(pp::PrettyPrinter, msg::Proto.Primitive) + flat1215 = try_flat(pp, msg, pretty_gt) if !isnothing(flat1215) write(pp, flat1215) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" - _t1786 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) + if _dollar_dollar.name == "rel_primitive_gt_monotype" + _t1795 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1786 = nothing + _t1795 = nothing end - fields1211 = _t1786 + fields1211 = _t1795 unwrapped_fields1212 = fields1211 - write(pp, "(>=") + write(pp, "(>") indent_sexp!(pp) newline(pp) field1213 = unwrapped_fields1212[1] @@ -2750,21 +2726,21 @@ function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) return nothing end -function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) - flat1221 = try_flat(pp, msg, pretty_add) - if !isnothing(flat1221) - write(pp, flat1221) +function pretty_gt_eq(pp::PrettyPrinter, msg::Proto.Primitive) + flat1220 = try_flat(pp, msg, pretty_gt_eq) + if !isnothing(flat1220) + write(pp, flat1220) return nothing else _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_add_monotype" - _t1787 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + if _dollar_dollar.name == "rel_primitive_gt_eq_monotype" + _t1796 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term),) else - _t1787 = nothing + _t1796 = nothing end - fields1216 = _t1787 + fields1216 = _t1796 unwrapped_fields1217 = fields1216 - write(pp, "(+") + write(pp, "(>=") indent_sexp!(pp) newline(pp) field1218 = unwrapped_fields1217[1] @@ -2772,9 +2748,37 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) newline(pp) field1219 = unwrapped_fields1217[2] pretty_term(pp, field1219) + dedent!(pp) + write(pp, ")") + end + return nothing +end + +function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) + flat1226 = try_flat(pp, msg, pretty_add) + if !isnothing(flat1226) + write(pp, flat1226) + return nothing + else + _dollar_dollar = msg + if _dollar_dollar.name == "rel_primitive_add_monotype" + _t1797 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + else + _t1797 = nothing + end + fields1221 = _t1797 + unwrapped_fields1222 = fields1221 + write(pp, "(+") + indent_sexp!(pp) + newline(pp) + field1223 = unwrapped_fields1222[1] + pretty_term(pp, field1223) newline(pp) - field1220 = unwrapped_fields1217[3] - pretty_term(pp, field1220) + field1224 = unwrapped_fields1222[2] + pretty_term(pp, field1224) + newline(pp) + field1225 = unwrapped_fields1222[3] + pretty_term(pp, field1225) dedent!(pp) write(pp, ")") end @@ -2782,30 +2786,30 @@ function pretty_add(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) - flat1227 = try_flat(pp, msg, pretty_minus) - if !isnothing(flat1227) - write(pp, flat1227) + flat1232 = try_flat(pp, msg, pretty_minus) + if !isnothing(flat1232) + write(pp, flat1232) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_subtract_monotype" - _t1788 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1798 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1788 = nothing + _t1798 = nothing end - fields1222 = _t1788 - unwrapped_fields1223 = fields1222 + fields1227 = _t1798 + unwrapped_fields1228 = fields1227 write(pp, "(-") indent_sexp!(pp) newline(pp) - field1224 = unwrapped_fields1223[1] - pretty_term(pp, field1224) + field1229 = unwrapped_fields1228[1] + pretty_term(pp, field1229) newline(pp) - field1225 = unwrapped_fields1223[2] - pretty_term(pp, field1225) + field1230 = unwrapped_fields1228[2] + pretty_term(pp, field1230) newline(pp) - field1226 = unwrapped_fields1223[3] - pretty_term(pp, field1226) + field1231 = unwrapped_fields1228[3] + pretty_term(pp, field1231) dedent!(pp) write(pp, ")") end @@ -2813,30 +2817,30 @@ function pretty_minus(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) - flat1233 = try_flat(pp, msg, pretty_multiply) - if !isnothing(flat1233) - write(pp, flat1233) + flat1238 = try_flat(pp, msg, pretty_multiply) + if !isnothing(flat1238) + write(pp, flat1238) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_multiply_monotype" - _t1789 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1799 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1789 = nothing + _t1799 = nothing end - fields1228 = _t1789 - unwrapped_fields1229 = fields1228 + fields1233 = _t1799 + unwrapped_fields1234 = fields1233 write(pp, "(*") indent_sexp!(pp) newline(pp) - field1230 = unwrapped_fields1229[1] - pretty_term(pp, field1230) + field1235 = unwrapped_fields1234[1] + pretty_term(pp, field1235) newline(pp) - field1231 = unwrapped_fields1229[2] - pretty_term(pp, field1231) + field1236 = unwrapped_fields1234[2] + pretty_term(pp, field1236) newline(pp) - field1232 = unwrapped_fields1229[3] - pretty_term(pp, field1232) + field1237 = unwrapped_fields1234[3] + pretty_term(pp, field1237) dedent!(pp) write(pp, ")") end @@ -2844,30 +2848,30 @@ function pretty_multiply(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) - flat1239 = try_flat(pp, msg, pretty_divide) - if !isnothing(flat1239) - write(pp, flat1239) + flat1244 = try_flat(pp, msg, pretty_divide) + if !isnothing(flat1244) + write(pp, flat1244) return nothing else _dollar_dollar = msg if _dollar_dollar.name == "rel_primitive_divide_monotype" - _t1790 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) + _t1800 = (_get_oneof_field(_dollar_dollar.terms[1], :term), _get_oneof_field(_dollar_dollar.terms[2], :term), _get_oneof_field(_dollar_dollar.terms[3], :term),) else - _t1790 = nothing + _t1800 = nothing end - fields1234 = _t1790 - unwrapped_fields1235 = fields1234 + fields1239 = _t1800 + unwrapped_fields1240 = fields1239 write(pp, "(/") indent_sexp!(pp) newline(pp) - field1236 = unwrapped_fields1235[1] - pretty_term(pp, field1236) + field1241 = unwrapped_fields1240[1] + pretty_term(pp, field1241) newline(pp) - field1237 = unwrapped_fields1235[2] - pretty_term(pp, field1237) + field1242 = unwrapped_fields1240[2] + pretty_term(pp, field1242) newline(pp) - field1238 = unwrapped_fields1235[3] - pretty_term(pp, field1238) + field1243 = unwrapped_fields1240[3] + pretty_term(pp, field1243) dedent!(pp) write(pp, ")") end @@ -2875,32 +2879,32 @@ function pretty_divide(pp::PrettyPrinter, msg::Proto.Primitive) end function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) - flat1244 = try_flat(pp, msg, pretty_rel_term) - if !isnothing(flat1244) - write(pp, flat1244) + flat1249 = try_flat(pp, msg, pretty_rel_term) + if !isnothing(flat1249) + write(pp, flat1249) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("specialized_value")) - _t1791 = _get_oneof_field(_dollar_dollar, :specialized_value) + _t1801 = _get_oneof_field(_dollar_dollar, :specialized_value) else - _t1791 = nothing + _t1801 = nothing end - deconstruct_result1242 = _t1791 - if !isnothing(deconstruct_result1242) - unwrapped1243 = deconstruct_result1242 - pretty_specialized_value(pp, unwrapped1243) + deconstruct_result1247 = _t1801 + if !isnothing(deconstruct_result1247) + unwrapped1248 = deconstruct_result1247 + pretty_specialized_value(pp, unwrapped1248) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("term")) - _t1792 = _get_oneof_field(_dollar_dollar, :term) + _t1802 = _get_oneof_field(_dollar_dollar, :term) else - _t1792 = nothing + _t1802 = nothing end - deconstruct_result1240 = _t1792 - if !isnothing(deconstruct_result1240) - unwrapped1241 = deconstruct_result1240 - pretty_term(pp, unwrapped1241) + deconstruct_result1245 = _t1802 + if !isnothing(deconstruct_result1245) + unwrapped1246 = deconstruct_result1245 + pretty_term(pp, unwrapped1246) else throw(ParseError("No matching rule for rel_term")) end @@ -2910,41 +2914,41 @@ function pretty_rel_term(pp::PrettyPrinter, msg::Proto.RelTerm) end function pretty_specialized_value(pp::PrettyPrinter, msg::Proto.Value) - flat1246 = try_flat(pp, msg, pretty_specialized_value) - if !isnothing(flat1246) - write(pp, flat1246) + flat1251 = try_flat(pp, msg, pretty_specialized_value) + if !isnothing(flat1251) + write(pp, flat1251) return nothing else - fields1245 = msg + fields1250 = msg write(pp, "#") - pretty_raw_value(pp, fields1245) + pretty_raw_value(pp, fields1250) end return nothing end function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) - flat1253 = try_flat(pp, msg, pretty_rel_atom) - if !isnothing(flat1253) - write(pp, flat1253) + flat1258 = try_flat(pp, msg, pretty_rel_atom) + if !isnothing(flat1258) + write(pp, flat1258) return nothing else _dollar_dollar = msg - fields1247 = (_dollar_dollar.name, _dollar_dollar.terms,) - unwrapped_fields1248 = fields1247 + fields1252 = (_dollar_dollar.name, _dollar_dollar.terms,) + unwrapped_fields1253 = fields1252 write(pp, "(relatom") indent_sexp!(pp) newline(pp) - field1249 = unwrapped_fields1248[1] - pretty_name(pp, field1249) - field1250 = unwrapped_fields1248[2] - if !isempty(field1250) + field1254 = unwrapped_fields1253[1] + pretty_name(pp, field1254) + field1255 = unwrapped_fields1253[2] + if !isempty(field1255) newline(pp) - for (i1793, elem1251) in enumerate(field1250) - i1252 = i1793 - 1 - if (i1252 > 0) + for (i1803, elem1256) in enumerate(field1255) + i1257 = i1803 - 1 + if (i1257 > 0) newline(pp) end - pretty_rel_term(pp, elem1251) + pretty_rel_term(pp, elem1256) end end dedent!(pp) @@ -2954,22 +2958,22 @@ function pretty_rel_atom(pp::PrettyPrinter, msg::Proto.RelAtom) end function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) - flat1258 = try_flat(pp, msg, pretty_cast) - if !isnothing(flat1258) - write(pp, flat1258) + flat1263 = try_flat(pp, msg, pretty_cast) + if !isnothing(flat1263) + write(pp, flat1263) return nothing else _dollar_dollar = msg - fields1254 = (_dollar_dollar.input, _dollar_dollar.result,) - unwrapped_fields1255 = fields1254 + fields1259 = (_dollar_dollar.input, _dollar_dollar.result,) + unwrapped_fields1260 = fields1259 write(pp, "(cast") indent_sexp!(pp) newline(pp) - field1256 = unwrapped_fields1255[1] - pretty_term(pp, field1256) + field1261 = unwrapped_fields1260[1] + pretty_term(pp, field1261) newline(pp) - field1257 = unwrapped_fields1255[2] - pretty_term(pp, field1257) + field1262 = unwrapped_fields1260[2] + pretty_term(pp, field1262) dedent!(pp) write(pp, ")") end @@ -2977,22 +2981,22 @@ function pretty_cast(pp::PrettyPrinter, msg::Proto.Cast) end function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) - flat1262 = try_flat(pp, msg, pretty_attrs) - if !isnothing(flat1262) - write(pp, flat1262) + flat1267 = try_flat(pp, msg, pretty_attrs) + if !isnothing(flat1267) + write(pp, flat1267) return nothing else - fields1259 = msg + fields1264 = msg write(pp, "(attrs") indent_sexp!(pp) - if !isempty(fields1259) + if !isempty(fields1264) newline(pp) - for (i1794, elem1260) in enumerate(fields1259) - i1261 = i1794 - 1 - if (i1261 > 0) + for (i1804, elem1265) in enumerate(fields1264) + i1266 = i1804 - 1 + if (i1266 > 0) newline(pp) end - pretty_attribute(pp, elem1260) + pretty_attribute(pp, elem1265) end end dedent!(pp) @@ -3002,28 +3006,28 @@ function pretty_attrs(pp::PrettyPrinter, msg::Vector{Proto.Attribute}) end function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) - flat1269 = try_flat(pp, msg, pretty_attribute) - if !isnothing(flat1269) - write(pp, flat1269) + flat1274 = try_flat(pp, msg, pretty_attribute) + if !isnothing(flat1274) + write(pp, flat1274) return nothing else _dollar_dollar = msg - fields1263 = (_dollar_dollar.name, _dollar_dollar.args,) - unwrapped_fields1264 = fields1263 + fields1268 = (_dollar_dollar.name, _dollar_dollar.args,) + unwrapped_fields1269 = fields1268 write(pp, "(attribute") indent_sexp!(pp) newline(pp) - field1265 = unwrapped_fields1264[1] - pretty_name(pp, field1265) - field1266 = unwrapped_fields1264[2] - if !isempty(field1266) + field1270 = unwrapped_fields1269[1] + pretty_name(pp, field1270) + field1271 = unwrapped_fields1269[2] + if !isempty(field1271) newline(pp) - for (i1795, elem1267) in enumerate(field1266) - i1268 = i1795 - 1 - if (i1268 > 0) + for (i1805, elem1272) in enumerate(field1271) + i1273 = i1805 - 1 + if (i1273 > 0) newline(pp) end - pretty_raw_value(pp, elem1267) + pretty_raw_value(pp, elem1272) end end dedent!(pp) @@ -3033,40 +3037,40 @@ function pretty_attribute(pp::PrettyPrinter, msg::Proto.Attribute) end function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) - flat1278 = try_flat(pp, msg, pretty_algorithm) - if !isnothing(flat1278) - write(pp, flat1278) + flat1283 = try_flat(pp, msg, pretty_algorithm) + if !isnothing(flat1283) + write(pp, flat1283) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1796 = _dollar_dollar.attrs + _t1806 = _dollar_dollar.attrs else - _t1796 = nothing + _t1806 = nothing end - fields1270 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1796,) - unwrapped_fields1271 = fields1270 + fields1275 = (_dollar_dollar.var"#global", _dollar_dollar.body, _t1806,) + unwrapped_fields1276 = fields1275 write(pp, "(algorithm") indent_sexp!(pp) - field1272 = unwrapped_fields1271[1] - if !isempty(field1272) + field1277 = unwrapped_fields1276[1] + if !isempty(field1277) newline(pp) - for (i1797, elem1273) in enumerate(field1272) - i1274 = i1797 - 1 - if (i1274 > 0) + for (i1807, elem1278) in enumerate(field1277) + i1279 = i1807 - 1 + if (i1279 > 0) newline(pp) end - pretty_relation_id(pp, elem1273) + pretty_relation_id(pp, elem1278) end end newline(pp) - field1275 = unwrapped_fields1271[2] - pretty_script(pp, field1275) - field1276 = unwrapped_fields1271[3] - if !isnothing(field1276) + field1280 = unwrapped_fields1276[2] + pretty_script(pp, field1280) + field1281 = unwrapped_fields1276[3] + if !isnothing(field1281) newline(pp) - opt_val1277 = field1276 - pretty_attrs(pp, opt_val1277) + opt_val1282 = field1281 + pretty_attrs(pp, opt_val1282) end dedent!(pp) write(pp, ")") @@ -3075,24 +3079,24 @@ function pretty_algorithm(pp::PrettyPrinter, msg::Proto.Algorithm) end function pretty_script(pp::PrettyPrinter, msg::Proto.Script) - flat1283 = try_flat(pp, msg, pretty_script) - if !isnothing(flat1283) - write(pp, flat1283) + flat1288 = try_flat(pp, msg, pretty_script) + if !isnothing(flat1288) + write(pp, flat1288) return nothing else _dollar_dollar = msg - fields1279 = _dollar_dollar.constructs - unwrapped_fields1280 = fields1279 + fields1284 = _dollar_dollar.constructs + unwrapped_fields1285 = fields1284 write(pp, "(script") indent_sexp!(pp) - if !isempty(unwrapped_fields1280) + if !isempty(unwrapped_fields1285) newline(pp) - for (i1798, elem1281) in enumerate(unwrapped_fields1280) - i1282 = i1798 - 1 - if (i1282 > 0) + for (i1808, elem1286) in enumerate(unwrapped_fields1285) + i1287 = i1808 - 1 + if (i1287 > 0) newline(pp) end - pretty_construct(pp, elem1281) + pretty_construct(pp, elem1286) end end dedent!(pp) @@ -3102,32 +3106,32 @@ function pretty_script(pp::PrettyPrinter, msg::Proto.Script) end function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) - flat1288 = try_flat(pp, msg, pretty_construct) - if !isnothing(flat1288) - write(pp, flat1288) + flat1293 = try_flat(pp, msg, pretty_construct) + if !isnothing(flat1293) + write(pp, flat1293) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("loop")) - _t1799 = _get_oneof_field(_dollar_dollar, :loop) + _t1809 = _get_oneof_field(_dollar_dollar, :loop) else - _t1799 = nothing + _t1809 = nothing end - deconstruct_result1286 = _t1799 - if !isnothing(deconstruct_result1286) - unwrapped1287 = deconstruct_result1286 - pretty_loop(pp, unwrapped1287) + deconstruct_result1291 = _t1809 + if !isnothing(deconstruct_result1291) + unwrapped1292 = deconstruct_result1291 + pretty_loop(pp, unwrapped1292) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("instruction")) - _t1800 = _get_oneof_field(_dollar_dollar, :instruction) + _t1810 = _get_oneof_field(_dollar_dollar, :instruction) else - _t1800 = nothing + _t1810 = nothing end - deconstruct_result1284 = _t1800 - if !isnothing(deconstruct_result1284) - unwrapped1285 = deconstruct_result1284 - pretty_instruction(pp, unwrapped1285) + deconstruct_result1289 = _t1810 + if !isnothing(deconstruct_result1289) + unwrapped1290 = deconstruct_result1289 + pretty_instruction(pp, unwrapped1290) else throw(ParseError("No matching rule for construct")) end @@ -3137,32 +3141,32 @@ function pretty_construct(pp::PrettyPrinter, msg::Proto.Construct) end function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) - flat1295 = try_flat(pp, msg, pretty_loop) - if !isnothing(flat1295) - write(pp, flat1295) + flat1300 = try_flat(pp, msg, pretty_loop) + if !isnothing(flat1300) + write(pp, flat1300) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1801 = _dollar_dollar.attrs + _t1811 = _dollar_dollar.attrs else - _t1801 = nothing + _t1811 = nothing end - fields1289 = (_dollar_dollar.init, _dollar_dollar.body, _t1801,) - unwrapped_fields1290 = fields1289 + fields1294 = (_dollar_dollar.init, _dollar_dollar.body, _t1811,) + unwrapped_fields1295 = fields1294 write(pp, "(loop") indent_sexp!(pp) newline(pp) - field1291 = unwrapped_fields1290[1] - pretty_init(pp, field1291) + field1296 = unwrapped_fields1295[1] + pretty_init(pp, field1296) newline(pp) - field1292 = unwrapped_fields1290[2] - pretty_script(pp, field1292) - field1293 = unwrapped_fields1290[3] - if !isnothing(field1293) + field1297 = unwrapped_fields1295[2] + pretty_script(pp, field1297) + field1298 = unwrapped_fields1295[3] + if !isnothing(field1298) newline(pp) - opt_val1294 = field1293 - pretty_attrs(pp, opt_val1294) + opt_val1299 = field1298 + pretty_attrs(pp, opt_val1299) end dedent!(pp) write(pp, ")") @@ -3171,22 +3175,22 @@ function pretty_loop(pp::PrettyPrinter, msg::Proto.Loop) end function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) - flat1299 = try_flat(pp, msg, pretty_init) - if !isnothing(flat1299) - write(pp, flat1299) + flat1304 = try_flat(pp, msg, pretty_init) + if !isnothing(flat1304) + write(pp, flat1304) return nothing else - fields1296 = msg + fields1301 = msg write(pp, "(init") indent_sexp!(pp) - if !isempty(fields1296) + if !isempty(fields1301) newline(pp) - for (i1802, elem1297) in enumerate(fields1296) - i1298 = i1802 - 1 - if (i1298 > 0) + for (i1812, elem1302) in enumerate(fields1301) + i1303 = i1812 - 1 + if (i1303 > 0) newline(pp) end - pretty_instruction(pp, elem1297) + pretty_instruction(pp, elem1302) end end dedent!(pp) @@ -3196,65 +3200,65 @@ function pretty_init(pp::PrettyPrinter, msg::Vector{Proto.Instruction}) end function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) - flat1310 = try_flat(pp, msg, pretty_instruction) - if !isnothing(flat1310) - write(pp, flat1310) + flat1315 = try_flat(pp, msg, pretty_instruction) + if !isnothing(flat1315) + write(pp, flat1315) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("assign")) - _t1803 = _get_oneof_field(_dollar_dollar, :assign) + _t1813 = _get_oneof_field(_dollar_dollar, :assign) else - _t1803 = nothing + _t1813 = nothing end - deconstruct_result1308 = _t1803 - if !isnothing(deconstruct_result1308) - unwrapped1309 = deconstruct_result1308 - pretty_assign(pp, unwrapped1309) + deconstruct_result1313 = _t1813 + if !isnothing(deconstruct_result1313) + unwrapped1314 = deconstruct_result1313 + pretty_assign(pp, unwrapped1314) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("upsert")) - _t1804 = _get_oneof_field(_dollar_dollar, :upsert) + _t1814 = _get_oneof_field(_dollar_dollar, :upsert) else - _t1804 = nothing + _t1814 = nothing end - deconstruct_result1306 = _t1804 - if !isnothing(deconstruct_result1306) - unwrapped1307 = deconstruct_result1306 - pretty_upsert(pp, unwrapped1307) + deconstruct_result1311 = _t1814 + if !isnothing(deconstruct_result1311) + unwrapped1312 = deconstruct_result1311 + pretty_upsert(pp, unwrapped1312) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#break")) - _t1805 = _get_oneof_field(_dollar_dollar, :var"#break") + _t1815 = _get_oneof_field(_dollar_dollar, :var"#break") else - _t1805 = nothing + _t1815 = nothing end - deconstruct_result1304 = _t1805 - if !isnothing(deconstruct_result1304) - unwrapped1305 = deconstruct_result1304 - pretty_break(pp, unwrapped1305) + deconstruct_result1309 = _t1815 + if !isnothing(deconstruct_result1309) + unwrapped1310 = deconstruct_result1309 + pretty_break(pp, unwrapped1310) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monoid_def")) - _t1806 = _get_oneof_field(_dollar_dollar, :monoid_def) + _t1816 = _get_oneof_field(_dollar_dollar, :monoid_def) else - _t1806 = nothing + _t1816 = nothing end - deconstruct_result1302 = _t1806 - if !isnothing(deconstruct_result1302) - unwrapped1303 = deconstruct_result1302 - pretty_monoid_def(pp, unwrapped1303) + deconstruct_result1307 = _t1816 + if !isnothing(deconstruct_result1307) + unwrapped1308 = deconstruct_result1307 + pretty_monoid_def(pp, unwrapped1308) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("monus_def")) - _t1807 = _get_oneof_field(_dollar_dollar, :monus_def) + _t1817 = _get_oneof_field(_dollar_dollar, :monus_def) else - _t1807 = nothing + _t1817 = nothing end - deconstruct_result1300 = _t1807 - if !isnothing(deconstruct_result1300) - unwrapped1301 = deconstruct_result1300 - pretty_monus_def(pp, unwrapped1301) + deconstruct_result1305 = _t1817 + if !isnothing(deconstruct_result1305) + unwrapped1306 = deconstruct_result1305 + pretty_monus_def(pp, unwrapped1306) else throw(ParseError("No matching rule for instruction")) end @@ -3267,32 +3271,32 @@ function pretty_instruction(pp::PrettyPrinter, msg::Proto.Instruction) end function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) - flat1317 = try_flat(pp, msg, pretty_assign) - if !isnothing(flat1317) - write(pp, flat1317) + flat1322 = try_flat(pp, msg, pretty_assign) + if !isnothing(flat1322) + write(pp, flat1322) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1808 = _dollar_dollar.attrs + _t1818 = _dollar_dollar.attrs else - _t1808 = nothing + _t1818 = nothing end - fields1311 = (_dollar_dollar.name, _dollar_dollar.body, _t1808,) - unwrapped_fields1312 = fields1311 + fields1316 = (_dollar_dollar.name, _dollar_dollar.body, _t1818,) + unwrapped_fields1317 = fields1316 write(pp, "(assign") indent_sexp!(pp) newline(pp) - field1313 = unwrapped_fields1312[1] - pretty_relation_id(pp, field1313) + field1318 = unwrapped_fields1317[1] + pretty_relation_id(pp, field1318) newline(pp) - field1314 = unwrapped_fields1312[2] - pretty_abstraction(pp, field1314) - field1315 = unwrapped_fields1312[3] - if !isnothing(field1315) + field1319 = unwrapped_fields1317[2] + pretty_abstraction(pp, field1319) + field1320 = unwrapped_fields1317[3] + if !isnothing(field1320) newline(pp) - opt_val1316 = field1315 - pretty_attrs(pp, opt_val1316) + opt_val1321 = field1320 + pretty_attrs(pp, opt_val1321) end dedent!(pp) write(pp, ")") @@ -3301,32 +3305,32 @@ function pretty_assign(pp::PrettyPrinter, msg::Proto.Assign) end function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) - flat1324 = try_flat(pp, msg, pretty_upsert) - if !isnothing(flat1324) - write(pp, flat1324) + flat1329 = try_flat(pp, msg, pretty_upsert) + if !isnothing(flat1329) + write(pp, flat1329) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1809 = _dollar_dollar.attrs + _t1819 = _dollar_dollar.attrs else - _t1809 = nothing + _t1819 = nothing end - fields1318 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1809,) - unwrapped_fields1319 = fields1318 + fields1323 = (_dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1819,) + unwrapped_fields1324 = fields1323 write(pp, "(upsert") indent_sexp!(pp) newline(pp) - field1320 = unwrapped_fields1319[1] - pretty_relation_id(pp, field1320) + field1325 = unwrapped_fields1324[1] + pretty_relation_id(pp, field1325) newline(pp) - field1321 = unwrapped_fields1319[2] - pretty_abstraction_with_arity(pp, field1321) - field1322 = unwrapped_fields1319[3] - if !isnothing(field1322) + field1326 = unwrapped_fields1324[2] + pretty_abstraction_with_arity(pp, field1326) + field1327 = unwrapped_fields1324[3] + if !isnothing(field1327) newline(pp) - opt_val1323 = field1322 - pretty_attrs(pp, opt_val1323) + opt_val1328 = field1327 + pretty_attrs(pp, opt_val1328) end dedent!(pp) write(pp, ")") @@ -3335,22 +3339,22 @@ function pretty_upsert(pp::PrettyPrinter, msg::Proto.Upsert) end function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstraction, Int64}) - flat1329 = try_flat(pp, msg, pretty_abstraction_with_arity) - if !isnothing(flat1329) - write(pp, flat1329) + flat1334 = try_flat(pp, msg, pretty_abstraction_with_arity) + if !isnothing(flat1334) + write(pp, flat1334) return nothing else _dollar_dollar = msg - _t1810 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) - fields1325 = (_t1810, _dollar_dollar[1].value,) - unwrapped_fields1326 = fields1325 + _t1820 = deconstruct_bindings_with_arity(pp, _dollar_dollar[1], _dollar_dollar[2]) + fields1330 = (_t1820, _dollar_dollar[1].value,) + unwrapped_fields1331 = fields1330 write(pp, "(") indent!(pp) - field1327 = unwrapped_fields1326[1] - pretty_bindings(pp, field1327) + field1332 = unwrapped_fields1331[1] + pretty_bindings(pp, field1332) newline(pp) - field1328 = unwrapped_fields1326[2] - pretty_formula(pp, field1328) + field1333 = unwrapped_fields1331[2] + pretty_formula(pp, field1333) dedent!(pp) write(pp, ")") end @@ -3358,32 +3362,32 @@ function pretty_abstraction_with_arity(pp::PrettyPrinter, msg::Tuple{Proto.Abstr end function pretty_break(pp::PrettyPrinter, msg::Proto.Break) - flat1336 = try_flat(pp, msg, pretty_break) - if !isnothing(flat1336) - write(pp, flat1336) + flat1341 = try_flat(pp, msg, pretty_break) + if !isnothing(flat1341) + write(pp, flat1341) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1811 = _dollar_dollar.attrs + _t1821 = _dollar_dollar.attrs else - _t1811 = nothing + _t1821 = nothing end - fields1330 = (_dollar_dollar.name, _dollar_dollar.body, _t1811,) - unwrapped_fields1331 = fields1330 + fields1335 = (_dollar_dollar.name, _dollar_dollar.body, _t1821,) + unwrapped_fields1336 = fields1335 write(pp, "(break") indent_sexp!(pp) newline(pp) - field1332 = unwrapped_fields1331[1] - pretty_relation_id(pp, field1332) + field1337 = unwrapped_fields1336[1] + pretty_relation_id(pp, field1337) newline(pp) - field1333 = unwrapped_fields1331[2] - pretty_abstraction(pp, field1333) - field1334 = unwrapped_fields1331[3] - if !isnothing(field1334) + field1338 = unwrapped_fields1336[2] + pretty_abstraction(pp, field1338) + field1339 = unwrapped_fields1336[3] + if !isnothing(field1339) newline(pp) - opt_val1335 = field1334 - pretty_attrs(pp, opt_val1335) + opt_val1340 = field1339 + pretty_attrs(pp, opt_val1340) end dedent!(pp) write(pp, ")") @@ -3392,35 +3396,35 @@ function pretty_break(pp::PrettyPrinter, msg::Proto.Break) end function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) - flat1344 = try_flat(pp, msg, pretty_monoid_def) - if !isnothing(flat1344) - write(pp, flat1344) + flat1349 = try_flat(pp, msg, pretty_monoid_def) + if !isnothing(flat1349) + write(pp, flat1349) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1812 = _dollar_dollar.attrs + _t1822 = _dollar_dollar.attrs else - _t1812 = nothing + _t1822 = nothing end - fields1337 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1812,) - unwrapped_fields1338 = fields1337 + fields1342 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1822,) + unwrapped_fields1343 = fields1342 write(pp, "(monoid") indent_sexp!(pp) newline(pp) - field1339 = unwrapped_fields1338[1] - pretty_monoid(pp, field1339) + field1344 = unwrapped_fields1343[1] + pretty_monoid(pp, field1344) newline(pp) - field1340 = unwrapped_fields1338[2] - pretty_relation_id(pp, field1340) + field1345 = unwrapped_fields1343[2] + pretty_relation_id(pp, field1345) newline(pp) - field1341 = unwrapped_fields1338[3] - pretty_abstraction_with_arity(pp, field1341) - field1342 = unwrapped_fields1338[4] - if !isnothing(field1342) + field1346 = unwrapped_fields1343[3] + pretty_abstraction_with_arity(pp, field1346) + field1347 = unwrapped_fields1343[4] + if !isnothing(field1347) newline(pp) - opt_val1343 = field1342 - pretty_attrs(pp, opt_val1343) + opt_val1348 = field1347 + pretty_attrs(pp, opt_val1348) end dedent!(pp) write(pp, ")") @@ -3429,54 +3433,54 @@ function pretty_monoid_def(pp::PrettyPrinter, msg::Proto.MonoidDef) end function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) - flat1353 = try_flat(pp, msg, pretty_monoid) - if !isnothing(flat1353) - write(pp, flat1353) + flat1358 = try_flat(pp, msg, pretty_monoid) + if !isnothing(flat1358) + write(pp, flat1358) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("or_monoid")) - _t1813 = _get_oneof_field(_dollar_dollar, :or_monoid) + _t1823 = _get_oneof_field(_dollar_dollar, :or_monoid) else - _t1813 = nothing + _t1823 = nothing end - deconstruct_result1351 = _t1813 - if !isnothing(deconstruct_result1351) - unwrapped1352 = deconstruct_result1351 - pretty_or_monoid(pp, unwrapped1352) + deconstruct_result1356 = _t1823 + if !isnothing(deconstruct_result1356) + unwrapped1357 = deconstruct_result1356 + pretty_or_monoid(pp, unwrapped1357) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("min_monoid")) - _t1814 = _get_oneof_field(_dollar_dollar, :min_monoid) + _t1824 = _get_oneof_field(_dollar_dollar, :min_monoid) else - _t1814 = nothing + _t1824 = nothing end - deconstruct_result1349 = _t1814 - if !isnothing(deconstruct_result1349) - unwrapped1350 = deconstruct_result1349 - pretty_min_monoid(pp, unwrapped1350) + deconstruct_result1354 = _t1824 + if !isnothing(deconstruct_result1354) + unwrapped1355 = deconstruct_result1354 + pretty_min_monoid(pp, unwrapped1355) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("max_monoid")) - _t1815 = _get_oneof_field(_dollar_dollar, :max_monoid) + _t1825 = _get_oneof_field(_dollar_dollar, :max_monoid) else - _t1815 = nothing + _t1825 = nothing end - deconstruct_result1347 = _t1815 - if !isnothing(deconstruct_result1347) - unwrapped1348 = deconstruct_result1347 - pretty_max_monoid(pp, unwrapped1348) + deconstruct_result1352 = _t1825 + if !isnothing(deconstruct_result1352) + unwrapped1353 = deconstruct_result1352 + pretty_max_monoid(pp, unwrapped1353) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("sum_monoid")) - _t1816 = _get_oneof_field(_dollar_dollar, :sum_monoid) + _t1826 = _get_oneof_field(_dollar_dollar, :sum_monoid) else - _t1816 = nothing + _t1826 = nothing end - deconstruct_result1345 = _t1816 - if !isnothing(deconstruct_result1345) - unwrapped1346 = deconstruct_result1345 - pretty_sum_monoid(pp, unwrapped1346) + deconstruct_result1350 = _t1826 + if !isnothing(deconstruct_result1350) + unwrapped1351 = deconstruct_result1350 + pretty_sum_monoid(pp, unwrapped1351) else throw(ParseError("No matching rule for monoid")) end @@ -3488,24 +3492,24 @@ function pretty_monoid(pp::PrettyPrinter, msg::Proto.Monoid) end function pretty_or_monoid(pp::PrettyPrinter, msg::Proto.OrMonoid) - fields1354 = msg + fields1359 = msg write(pp, "(or)") return nothing end function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) - flat1357 = try_flat(pp, msg, pretty_min_monoid) - if !isnothing(flat1357) - write(pp, flat1357) + flat1362 = try_flat(pp, msg, pretty_min_monoid) + if !isnothing(flat1362) + write(pp, flat1362) return nothing else _dollar_dollar = msg - fields1355 = _dollar_dollar.var"#type" - unwrapped_fields1356 = fields1355 + fields1360 = _dollar_dollar.var"#type" + unwrapped_fields1361 = fields1360 write(pp, "(min") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1356) + pretty_type(pp, unwrapped_fields1361) dedent!(pp) write(pp, ")") end @@ -3513,18 +3517,18 @@ function pretty_min_monoid(pp::PrettyPrinter, msg::Proto.MinMonoid) end function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) - flat1360 = try_flat(pp, msg, pretty_max_monoid) - if !isnothing(flat1360) - write(pp, flat1360) + flat1365 = try_flat(pp, msg, pretty_max_monoid) + if !isnothing(flat1365) + write(pp, flat1365) return nothing else _dollar_dollar = msg - fields1358 = _dollar_dollar.var"#type" - unwrapped_fields1359 = fields1358 + fields1363 = _dollar_dollar.var"#type" + unwrapped_fields1364 = fields1363 write(pp, "(max") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1359) + pretty_type(pp, unwrapped_fields1364) dedent!(pp) write(pp, ")") end @@ -3532,18 +3536,18 @@ function pretty_max_monoid(pp::PrettyPrinter, msg::Proto.MaxMonoid) end function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) - flat1363 = try_flat(pp, msg, pretty_sum_monoid) - if !isnothing(flat1363) - write(pp, flat1363) + flat1368 = try_flat(pp, msg, pretty_sum_monoid) + if !isnothing(flat1368) + write(pp, flat1368) return nothing else _dollar_dollar = msg - fields1361 = _dollar_dollar.var"#type" - unwrapped_fields1362 = fields1361 + fields1366 = _dollar_dollar.var"#type" + unwrapped_fields1367 = fields1366 write(pp, "(sum") indent_sexp!(pp) newline(pp) - pretty_type(pp, unwrapped_fields1362) + pretty_type(pp, unwrapped_fields1367) dedent!(pp) write(pp, ")") end @@ -3551,35 +3555,35 @@ function pretty_sum_monoid(pp::PrettyPrinter, msg::Proto.SumMonoid) end function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) - flat1371 = try_flat(pp, msg, pretty_monus_def) - if !isnothing(flat1371) - write(pp, flat1371) + flat1376 = try_flat(pp, msg, pretty_monus_def) + if !isnothing(flat1376) + write(pp, flat1376) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.attrs) - _t1817 = _dollar_dollar.attrs + _t1827 = _dollar_dollar.attrs else - _t1817 = nothing + _t1827 = nothing end - fields1364 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1817,) - unwrapped_fields1365 = fields1364 + fields1369 = (_dollar_dollar.monoid, _dollar_dollar.name, (_dollar_dollar.body, _dollar_dollar.value_arity,), _t1827,) + unwrapped_fields1370 = fields1369 write(pp, "(monus") indent_sexp!(pp) newline(pp) - field1366 = unwrapped_fields1365[1] - pretty_monoid(pp, field1366) + field1371 = unwrapped_fields1370[1] + pretty_monoid(pp, field1371) newline(pp) - field1367 = unwrapped_fields1365[2] - pretty_relation_id(pp, field1367) + field1372 = unwrapped_fields1370[2] + pretty_relation_id(pp, field1372) newline(pp) - field1368 = unwrapped_fields1365[3] - pretty_abstraction_with_arity(pp, field1368) - field1369 = unwrapped_fields1365[4] - if !isnothing(field1369) + field1373 = unwrapped_fields1370[3] + pretty_abstraction_with_arity(pp, field1373) + field1374 = unwrapped_fields1370[4] + if !isnothing(field1374) newline(pp) - opt_val1370 = field1369 - pretty_attrs(pp, opt_val1370) + opt_val1375 = field1374 + pretty_attrs(pp, opt_val1375) end dedent!(pp) write(pp, ")") @@ -3588,28 +3592,28 @@ function pretty_monus_def(pp::PrettyPrinter, msg::Proto.MonusDef) end function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) - flat1378 = try_flat(pp, msg, pretty_constraint) - if !isnothing(flat1378) - write(pp, flat1378) + flat1383 = try_flat(pp, msg, pretty_constraint) + if !isnothing(flat1383) + write(pp, flat1383) return nothing else _dollar_dollar = msg - fields1372 = (_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_fields1373 = fields1372 + fields1377 = (_dollar_dollar.name, _get_oneof_field(_dollar_dollar, :functional_dependency).guard, _get_oneof_field(_dollar_dollar, :functional_dependency).keys, _get_oneof_field(_dollar_dollar, :functional_dependency).values,) + unwrapped_fields1378 = fields1377 write(pp, "(functional_dependency") indent_sexp!(pp) newline(pp) - field1374 = unwrapped_fields1373[1] - pretty_relation_id(pp, field1374) + field1379 = unwrapped_fields1378[1] + pretty_relation_id(pp, field1379) newline(pp) - field1375 = unwrapped_fields1373[2] - pretty_abstraction(pp, field1375) + field1380 = unwrapped_fields1378[2] + pretty_abstraction(pp, field1380) newline(pp) - field1376 = unwrapped_fields1373[3] - pretty_functional_dependency_keys(pp, field1376) + field1381 = unwrapped_fields1378[3] + pretty_functional_dependency_keys(pp, field1381) newline(pp) - field1377 = unwrapped_fields1373[4] - pretty_functional_dependency_values(pp, field1377) + field1382 = unwrapped_fields1378[4] + pretty_functional_dependency_values(pp, field1382) dedent!(pp) write(pp, ")") end @@ -3617,22 +3621,22 @@ function pretty_constraint(pp::PrettyPrinter, msg::Proto.Constraint) end function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1382 = try_flat(pp, msg, pretty_functional_dependency_keys) - if !isnothing(flat1382) - write(pp, flat1382) + flat1387 = try_flat(pp, msg, pretty_functional_dependency_keys) + if !isnothing(flat1387) + write(pp, flat1387) return nothing else - fields1379 = msg + fields1384 = msg write(pp, "(keys") indent_sexp!(pp) - if !isempty(fields1379) + if !isempty(fields1384) newline(pp) - for (i1818, elem1380) in enumerate(fields1379) - i1381 = i1818 - 1 - if (i1381 > 0) + for (i1828, elem1385) in enumerate(fields1384) + i1386 = i1828 - 1 + if (i1386 > 0) newline(pp) end - pretty_var(pp, elem1380) + pretty_var(pp, elem1385) end end dedent!(pp) @@ -3642,22 +3646,22 @@ function pretty_functional_dependency_keys(pp::PrettyPrinter, msg::Vector{Proto. end function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Proto.Var}) - flat1386 = try_flat(pp, msg, pretty_functional_dependency_values) - if !isnothing(flat1386) - write(pp, flat1386) + flat1391 = try_flat(pp, msg, pretty_functional_dependency_values) + if !isnothing(flat1391) + write(pp, flat1391) return nothing else - fields1383 = msg + fields1388 = msg write(pp, "(values") indent_sexp!(pp) - if !isempty(fields1383) + if !isempty(fields1388) newline(pp) - for (i1819, elem1384) in enumerate(fields1383) - i1385 = i1819 - 1 - if (i1385 > 0) + for (i1829, elem1389) in enumerate(fields1388) + i1390 = i1829 - 1 + if (i1390 > 0) newline(pp) end - pretty_var(pp, elem1384) + pretty_var(pp, elem1389) end end dedent!(pp) @@ -3667,54 +3671,54 @@ function pretty_functional_dependency_values(pp::PrettyPrinter, msg::Vector{Prot end function pretty_data(pp::PrettyPrinter, msg::Proto.Data) - flat1395 = try_flat(pp, msg, pretty_data) - if !isnothing(flat1395) - write(pp, flat1395) + flat1400 = try_flat(pp, msg, pretty_data) + if !isnothing(flat1400) + write(pp, flat1400) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("edb")) - _t1820 = _get_oneof_field(_dollar_dollar, :edb) + _t1830 = _get_oneof_field(_dollar_dollar, :edb) else - _t1820 = nothing + _t1830 = nothing end - deconstruct_result1393 = _t1820 - if !isnothing(deconstruct_result1393) - unwrapped1394 = deconstruct_result1393 - pretty_edb(pp, unwrapped1394) + deconstruct_result1398 = _t1830 + if !isnothing(deconstruct_result1398) + unwrapped1399 = deconstruct_result1398 + pretty_edb(pp, unwrapped1399) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("betree_relation")) - _t1821 = _get_oneof_field(_dollar_dollar, :betree_relation) + _t1831 = _get_oneof_field(_dollar_dollar, :betree_relation) else - _t1821 = nothing + _t1831 = nothing end - deconstruct_result1391 = _t1821 - if !isnothing(deconstruct_result1391) - unwrapped1392 = deconstruct_result1391 - pretty_betree_relation(pp, unwrapped1392) + deconstruct_result1396 = _t1831 + if !isnothing(deconstruct_result1396) + unwrapped1397 = deconstruct_result1396 + pretty_betree_relation(pp, unwrapped1397) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_data")) - _t1822 = _get_oneof_field(_dollar_dollar, :csv_data) + _t1832 = _get_oneof_field(_dollar_dollar, :csv_data) else - _t1822 = nothing + _t1832 = nothing end - deconstruct_result1389 = _t1822 - if !isnothing(deconstruct_result1389) - unwrapped1390 = deconstruct_result1389 - pretty_csv_data(pp, unwrapped1390) + deconstruct_result1394 = _t1832 + if !isnothing(deconstruct_result1394) + unwrapped1395 = deconstruct_result1394 + pretty_csv_data(pp, unwrapped1395) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_data")) - _t1823 = _get_oneof_field(_dollar_dollar, :iceberg_data) + _t1833 = _get_oneof_field(_dollar_dollar, :iceberg_data) else - _t1823 = nothing + _t1833 = nothing end - deconstruct_result1387 = _t1823 - if !isnothing(deconstruct_result1387) - unwrapped1388 = deconstruct_result1387 - pretty_iceberg_data(pp, unwrapped1388) + deconstruct_result1392 = _t1833 + if !isnothing(deconstruct_result1392) + unwrapped1393 = deconstruct_result1392 + pretty_iceberg_data(pp, unwrapped1393) else throw(ParseError("No matching rule for data")) end @@ -3726,25 +3730,25 @@ function pretty_data(pp::PrettyPrinter, msg::Proto.Data) end function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) - flat1401 = try_flat(pp, msg, pretty_edb) - if !isnothing(flat1401) - write(pp, flat1401) + flat1406 = try_flat(pp, msg, pretty_edb) + if !isnothing(flat1406) + write(pp, flat1406) return nothing else _dollar_dollar = msg - fields1396 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - unwrapped_fields1397 = fields1396 + fields1401 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) + unwrapped_fields1402 = fields1401 write(pp, "(edb") indent_sexp!(pp) newline(pp) - field1398 = unwrapped_fields1397[1] - pretty_relation_id(pp, field1398) + field1403 = unwrapped_fields1402[1] + pretty_relation_id(pp, field1403) newline(pp) - field1399 = unwrapped_fields1397[2] - pretty_edb_path(pp, field1399) + field1404 = unwrapped_fields1402[2] + pretty_edb_path(pp, field1404) newline(pp) - field1400 = unwrapped_fields1397[3] - pretty_edb_types(pp, field1400) + field1405 = unwrapped_fields1402[3] + pretty_edb_types(pp, field1405) dedent!(pp) write(pp, ")") end @@ -3752,20 +3756,20 @@ function pretty_edb(pp::PrettyPrinter, msg::Proto.EDB) end function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) - flat1405 = try_flat(pp, msg, pretty_edb_path) - if !isnothing(flat1405) - write(pp, flat1405) + flat1410 = try_flat(pp, msg, pretty_edb_path) + if !isnothing(flat1410) + write(pp, flat1410) return nothing else - fields1402 = msg + fields1407 = msg write(pp, "[") indent!(pp) - for (i1824, elem1403) in enumerate(fields1402) - i1404 = i1824 - 1 - if (i1404 > 0) + for (i1834, elem1408) in enumerate(fields1407) + i1409 = i1834 - 1 + if (i1409 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1403)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1408)) end dedent!(pp) write(pp, "]") @@ -3774,20 +3778,20 @@ function pretty_edb_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1409 = try_flat(pp, msg, pretty_edb_types) - if !isnothing(flat1409) - write(pp, flat1409) + flat1414 = try_flat(pp, msg, pretty_edb_types) + if !isnothing(flat1414) + write(pp, flat1414) return nothing else - fields1406 = msg + fields1411 = msg write(pp, "[") indent!(pp) - for (i1825, elem1407) in enumerate(fields1406) - i1408 = i1825 - 1 - if (i1408 > 0) + for (i1835, elem1412) in enumerate(fields1411) + i1413 = i1835 - 1 + if (i1413 > 0) newline(pp) end - pretty_type(pp, elem1407) + pretty_type(pp, elem1412) end dedent!(pp) write(pp, "]") @@ -3796,22 +3800,22 @@ function pretty_edb_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) end function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) - flat1414 = try_flat(pp, msg, pretty_betree_relation) - if !isnothing(flat1414) - write(pp, flat1414) + flat1419 = try_flat(pp, msg, pretty_betree_relation) + if !isnothing(flat1419) + write(pp, flat1419) return nothing else _dollar_dollar = msg - fields1410 = (_dollar_dollar.name, _dollar_dollar.relation_info,) - unwrapped_fields1411 = fields1410 + fields1415 = (_dollar_dollar.name, _dollar_dollar.relation_info,) + unwrapped_fields1416 = fields1415 write(pp, "(betree_relation") indent_sexp!(pp) newline(pp) - field1412 = unwrapped_fields1411[1] - pretty_relation_id(pp, field1412) + field1417 = unwrapped_fields1416[1] + pretty_relation_id(pp, field1417) newline(pp) - field1413 = unwrapped_fields1411[2] - pretty_betree_info(pp, field1413) + field1418 = unwrapped_fields1416[2] + pretty_betree_info(pp, field1418) dedent!(pp) write(pp, ")") end @@ -3819,26 +3823,26 @@ function pretty_betree_relation(pp::PrettyPrinter, msg::Proto.BeTreeRelation) end function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) - flat1420 = try_flat(pp, msg, pretty_betree_info) - if !isnothing(flat1420) - write(pp, flat1420) + flat1425 = try_flat(pp, msg, pretty_betree_info) + if !isnothing(flat1425) + write(pp, flat1425) return nothing else _dollar_dollar = msg - _t1826 = deconstruct_betree_info_config(pp, _dollar_dollar) - fields1415 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1826,) - unwrapped_fields1416 = fields1415 + _t1836 = deconstruct_betree_info_config(pp, _dollar_dollar) + fields1420 = (_dollar_dollar.key_types, _dollar_dollar.value_types, _t1836,) + unwrapped_fields1421 = fields1420 write(pp, "(betree_info") indent_sexp!(pp) newline(pp) - field1417 = unwrapped_fields1416[1] - pretty_betree_info_key_types(pp, field1417) + field1422 = unwrapped_fields1421[1] + pretty_betree_info_key_types(pp, field1422) newline(pp) - field1418 = unwrapped_fields1416[2] - pretty_betree_info_value_types(pp, field1418) + field1423 = unwrapped_fields1421[2] + pretty_betree_info_value_types(pp, field1423) newline(pp) - field1419 = unwrapped_fields1416[3] - pretty_config_dict(pp, field1419) + field1424 = unwrapped_fields1421[3] + pretty_config_dict(pp, field1424) dedent!(pp) write(pp, ")") end @@ -3846,22 +3850,22 @@ function pretty_betree_info(pp::PrettyPrinter, msg::Proto.BeTreeInfo) end function pretty_betree_info_key_types(pp::PrettyPrinter, msg::Vector{Proto.var"#Type"}) - flat1424 = try_flat(pp, msg, pretty_betree_info_key_types) - if !isnothing(flat1424) - write(pp, flat1424) + flat1429 = try_flat(pp, msg, pretty_betree_info_key_types) + if !isnothing(flat1429) + write(pp, flat1429) return nothing else - fields1421 = msg + fields1426 = msg write(pp, "(key_types") indent_sexp!(pp) - if !isempty(fields1421) + if !isempty(fields1426) newline(pp) - for (i1827, elem1422) in enumerate(fields1421) - i1423 = i1827 - 1 - if (i1423 > 0) + for (i1837, elem1427) in enumerate(fields1426) + i1428 = i1837 - 1 + if (i1428 > 0) newline(pp) end - pretty_type(pp, elem1422) + pretty_type(pp, elem1427) end end dedent!(pp) @@ -3871,22 +3875,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"}) - flat1428 = try_flat(pp, msg, pretty_betree_info_value_types) - if !isnothing(flat1428) - write(pp, flat1428) + flat1433 = try_flat(pp, msg, pretty_betree_info_value_types) + if !isnothing(flat1433) + write(pp, flat1433) return nothing else - fields1425 = msg + fields1430 = msg write(pp, "(value_types") indent_sexp!(pp) - if !isempty(fields1425) + if !isempty(fields1430) newline(pp) - for (i1828, elem1426) in enumerate(fields1425) - i1427 = i1828 - 1 - if (i1427 > 0) + for (i1838, elem1431) in enumerate(fields1430) + i1432 = i1838 - 1 + if (i1432 > 0) newline(pp) end - pretty_type(pp, elem1426) + pretty_type(pp, elem1431) end end dedent!(pp) @@ -3896,39 +3900,39 @@ function pretty_betree_info_value_types(pp::PrettyPrinter, msg::Vector{Proto.var end function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) - flat1438 = try_flat(pp, msg, pretty_csv_data) - if !isnothing(flat1438) - write(pp, flat1438) + flat1443 = try_flat(pp, msg, pretty_csv_data) + if !isnothing(flat1443) + write(pp, flat1443) return nothing else _dollar_dollar = msg - _t1829 = deconstruct_csv_data_columns_optional(pp, _dollar_dollar) - _t1830 = deconstruct_csv_data_relations_optional(pp, _dollar_dollar) - fields1429 = (_dollar_dollar.locator, _dollar_dollar.config, _t1829, _t1830, _dollar_dollar.asof,) - unwrapped_fields1430 = fields1429 + _t1839 = deconstruct_csv_data_columns_optional(pp, _dollar_dollar) + _t1840 = deconstruct_csv_data_relations_optional(pp, _dollar_dollar) + fields1434 = (_dollar_dollar.locator, _dollar_dollar.config, _t1839, _t1840, _dollar_dollar.asof,) + unwrapped_fields1435 = fields1434 write(pp, "(csv_data") indent_sexp!(pp) newline(pp) - field1431 = unwrapped_fields1430[1] - pretty_csvlocator(pp, field1431) + field1436 = unwrapped_fields1435[1] + pretty_csvlocator(pp, field1436) newline(pp) - field1432 = unwrapped_fields1430[2] - pretty_csv_config(pp, field1432) - field1433 = unwrapped_fields1430[3] - if !isnothing(field1433) + field1437 = unwrapped_fields1435[2] + pretty_csv_config(pp, field1437) + field1438 = unwrapped_fields1435[3] + if !isnothing(field1438) newline(pp) - opt_val1434 = field1433 - pretty_gnf_columns(pp, opt_val1434) + opt_val1439 = field1438 + pretty_gnf_columns(pp, opt_val1439) end - field1435 = unwrapped_fields1430[4] - if !isnothing(field1435) + field1440 = unwrapped_fields1435[4] + if !isnothing(field1440) newline(pp) - opt_val1436 = field1435 - pretty_target_relations(pp, opt_val1436) + opt_val1441 = field1440 + pretty_target_relations(pp, opt_val1441) end newline(pp) - field1437 = unwrapped_fields1430[5] - pretty_csv_asof(pp, field1437) + field1442 = unwrapped_fields1435[5] + pretty_csv_asof(pp, field1442) dedent!(pp) write(pp, ")") end @@ -3936,37 +3940,37 @@ function pretty_csv_data(pp::PrettyPrinter, msg::Proto.CSVData) end function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) - flat1445 = try_flat(pp, msg, pretty_csvlocator) - if !isnothing(flat1445) - write(pp, flat1445) + flat1450 = try_flat(pp, msg, pretty_csvlocator) + if !isnothing(flat1450) + write(pp, flat1450) return nothing else _dollar_dollar = msg if !isempty(_dollar_dollar.paths) - _t1831 = _dollar_dollar.paths + _t1841 = _dollar_dollar.paths else - _t1831 = nothing + _t1841 = nothing end if String(copy(_dollar_dollar.inline_data)) != "" - _t1832 = String(copy(_dollar_dollar.inline_data)) + _t1842 = String(copy(_dollar_dollar.inline_data)) else - _t1832 = nothing + _t1842 = nothing end - fields1439 = (_t1831, _t1832,) - unwrapped_fields1440 = fields1439 + fields1444 = (_t1841, _t1842,) + unwrapped_fields1445 = fields1444 write(pp, "(csv_locator") indent_sexp!(pp) - field1441 = unwrapped_fields1440[1] - if !isnothing(field1441) + field1446 = unwrapped_fields1445[1] + if !isnothing(field1446) newline(pp) - opt_val1442 = field1441 - pretty_csv_locator_paths(pp, opt_val1442) + opt_val1447 = field1446 + pretty_csv_locator_paths(pp, opt_val1447) end - field1443 = unwrapped_fields1440[2] - if !isnothing(field1443) + field1448 = unwrapped_fields1445[2] + if !isnothing(field1448) newline(pp) - opt_val1444 = field1443 - pretty_csv_locator_inline_data(pp, opt_val1444) + opt_val1449 = field1448 + pretty_csv_locator_inline_data(pp, opt_val1449) end dedent!(pp) write(pp, ")") @@ -3975,22 +3979,22 @@ function pretty_csvlocator(pp::PrettyPrinter, msg::Proto.CSVLocator) end function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) - flat1449 = try_flat(pp, msg, pretty_csv_locator_paths) - if !isnothing(flat1449) - write(pp, flat1449) + flat1454 = try_flat(pp, msg, pretty_csv_locator_paths) + if !isnothing(flat1454) + write(pp, flat1454) return nothing else - fields1446 = msg + fields1451 = msg write(pp, "(paths") indent_sexp!(pp) - if !isempty(fields1446) + if !isempty(fields1451) newline(pp) - for (i1833, elem1447) in enumerate(fields1446) - i1448 = i1833 - 1 - if (i1448 > 0) + for (i1843, elem1452) in enumerate(fields1451) + i1453 = i1843 - 1 + if (i1453 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1447)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1452)) end end dedent!(pp) @@ -4000,16 +4004,16 @@ function pretty_csv_locator_paths(pp::PrettyPrinter, msg::Vector{String}) end function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) - flat1451 = try_flat(pp, msg, pretty_csv_locator_inline_data) - if !isnothing(flat1451) - write(pp, flat1451) + flat1456 = try_flat(pp, msg, pretty_csv_locator_inline_data) + if !isnothing(flat1456) + write(pp, flat1456) return nothing else - fields1450 = msg + fields1455 = msg write(pp, "(inline_data") indent_sexp!(pp) newline(pp) - write(pp, format_string(pp, fields1450)) + write(pp, format_string(pp, fields1455)) dedent!(pp) write(pp, ")") end @@ -4017,26 +4021,26 @@ function pretty_csv_locator_inline_data(pp::PrettyPrinter, msg::String) end function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) - flat1457 = try_flat(pp, msg, pretty_csv_config) - if !isnothing(flat1457) - write(pp, flat1457) + flat1462 = try_flat(pp, msg, pretty_csv_config) + if !isnothing(flat1462) + write(pp, flat1462) return nothing else _dollar_dollar = msg - _t1834 = deconstruct_csv_config(pp, _dollar_dollar) - _t1835 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) - fields1452 = (_t1834, _t1835,) - unwrapped_fields1453 = fields1452 + _t1844 = deconstruct_csv_config(pp, _dollar_dollar) + _t1845 = deconstruct_csv_storage_integration_optional(pp, _dollar_dollar) + fields1457 = (_t1844, _t1845,) + unwrapped_fields1458 = fields1457 write(pp, "(csv_config") indent_sexp!(pp) newline(pp) - field1454 = unwrapped_fields1453[1] - pretty_config_dict(pp, field1454) - field1455 = unwrapped_fields1453[2] - if !isnothing(field1455) + field1459 = unwrapped_fields1458[1] + pretty_config_dict(pp, field1459) + field1460 = unwrapped_fields1458[2] + if !isnothing(field1460) newline(pp) - opt_val1456 = field1455 - pretty__storage_integration(pp, opt_val1456) + opt_val1461 = field1460 + pretty__storage_integration(pp, opt_val1461) end dedent!(pp) write(pp, ")") @@ -4045,16 +4049,16 @@ function pretty_csv_config(pp::PrettyPrinter, msg::Proto.CSVConfig) end function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String, Proto.Value}}) - flat1459 = try_flat(pp, msg, pretty__storage_integration) - if !isnothing(flat1459) - write(pp, flat1459) + flat1464 = try_flat(pp, msg, pretty__storage_integration) + if !isnothing(flat1464) + write(pp, flat1464) return nothing else - fields1458 = msg + fields1463 = msg write(pp, "(storage_integration") indent_sexp!(pp) newline(pp) - pretty_config_dict(pp, fields1458) + pretty_config_dict(pp, fields1463) dedent!(pp) write(pp, ")") end @@ -4062,22 +4066,22 @@ function pretty__storage_integration(pp::PrettyPrinter, msg::Vector{Tuple{String end function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) - flat1463 = try_flat(pp, msg, pretty_gnf_columns) - if !isnothing(flat1463) - write(pp, flat1463) + flat1468 = try_flat(pp, msg, pretty_gnf_columns) + if !isnothing(flat1468) + write(pp, flat1468) return nothing else - fields1460 = msg + fields1465 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1460) + if !isempty(fields1465) newline(pp) - for (i1836, elem1461) in enumerate(fields1460) - i1462 = i1836 - 1 - if (i1462 > 0) + for (i1846, elem1466) in enumerate(fields1465) + i1467 = i1846 - 1 + if (i1467 > 0) newline(pp) end - pretty_gnf_column(pp, elem1461) + pretty_gnf_column(pp, elem1466) end end dedent!(pp) @@ -4087,39 +4091,39 @@ function pretty_gnf_columns(pp::PrettyPrinter, msg::Vector{Proto.GNFColumn}) end function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) - flat1472 = try_flat(pp, msg, pretty_gnf_column) - if !isnothing(flat1472) - write(pp, flat1472) + flat1477 = try_flat(pp, msg, pretty_gnf_column) + if !isnothing(flat1477) + write(pp, flat1477) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("target_id")) - _t1837 = _dollar_dollar.target_id + _t1847 = _dollar_dollar.target_id else - _t1837 = nothing + _t1847 = nothing end - fields1464 = (_dollar_dollar.column_path, _t1837, _dollar_dollar.types,) - unwrapped_fields1465 = fields1464 + fields1469 = (_dollar_dollar.column_path, _t1847, _dollar_dollar.types,) + unwrapped_fields1470 = fields1469 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1466 = unwrapped_fields1465[1] - pretty_gnf_column_path(pp, field1466) - field1467 = unwrapped_fields1465[2] - if !isnothing(field1467) + field1471 = unwrapped_fields1470[1] + pretty_gnf_column_path(pp, field1471) + field1472 = unwrapped_fields1470[2] + if !isnothing(field1472) newline(pp) - opt_val1468 = field1467 - pretty_relation_id(pp, opt_val1468) + opt_val1473 = field1472 + pretty_relation_id(pp, opt_val1473) end newline(pp) write(pp, "[") - field1469 = unwrapped_fields1465[3] - for (i1838, elem1470) in enumerate(field1469) - i1471 = i1838 - 1 - if (i1471 > 0) + field1474 = unwrapped_fields1470[3] + for (i1848, elem1475) in enumerate(field1474) + i1476 = i1848 - 1 + if (i1476 > 0) newline(pp) end - pretty_type(pp, elem1470) + pretty_type(pp, elem1475) end write(pp, "]") dedent!(pp) @@ -4129,39 +4133,39 @@ function pretty_gnf_column(pp::PrettyPrinter, msg::Proto.GNFColumn) end function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) - flat1479 = try_flat(pp, msg, pretty_gnf_column_path) - if !isnothing(flat1479) - write(pp, flat1479) + flat1484 = try_flat(pp, msg, pretty_gnf_column_path) + if !isnothing(flat1484) + write(pp, flat1484) return nothing else _dollar_dollar = msg if length(_dollar_dollar) == 1 - _t1839 = _dollar_dollar[1] + _t1849 = _dollar_dollar[1] else - _t1839 = nothing + _t1849 = nothing end - deconstruct_result1477 = _t1839 - if !isnothing(deconstruct_result1477) - unwrapped1478 = deconstruct_result1477 - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1478)) + deconstruct_result1482 = _t1849 + if !isnothing(deconstruct_result1482) + unwrapped1483 = deconstruct_result1482 + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1483)) else _dollar_dollar = msg if length(_dollar_dollar) != 1 - _t1840 = _dollar_dollar + _t1850 = _dollar_dollar else - _t1840 = nothing + _t1850 = nothing end - deconstruct_result1473 = _t1840 - if !isnothing(deconstruct_result1473) - unwrapped1474 = deconstruct_result1473 + deconstruct_result1478 = _t1850 + if !isnothing(deconstruct_result1478) + unwrapped1479 = deconstruct_result1478 write(pp, "[") indent!(pp) - for (i1841, elem1475) in enumerate(unwrapped1474) - i1476 = i1841 - 1 - if (i1476 > 0) + for (i1851, elem1480) in enumerate(unwrapped1479) + i1481 = i1851 - 1 + if (i1481 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1475)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1480)) end dedent!(pp) write(pp, "]") @@ -4174,22 +4178,22 @@ function pretty_gnf_column_path(pp::PrettyPrinter, msg::Vector{String}) end function pretty_target_relations(pp::PrettyPrinter, msg::Proto.TargetRelations) - flat1484 = try_flat(pp, msg, pretty_target_relations) - if !isnothing(flat1484) - write(pp, flat1484) + flat1489 = try_flat(pp, msg, pretty_target_relations) + if !isnothing(flat1489) + write(pp, flat1489) return nothing else _dollar_dollar = msg - fields1480 = (_dollar_dollar.keys, _dollar_dollar,) - unwrapped_fields1481 = fields1480 + fields1485 = (_dollar_dollar.keys, _dollar_dollar,) + unwrapped_fields1486 = fields1485 write(pp, "(relations") indent_sexp!(pp) newline(pp) - field1482 = unwrapped_fields1481[1] - pretty_relation_keys(pp, field1482) + field1487 = unwrapped_fields1486[1] + pretty_relation_keys(pp, field1487) newline(pp) - field1483 = unwrapped_fields1481[2] - pretty_relation_body(pp, field1483) + field1488 = unwrapped_fields1486[2] + pretty_relation_body(pp, field1488) dedent!(pp) write(pp, ")") end @@ -4197,22 +4201,22 @@ function pretty_target_relations(pp::PrettyPrinter, msg::Proto.TargetRelations) end function pretty_relation_keys(pp::PrettyPrinter, msg::Vector{Proto.NamedColumn}) - flat1488 = try_flat(pp, msg, pretty_relation_keys) - if !isnothing(flat1488) - write(pp, flat1488) + flat1493 = try_flat(pp, msg, pretty_relation_keys) + if !isnothing(flat1493) + write(pp, flat1493) return nothing else - fields1485 = msg + fields1490 = msg write(pp, "(keys") indent_sexp!(pp) - if !isempty(fields1485) + if !isempty(fields1490) newline(pp) - for (i1842, elem1486) in enumerate(fields1485) - i1487 = i1842 - 1 - if (i1487 > 0) + for (i1852, elem1491) in enumerate(fields1490) + i1492 = i1852 - 1 + if (i1492 > 0) newline(pp) end - pretty_named_column(pp, elem1486) + pretty_named_column(pp, elem1491) end end dedent!(pp) @@ -4222,22 +4226,22 @@ function pretty_relation_keys(pp::PrettyPrinter, msg::Vector{Proto.NamedColumn}) end function pretty_named_column(pp::PrettyPrinter, msg::Proto.NamedColumn) - flat1493 = try_flat(pp, msg, pretty_named_column) - if !isnothing(flat1493) - write(pp, flat1493) + flat1498 = try_flat(pp, msg, pretty_named_column) + if !isnothing(flat1498) + write(pp, flat1498) return nothing else _dollar_dollar = msg - fields1489 = (_dollar_dollar.name, _dollar_dollar.var"#type",) - unwrapped_fields1490 = fields1489 + fields1494 = (_dollar_dollar.name, _dollar_dollar.var"#type",) + unwrapped_fields1495 = fields1494 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1491 = unwrapped_fields1490[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1491)) + field1496 = unwrapped_fields1495[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1496)) newline(pp) - field1492 = unwrapped_fields1490[2] - pretty_type(pp, field1492) + field1497 = unwrapped_fields1495[2] + pretty_type(pp, field1497) dedent!(pp) write(pp, ")") end @@ -4245,36 +4249,36 @@ function pretty_named_column(pp::PrettyPrinter, msg::Proto.NamedColumn) end function pretty_relation_body(pp::PrettyPrinter, msg::Proto.TargetRelations) - flat1500 = try_flat(pp, msg, pretty_relation_body) - if !isnothing(flat1500) - write(pp, flat1500) + flat1505 = try_flat(pp, msg, pretty_relation_body) + if !isnothing(flat1505) + write(pp, flat1505) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("plain")) - _t1843 = _get_oneof_field(_dollar_dollar, :plain).targets + _t1853 = _get_oneof_field(_dollar_dollar, :plain).targets else - _t1843 = nothing + _t1853 = nothing end - deconstruct_result1498 = _t1843 - if !isnothing(deconstruct_result1498) - unwrapped1499 = deconstruct_result1498 - pretty_non_cdc_relations(pp, unwrapped1499) + deconstruct_result1503 = _t1853 + if !isnothing(deconstruct_result1503) + unwrapped1504 = deconstruct_result1503 + pretty_non_cdc_relations(pp, unwrapped1504) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("cdc")) - _t1844 = (_get_oneof_field(_dollar_dollar, :cdc).inserts, _get_oneof_field(_dollar_dollar, :cdc).deletes,) + _t1854 = (_get_oneof_field(_dollar_dollar, :cdc).inserts, _get_oneof_field(_dollar_dollar, :cdc).deletes,) else - _t1844 = nothing + _t1854 = nothing end - deconstruct_result1494 = _t1844 - if !isnothing(deconstruct_result1494) - unwrapped1495 = deconstruct_result1494 - field1496 = unwrapped1495[1] - pretty_cdc_inserts(pp, field1496) + deconstruct_result1499 = _t1854 + if !isnothing(deconstruct_result1499) + unwrapped1500 = deconstruct_result1499 + field1501 = unwrapped1500[1] + pretty_cdc_inserts(pp, field1501) write(pp, " ") - field1497 = unwrapped1495[2] - pretty_cdc_deletes(pp, field1497) + field1502 = unwrapped1500[2] + pretty_cdc_deletes(pp, field1502) else throw(ParseError("No matching rule for relation_body")) end @@ -4284,46 +4288,46 @@ function pretty_relation_body(pp::PrettyPrinter, msg::Proto.TargetRelations) end function pretty_non_cdc_relations(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation}) - flat1504 = try_flat(pp, msg, pretty_non_cdc_relations) - if !isnothing(flat1504) - write(pp, flat1504) + flat1509 = try_flat(pp, msg, pretty_non_cdc_relations) + if !isnothing(flat1509) + write(pp, flat1509) return nothing else - fields1501 = msg - for (i1845, elem1502) in enumerate(fields1501) - i1503 = i1845 - 1 - if (i1503 > 0) + fields1506 = msg + for (i1855, elem1507) in enumerate(fields1506) + i1508 = i1855 - 1 + if (i1508 > 0) newline(pp) end - pretty_target_relation(pp, elem1502) + pretty_target_relation(pp, elem1507) end end return nothing end function pretty_target_relation(pp::PrettyPrinter, msg::Proto.TargetRelation) - flat1511 = try_flat(pp, msg, pretty_target_relation) - if !isnothing(flat1511) - write(pp, flat1511) + flat1516 = try_flat(pp, msg, pretty_target_relation) + if !isnothing(flat1516) + write(pp, flat1516) return nothing else _dollar_dollar = msg - fields1505 = (_dollar_dollar.target_id, _dollar_dollar.values,) - unwrapped_fields1506 = fields1505 + fields1510 = (_dollar_dollar.target_id, _dollar_dollar.values,) + unwrapped_fields1511 = fields1510 write(pp, "(relation") indent_sexp!(pp) newline(pp) - field1507 = unwrapped_fields1506[1] - pretty_relation_id(pp, field1507) - field1508 = unwrapped_fields1506[2] - if !isempty(field1508) + field1512 = unwrapped_fields1511[1] + pretty_relation_id(pp, field1512) + field1513 = unwrapped_fields1511[2] + if !isempty(field1513) newline(pp) - for (i1846, elem1509) in enumerate(field1508) - i1510 = i1846 - 1 - if (i1510 > 0) + for (i1856, elem1514) in enumerate(field1513) + i1515 = i1856 - 1 + if (i1515 > 0) newline(pp) end - pretty_named_column(pp, elem1509) + pretty_named_column(pp, elem1514) end end dedent!(pp) @@ -4333,22 +4337,22 @@ function pretty_target_relation(pp::PrettyPrinter, msg::Proto.TargetRelation) end function pretty_cdc_inserts(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation}) - flat1515 = try_flat(pp, msg, pretty_cdc_inserts) - if !isnothing(flat1515) - write(pp, flat1515) + flat1520 = try_flat(pp, msg, pretty_cdc_inserts) + if !isnothing(flat1520) + write(pp, flat1520) return nothing else - fields1512 = msg + fields1517 = msg write(pp, "(inserts") indent_sexp!(pp) - if !isempty(fields1512) + if !isempty(fields1517) newline(pp) - for (i1847, elem1513) in enumerate(fields1512) - i1514 = i1847 - 1 - if (i1514 > 0) + for (i1857, elem1518) in enumerate(fields1517) + i1519 = i1857 - 1 + if (i1519 > 0) newline(pp) end - pretty_target_relation(pp, elem1513) + pretty_target_relation(pp, elem1518) end end dedent!(pp) @@ -4358,22 +4362,22 @@ function pretty_cdc_inserts(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation} end function pretty_cdc_deletes(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation}) - flat1519 = try_flat(pp, msg, pretty_cdc_deletes) - if !isnothing(flat1519) - write(pp, flat1519) + flat1524 = try_flat(pp, msg, pretty_cdc_deletes) + if !isnothing(flat1524) + write(pp, flat1524) return nothing else - fields1516 = msg + fields1521 = msg write(pp, "(deletes") indent_sexp!(pp) - if !isempty(fields1516) + if !isempty(fields1521) newline(pp) - for (i1848, elem1517) in enumerate(fields1516) - i1518 = i1848 - 1 - if (i1518 > 0) + for (i1858, elem1522) in enumerate(fields1521) + i1523 = i1858 - 1 + if (i1523 > 0) newline(pp) end - pretty_target_relation(pp, elem1517) + pretty_target_relation(pp, elem1522) end end dedent!(pp) @@ -4383,16 +4387,16 @@ function pretty_cdc_deletes(pp::PrettyPrinter, msg::Vector{Proto.TargetRelation} end function pretty_csv_asof(pp::PrettyPrinter, msg::String) - flat1521 = try_flat(pp, msg, pretty_csv_asof) - if !isnothing(flat1521) - write(pp, flat1521) + flat1526 = try_flat(pp, msg, pretty_csv_asof) + if !isnothing(flat1526) + write(pp, flat1526) return nothing else - fields1520 = msg + fields1525 = msg write(pp, "(asof") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1520)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1525)) dedent!(pp) write(pp, ")") end @@ -4400,42 +4404,42 @@ function pretty_csv_asof(pp::PrettyPrinter, msg::String) end function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) - flat1532 = try_flat(pp, msg, pretty_iceberg_data) - if !isnothing(flat1532) - write(pp, flat1532) + flat1537 = try_flat(pp, msg, pretty_iceberg_data) + if !isnothing(flat1537) + write(pp, flat1537) return nothing else _dollar_dollar = msg - _t1849 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) - _t1850 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) - fields1522 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1849, _t1850, _dollar_dollar.returns_delta,) - unwrapped_fields1523 = fields1522 + _t1859 = deconstruct_iceberg_data_from_snapshot_optional(pp, _dollar_dollar) + _t1860 = deconstruct_iceberg_data_to_snapshot_optional(pp, _dollar_dollar) + fields1527 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.columns, _t1859, _t1860, _dollar_dollar.returns_delta,) + unwrapped_fields1528 = fields1527 write(pp, "(iceberg_data") indent_sexp!(pp) newline(pp) - field1524 = unwrapped_fields1523[1] - pretty_iceberg_locator(pp, field1524) + field1529 = unwrapped_fields1528[1] + pretty_iceberg_locator(pp, field1529) newline(pp) - field1525 = unwrapped_fields1523[2] - pretty_iceberg_catalog_config(pp, field1525) + field1530 = unwrapped_fields1528[2] + pretty_iceberg_catalog_config(pp, field1530) newline(pp) - field1526 = unwrapped_fields1523[3] - pretty_gnf_columns(pp, field1526) - field1527 = unwrapped_fields1523[4] - if !isnothing(field1527) + field1531 = unwrapped_fields1528[3] + pretty_gnf_columns(pp, field1531) + field1532 = unwrapped_fields1528[4] + if !isnothing(field1532) newline(pp) - opt_val1528 = field1527 - pretty_iceberg_from_snapshot(pp, opt_val1528) + opt_val1533 = field1532 + pretty_iceberg_from_snapshot(pp, opt_val1533) end - field1529 = unwrapped_fields1523[5] - if !isnothing(field1529) + field1534 = unwrapped_fields1528[5] + if !isnothing(field1534) newline(pp) - opt_val1530 = field1529 - pretty_iceberg_to_snapshot(pp, opt_val1530) + opt_val1535 = field1534 + pretty_iceberg_to_snapshot(pp, opt_val1535) end newline(pp) - field1531 = unwrapped_fields1523[6] - pretty_boolean_value(pp, field1531) + field1536 = unwrapped_fields1528[6] + pretty_boolean_value(pp, field1536) dedent!(pp) write(pp, ")") end @@ -4443,25 +4447,25 @@ function pretty_iceberg_data(pp::PrettyPrinter, msg::Proto.IcebergData) end function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) - flat1538 = try_flat(pp, msg, pretty_iceberg_locator) - if !isnothing(flat1538) - write(pp, flat1538) + flat1543 = try_flat(pp, msg, pretty_iceberg_locator) + if !isnothing(flat1543) + write(pp, flat1543) return nothing else _dollar_dollar = msg - fields1533 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) - unwrapped_fields1534 = fields1533 + fields1538 = (_dollar_dollar.table_name, _dollar_dollar.namespace, _dollar_dollar.warehouse,) + unwrapped_fields1539 = fields1538 write(pp, "(iceberg_locator") indent_sexp!(pp) newline(pp) - field1535 = unwrapped_fields1534[1] - pretty_iceberg_locator_table_name(pp, field1535) + field1540 = unwrapped_fields1539[1] + pretty_iceberg_locator_table_name(pp, field1540) newline(pp) - field1536 = unwrapped_fields1534[2] - pretty_iceberg_locator_namespace(pp, field1536) + field1541 = unwrapped_fields1539[2] + pretty_iceberg_locator_namespace(pp, field1541) newline(pp) - field1537 = unwrapped_fields1534[3] - pretty_iceberg_locator_warehouse(pp, field1537) + field1542 = unwrapped_fields1539[3] + pretty_iceberg_locator_warehouse(pp, field1542) dedent!(pp) write(pp, ")") end @@ -4469,16 +4473,16 @@ function pretty_iceberg_locator(pp::PrettyPrinter, msg::Proto.IcebergLocator) end function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) - flat1540 = try_flat(pp, msg, pretty_iceberg_locator_table_name) - if !isnothing(flat1540) - write(pp, flat1540) + flat1545 = try_flat(pp, msg, pretty_iceberg_locator_table_name) + if !isnothing(flat1545) + write(pp, flat1545) return nothing else - fields1539 = msg + fields1544 = msg write(pp, "(table_name") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1539)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1544)) dedent!(pp) write(pp, ")") end @@ -4486,22 +4490,22 @@ function pretty_iceberg_locator_table_name(pp::PrettyPrinter, msg::String) end function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String}) - flat1544 = try_flat(pp, msg, pretty_iceberg_locator_namespace) - if !isnothing(flat1544) - write(pp, flat1544) + flat1549 = try_flat(pp, msg, pretty_iceberg_locator_namespace) + if !isnothing(flat1549) + write(pp, flat1549) return nothing else - fields1541 = msg + fields1546 = msg write(pp, "(namespace") indent_sexp!(pp) - if !isempty(fields1541) + if !isempty(fields1546) newline(pp) - for (i1851, elem1542) in enumerate(fields1541) - i1543 = i1851 - 1 - if (i1543 > 0) + for (i1861, elem1547) in enumerate(fields1546) + i1548 = i1861 - 1 + if (i1548 > 0) newline(pp) end - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1542)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, elem1547)) end end dedent!(pp) @@ -4511,16 +4515,16 @@ function pretty_iceberg_locator_namespace(pp::PrettyPrinter, msg::Vector{String} end function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) - flat1546 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) - if !isnothing(flat1546) - write(pp, flat1546) + flat1551 = try_flat(pp, msg, pretty_iceberg_locator_warehouse) + if !isnothing(flat1551) + write(pp, flat1551) return nothing else - fields1545 = msg + fields1550 = msg write(pp, "(warehouse") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1545)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1550)) dedent!(pp) write(pp, ")") end @@ -4528,32 +4532,32 @@ function pretty_iceberg_locator_warehouse(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCatalogConfig) - flat1554 = try_flat(pp, msg, pretty_iceberg_catalog_config) - if !isnothing(flat1554) - write(pp, flat1554) + flat1559 = try_flat(pp, msg, pretty_iceberg_catalog_config) + if !isnothing(flat1559) + write(pp, flat1559) return nothing else _dollar_dollar = msg - _t1852 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) - fields1547 = (_dollar_dollar.catalog_uri, _t1852, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) - unwrapped_fields1548 = fields1547 + _t1862 = deconstruct_iceberg_catalog_config_scope_optional(pp, _dollar_dollar) + fields1552 = (_dollar_dollar.catalog_uri, _t1862, sort([(k, v) for (k, v) in _dollar_dollar.properties]), sort([(k, v) for (k, v) in _dollar_dollar.auth_properties]),) + unwrapped_fields1553 = fields1552 write(pp, "(iceberg_catalog_config") indent_sexp!(pp) newline(pp) - field1549 = unwrapped_fields1548[1] - pretty_iceberg_catalog_uri(pp, field1549) - field1550 = unwrapped_fields1548[2] - if !isnothing(field1550) + field1554 = unwrapped_fields1553[1] + pretty_iceberg_catalog_uri(pp, field1554) + field1555 = unwrapped_fields1553[2] + if !isnothing(field1555) newline(pp) - opt_val1551 = field1550 - pretty_iceberg_catalog_config_scope(pp, opt_val1551) + opt_val1556 = field1555 + pretty_iceberg_catalog_config_scope(pp, opt_val1556) end newline(pp) - field1552 = unwrapped_fields1548[3] - pretty_iceberg_properties(pp, field1552) + field1557 = unwrapped_fields1553[3] + pretty_iceberg_properties(pp, field1557) newline(pp) - field1553 = unwrapped_fields1548[4] - pretty_iceberg_auth_properties(pp, field1553) + field1558 = unwrapped_fields1553[4] + pretty_iceberg_auth_properties(pp, field1558) dedent!(pp) write(pp, ")") end @@ -4561,16 +4565,16 @@ function pretty_iceberg_catalog_config(pp::PrettyPrinter, msg::Proto.IcebergCata end function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) - flat1556 = try_flat(pp, msg, pretty_iceberg_catalog_uri) - if !isnothing(flat1556) - write(pp, flat1556) + flat1561 = try_flat(pp, msg, pretty_iceberg_catalog_uri) + if !isnothing(flat1561) + write(pp, flat1561) return nothing else - fields1555 = msg + fields1560 = msg write(pp, "(catalog_uri") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1555)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1560)) dedent!(pp) write(pp, ")") end @@ -4578,16 +4582,16 @@ function pretty_iceberg_catalog_uri(pp::PrettyPrinter, msg::String) end function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) - flat1558 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) - if !isnothing(flat1558) - write(pp, flat1558) + flat1563 = try_flat(pp, msg, pretty_iceberg_catalog_config_scope) + if !isnothing(flat1563) + write(pp, flat1563) return nothing else - fields1557 = msg + fields1562 = msg write(pp, "(scope") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1557)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1562)) dedent!(pp) write(pp, ")") end @@ -4595,22 +4599,22 @@ function pretty_iceberg_catalog_config_scope(pp::PrettyPrinter, msg::String) end function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, String}}) - flat1562 = try_flat(pp, msg, pretty_iceberg_properties) - if !isnothing(flat1562) - write(pp, flat1562) + flat1567 = try_flat(pp, msg, pretty_iceberg_properties) + if !isnothing(flat1567) + write(pp, flat1567) return nothing else - fields1559 = msg + fields1564 = msg write(pp, "(properties") indent_sexp!(pp) - if !isempty(fields1559) + if !isempty(fields1564) newline(pp) - for (i1853, elem1560) in enumerate(fields1559) - i1561 = i1853 - 1 - if (i1561 > 0) + for (i1863, elem1565) in enumerate(fields1564) + i1566 = i1863 - 1 + if (i1566 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1560) + pretty_iceberg_property_entry(pp, elem1565) end end dedent!(pp) @@ -4620,22 +4624,22 @@ function pretty_iceberg_properties(pp::PrettyPrinter, msg::Vector{Tuple{String, end function pretty_iceberg_property_entry(pp::PrettyPrinter, msg::Tuple{String, String}) - flat1567 = try_flat(pp, msg, pretty_iceberg_property_entry) - if !isnothing(flat1567) - write(pp, flat1567) + flat1572 = try_flat(pp, msg, pretty_iceberg_property_entry) + if !isnothing(flat1572) + write(pp, flat1572) return nothing else _dollar_dollar = msg - fields1563 = (_dollar_dollar[1], _dollar_dollar[2],) - unwrapped_fields1564 = fields1563 + fields1568 = (_dollar_dollar[1], _dollar_dollar[2],) + unwrapped_fields1569 = fields1568 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1565 = unwrapped_fields1564[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1565)) + field1570 = unwrapped_fields1569[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1570)) newline(pp) - field1566 = unwrapped_fields1564[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1566)) + field1571 = unwrapped_fields1569[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1571)) dedent!(pp) write(pp, ")") end @@ -4643,22 +4647,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}}) - flat1571 = try_flat(pp, msg, pretty_iceberg_auth_properties) - if !isnothing(flat1571) - write(pp, flat1571) + flat1576 = try_flat(pp, msg, pretty_iceberg_auth_properties) + if !isnothing(flat1576) + write(pp, flat1576) return nothing else - fields1568 = msg + fields1573 = msg write(pp, "(auth_properties") indent_sexp!(pp) - if !isempty(fields1568) + if !isempty(fields1573) newline(pp) - for (i1854, elem1569) in enumerate(fields1568) - i1570 = i1854 - 1 - if (i1570 > 0) + for (i1864, elem1574) in enumerate(fields1573) + i1575 = i1864 - 1 + if (i1575 > 0) newline(pp) end - pretty_iceberg_masked_property_entry(pp, elem1569) + pretty_iceberg_masked_property_entry(pp, elem1574) end end dedent!(pp) @@ -4668,23 +4672,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}) - flat1576 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) - if !isnothing(flat1576) - write(pp, flat1576) + flat1581 = try_flat(pp, msg, pretty_iceberg_masked_property_entry) + if !isnothing(flat1581) + write(pp, flat1581) return nothing else _dollar_dollar = msg - _t1855 = mask_secret_value(pp, _dollar_dollar) - fields1572 = (_dollar_dollar[1], _t1855,) - unwrapped_fields1573 = fields1572 + _t1865 = mask_secret_value(pp, _dollar_dollar) + fields1577 = (_dollar_dollar[1], _t1865,) + unwrapped_fields1578 = fields1577 write(pp, "(prop") indent_sexp!(pp) newline(pp) - field1574 = unwrapped_fields1573[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1574)) + field1579 = unwrapped_fields1578[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1579)) newline(pp) - field1575 = unwrapped_fields1573[2] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1575)) + field1580 = unwrapped_fields1578[2] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1580)) dedent!(pp) write(pp, ")") end @@ -4692,16 +4696,16 @@ function pretty_iceberg_masked_property_entry(pp::PrettyPrinter, msg::Tuple{Stri end function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) - flat1578 = try_flat(pp, msg, pretty_iceberg_from_snapshot) - if !isnothing(flat1578) - write(pp, flat1578) + flat1583 = try_flat(pp, msg, pretty_iceberg_from_snapshot) + if !isnothing(flat1583) + write(pp, flat1583) return nothing else - fields1577 = msg + fields1582 = msg write(pp, "(from_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1577)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1582)) dedent!(pp) write(pp, ")") end @@ -4709,16 +4713,16 @@ function pretty_iceberg_from_snapshot(pp::PrettyPrinter, msg::String) end function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) - flat1580 = try_flat(pp, msg, pretty_iceberg_to_snapshot) - if !isnothing(flat1580) - write(pp, flat1580) + flat1585 = try_flat(pp, msg, pretty_iceberg_to_snapshot) + if !isnothing(flat1585) + write(pp, flat1585) return nothing else - fields1579 = msg + fields1584 = msg write(pp, "(to_snapshot") indent_sexp!(pp) newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1579)) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1584)) dedent!(pp) write(pp, ")") end @@ -4726,18 +4730,18 @@ function pretty_iceberg_to_snapshot(pp::PrettyPrinter, msg::String) end function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) - flat1583 = try_flat(pp, msg, pretty_undefine) - if !isnothing(flat1583) - write(pp, flat1583) + flat1588 = try_flat(pp, msg, pretty_undefine) + if !isnothing(flat1588) + write(pp, flat1588) return nothing else _dollar_dollar = msg - fields1581 = _dollar_dollar.fragment_id - unwrapped_fields1582 = fields1581 + fields1586 = _dollar_dollar.fragment_id + unwrapped_fields1587 = fields1586 write(pp, "(undefine") indent_sexp!(pp) newline(pp) - pretty_fragment_id(pp, unwrapped_fields1582) + pretty_fragment_id(pp, unwrapped_fields1587) dedent!(pp) write(pp, ")") end @@ -4745,24 +4749,24 @@ function pretty_undefine(pp::PrettyPrinter, msg::Proto.Undefine) end function pretty_context(pp::PrettyPrinter, msg::Proto.Context) - flat1588 = try_flat(pp, msg, pretty_context) - if !isnothing(flat1588) - write(pp, flat1588) + flat1593 = try_flat(pp, msg, pretty_context) + if !isnothing(flat1593) + write(pp, flat1593) return nothing else _dollar_dollar = msg - fields1584 = _dollar_dollar.relations - unwrapped_fields1585 = fields1584 + fields1589 = _dollar_dollar.relations + unwrapped_fields1590 = fields1589 write(pp, "(context") indent_sexp!(pp) - if !isempty(unwrapped_fields1585) + if !isempty(unwrapped_fields1590) newline(pp) - for (i1856, elem1586) in enumerate(unwrapped_fields1585) - i1587 = i1856 - 1 - if (i1587 > 0) + for (i1866, elem1591) in enumerate(unwrapped_fields1590) + i1592 = i1866 - 1 + if (i1592 > 0) newline(pp) end - pretty_relation_id(pp, elem1586) + pretty_relation_id(pp, elem1591) end end dedent!(pp) @@ -4772,28 +4776,28 @@ function pretty_context(pp::PrettyPrinter, msg::Proto.Context) end function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) - flat1595 = try_flat(pp, msg, pretty_snapshot) - if !isnothing(flat1595) - write(pp, flat1595) + flat1600 = try_flat(pp, msg, pretty_snapshot) + if !isnothing(flat1600) + write(pp, flat1600) return nothing else _dollar_dollar = msg - fields1589 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) - unwrapped_fields1590 = fields1589 + fields1594 = (_dollar_dollar.prefix, _dollar_dollar.mappings,) + unwrapped_fields1595 = fields1594 write(pp, "(snapshot") indent_sexp!(pp) newline(pp) - field1591 = unwrapped_fields1590[1] - pretty_edb_path(pp, field1591) - field1592 = unwrapped_fields1590[2] - if !isempty(field1592) + field1596 = unwrapped_fields1595[1] + pretty_edb_path(pp, field1596) + field1597 = unwrapped_fields1595[2] + if !isempty(field1597) newline(pp) - for (i1857, elem1593) in enumerate(field1592) - i1594 = i1857 - 1 - if (i1594 > 0) + for (i1867, elem1598) in enumerate(field1597) + i1599 = i1867 - 1 + if (i1599 > 0) newline(pp) end - pretty_snapshot_mapping(pp, elem1593) + pretty_snapshot_mapping(pp, elem1598) end end dedent!(pp) @@ -4803,40 +4807,40 @@ function pretty_snapshot(pp::PrettyPrinter, msg::Proto.Snapshot) end function pretty_snapshot_mapping(pp::PrettyPrinter, msg::Proto.SnapshotMapping) - flat1600 = try_flat(pp, msg, pretty_snapshot_mapping) - if !isnothing(flat1600) - write(pp, flat1600) + flat1605 = try_flat(pp, msg, pretty_snapshot_mapping) + if !isnothing(flat1605) + write(pp, flat1605) return nothing else _dollar_dollar = msg - fields1596 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) - unwrapped_fields1597 = fields1596 - field1598 = unwrapped_fields1597[1] - pretty_edb_path(pp, field1598) + fields1601 = (_dollar_dollar.destination_path, _dollar_dollar.source_relation,) + unwrapped_fields1602 = fields1601 + field1603 = unwrapped_fields1602[1] + pretty_edb_path(pp, field1603) write(pp, " ") - field1599 = unwrapped_fields1597[2] - pretty_relation_id(pp, field1599) + field1604 = unwrapped_fields1602[2] + pretty_relation_id(pp, field1604) end return nothing end function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) - flat1604 = try_flat(pp, msg, pretty_epoch_reads) - if !isnothing(flat1604) - write(pp, flat1604) + flat1609 = try_flat(pp, msg, pretty_epoch_reads) + if !isnothing(flat1609) + write(pp, flat1609) return nothing else - fields1601 = msg + fields1606 = msg write(pp, "(reads") indent_sexp!(pp) - if !isempty(fields1601) + if !isempty(fields1606) newline(pp) - for (i1858, elem1602) in enumerate(fields1601) - i1603 = i1858 - 1 - if (i1603 > 0) + for (i1868, elem1607) in enumerate(fields1606) + i1608 = i1868 - 1 + if (i1608 > 0) newline(pp) end - pretty_read(pp, elem1602) + pretty_read(pp, elem1607) end end dedent!(pp) @@ -4846,65 +4850,65 @@ function pretty_epoch_reads(pp::PrettyPrinter, msg::Vector{Proto.Read}) end function pretty_read(pp::PrettyPrinter, msg::Proto.Read) - flat1615 = try_flat(pp, msg, pretty_read) - if !isnothing(flat1615) - write(pp, flat1615) + flat1620 = try_flat(pp, msg, pretty_read) + if !isnothing(flat1620) + write(pp, flat1620) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("demand")) - _t1859 = _get_oneof_field(_dollar_dollar, :demand) + _t1869 = _get_oneof_field(_dollar_dollar, :demand) else - _t1859 = nothing + _t1869 = nothing end - deconstruct_result1613 = _t1859 - if !isnothing(deconstruct_result1613) - unwrapped1614 = deconstruct_result1613 - pretty_demand(pp, unwrapped1614) + deconstruct_result1618 = _t1869 + if !isnothing(deconstruct_result1618) + unwrapped1619 = deconstruct_result1618 + pretty_demand(pp, unwrapped1619) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("output")) - _t1860 = _get_oneof_field(_dollar_dollar, :output) + _t1870 = _get_oneof_field(_dollar_dollar, :output) else - _t1860 = nothing + _t1870 = nothing end - deconstruct_result1611 = _t1860 - if !isnothing(deconstruct_result1611) - unwrapped1612 = deconstruct_result1611 - pretty_output(pp, unwrapped1612) + deconstruct_result1616 = _t1870 + if !isnothing(deconstruct_result1616) + unwrapped1617 = deconstruct_result1616 + pretty_output(pp, unwrapped1617) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("what_if")) - _t1861 = _get_oneof_field(_dollar_dollar, :what_if) + _t1871 = _get_oneof_field(_dollar_dollar, :what_if) else - _t1861 = nothing + _t1871 = nothing end - deconstruct_result1609 = _t1861 - if !isnothing(deconstruct_result1609) - unwrapped1610 = deconstruct_result1609 - pretty_what_if(pp, unwrapped1610) + deconstruct_result1614 = _t1871 + if !isnothing(deconstruct_result1614) + unwrapped1615 = deconstruct_result1614 + pretty_what_if(pp, unwrapped1615) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("abort")) - _t1862 = _get_oneof_field(_dollar_dollar, :abort) + _t1872 = _get_oneof_field(_dollar_dollar, :abort) else - _t1862 = nothing + _t1872 = nothing end - deconstruct_result1607 = _t1862 - if !isnothing(deconstruct_result1607) - unwrapped1608 = deconstruct_result1607 - pretty_abort(pp, unwrapped1608) + deconstruct_result1612 = _t1872 + if !isnothing(deconstruct_result1612) + unwrapped1613 = deconstruct_result1612 + pretty_abort(pp, unwrapped1613) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("#export")) - _t1863 = _get_oneof_field(_dollar_dollar, :var"#export") + _t1873 = _get_oneof_field(_dollar_dollar, :var"#export") else - _t1863 = nothing + _t1873 = nothing end - deconstruct_result1605 = _t1863 - if !isnothing(deconstruct_result1605) - unwrapped1606 = deconstruct_result1605 - pretty_export(pp, unwrapped1606) + deconstruct_result1610 = _t1873 + if !isnothing(deconstruct_result1610) + unwrapped1611 = deconstruct_result1610 + pretty_export(pp, unwrapped1611) else throw(ParseError("No matching rule for read")) end @@ -4917,18 +4921,18 @@ function pretty_read(pp::PrettyPrinter, msg::Proto.Read) end function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) - flat1618 = try_flat(pp, msg, pretty_demand) - if !isnothing(flat1618) - write(pp, flat1618) + flat1623 = try_flat(pp, msg, pretty_demand) + if !isnothing(flat1623) + write(pp, flat1623) return nothing else _dollar_dollar = msg - fields1616 = _dollar_dollar.relation_id - unwrapped_fields1617 = fields1616 + fields1621 = _dollar_dollar.relation_id + unwrapped_fields1622 = fields1621 write(pp, "(demand") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped_fields1617) + pretty_relation_id(pp, unwrapped_fields1622) dedent!(pp) write(pp, ")") end @@ -4936,22 +4940,22 @@ function pretty_demand(pp::PrettyPrinter, msg::Proto.Demand) end function pretty_output(pp::PrettyPrinter, msg::Proto.Output) - flat1623 = try_flat(pp, msg, pretty_output) - if !isnothing(flat1623) - write(pp, flat1623) + flat1628 = try_flat(pp, msg, pretty_output) + if !isnothing(flat1628) + write(pp, flat1628) return nothing else _dollar_dollar = msg - fields1619 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - unwrapped_fields1620 = fields1619 + fields1624 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + unwrapped_fields1625 = fields1624 write(pp, "(output") indent_sexp!(pp) newline(pp) - field1621 = unwrapped_fields1620[1] - pretty_name(pp, field1621) + field1626 = unwrapped_fields1625[1] + pretty_name(pp, field1626) newline(pp) - field1622 = unwrapped_fields1620[2] - pretty_relation_id(pp, field1622) + field1627 = unwrapped_fields1625[2] + pretty_relation_id(pp, field1627) dedent!(pp) write(pp, ")") end @@ -4959,22 +4963,22 @@ function pretty_output(pp::PrettyPrinter, msg::Proto.Output) end function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) - flat1628 = try_flat(pp, msg, pretty_what_if) - if !isnothing(flat1628) - write(pp, flat1628) + flat1633 = try_flat(pp, msg, pretty_what_if) + if !isnothing(flat1633) + write(pp, flat1633) return nothing else _dollar_dollar = msg - fields1624 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - unwrapped_fields1625 = fields1624 + fields1629 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + unwrapped_fields1630 = fields1629 write(pp, "(what_if") indent_sexp!(pp) newline(pp) - field1626 = unwrapped_fields1625[1] - pretty_name(pp, field1626) + field1631 = unwrapped_fields1630[1] + pretty_name(pp, field1631) newline(pp) - field1627 = unwrapped_fields1625[2] - pretty_epoch(pp, field1627) + field1632 = unwrapped_fields1630[2] + pretty_epoch(pp, field1632) dedent!(pp) write(pp, ")") end @@ -4982,30 +4986,30 @@ function pretty_what_if(pp::PrettyPrinter, msg::Proto.WhatIf) end function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) - flat1634 = try_flat(pp, msg, pretty_abort) - if !isnothing(flat1634) - write(pp, flat1634) + flat1639 = try_flat(pp, msg, pretty_abort) + if !isnothing(flat1639) + write(pp, flat1639) return nothing else _dollar_dollar = msg if _dollar_dollar.name != "abort" - _t1864 = _dollar_dollar.name + _t1874 = _dollar_dollar.name else - _t1864 = nothing + _t1874 = nothing end - fields1629 = (_t1864, _dollar_dollar.relation_id,) - unwrapped_fields1630 = fields1629 + fields1634 = (_t1874, _dollar_dollar.relation_id,) + unwrapped_fields1635 = fields1634 write(pp, "(abort") indent_sexp!(pp) - field1631 = unwrapped_fields1630[1] - if !isnothing(field1631) + field1636 = unwrapped_fields1635[1] + if !isnothing(field1636) newline(pp) - opt_val1632 = field1631 - pretty_name(pp, opt_val1632) + opt_val1637 = field1636 + pretty_name(pp, opt_val1637) end newline(pp) - field1633 = unwrapped_fields1630[2] - pretty_relation_id(pp, field1633) + field1638 = unwrapped_fields1635[2] + pretty_relation_id(pp, field1638) dedent!(pp) write(pp, ")") end @@ -5013,40 +5017,40 @@ function pretty_abort(pp::PrettyPrinter, msg::Proto.Abort) end function pretty_export(pp::PrettyPrinter, msg::Proto.Export) - flat1639 = try_flat(pp, msg, pretty_export) - if !isnothing(flat1639) - write(pp, flat1639) + flat1644 = try_flat(pp, msg, pretty_export) + if !isnothing(flat1644) + write(pp, flat1644) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("csv_config")) - _t1865 = _get_oneof_field(_dollar_dollar, :csv_config) + _t1875 = _get_oneof_field(_dollar_dollar, :csv_config) else - _t1865 = nothing + _t1875 = nothing end - deconstruct_result1637 = _t1865 - if !isnothing(deconstruct_result1637) - unwrapped1638 = deconstruct_result1637 + deconstruct_result1642 = _t1875 + if !isnothing(deconstruct_result1642) + unwrapped1643 = deconstruct_result1642 write(pp, "(export") indent_sexp!(pp) newline(pp) - pretty_export_csv_config(pp, unwrapped1638) + pretty_export_csv_config(pp, unwrapped1643) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("iceberg_config")) - _t1866 = _get_oneof_field(_dollar_dollar, :iceberg_config) + _t1876 = _get_oneof_field(_dollar_dollar, :iceberg_config) else - _t1866 = nothing + _t1876 = nothing end - deconstruct_result1635 = _t1866 - if !isnothing(deconstruct_result1635) - unwrapped1636 = deconstruct_result1635 + deconstruct_result1640 = _t1876 + if !isnothing(deconstruct_result1640) + unwrapped1641 = deconstruct_result1640 write(pp, "(export_iceberg") indent_sexp!(pp) newline(pp) - pretty_export_iceberg_config(pp, unwrapped1636) + pretty_export_iceberg_config(pp, unwrapped1641) dedent!(pp) write(pp, ")") else @@ -5058,55 +5062,56 @@ function pretty_export(pp::PrettyPrinter, msg::Proto.Export) end function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) - flat1650 = try_flat(pp, msg, pretty_export_csv_config) - if !isnothing(flat1650) - write(pp, flat1650) + flat1655 = try_flat(pp, msg, pretty_export_csv_config) + if !isnothing(flat1655) + write(pp, flat1655) return nothing else _dollar_dollar = msg if length(_dollar_dollar.data_columns) == 0 - _t1867 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1878 = deconstruct_export_csv_output_location(pp, _dollar_dollar) + _t1877 = (_t1878, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) else - _t1867 = nothing + _t1877 = nothing end - deconstruct_result1645 = _t1867 - if !isnothing(deconstruct_result1645) - unwrapped1646 = deconstruct_result1645 + deconstruct_result1650 = _t1877 + if !isnothing(deconstruct_result1650) + unwrapped1651 = deconstruct_result1650 write(pp, "(export_csv_config_v2") indent_sexp!(pp) newline(pp) - field1647 = unwrapped1646[1] - pretty_export_csv_path(pp, field1647) + field1652 = unwrapped1651[1] + pretty_export_csv_output_location(pp, field1652) newline(pp) - field1648 = unwrapped1646[2] - pretty_export_csv_source(pp, field1648) + field1653 = unwrapped1651[2] + pretty_export_csv_source(pp, field1653) newline(pp) - field1649 = unwrapped1646[3] - pretty_csv_config(pp, field1649) + field1654 = unwrapped1651[3] + pretty_csv_config(pp, field1654) dedent!(pp) write(pp, ")") else _dollar_dollar = msg if length(_dollar_dollar.data_columns) != 0 - _t1869 = deconstruct_export_csv_config(pp, _dollar_dollar) - _t1868 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1869,) + _t1880 = deconstruct_export_csv_config(pp, _dollar_dollar) + _t1879 = (_dollar_dollar.path, _dollar_dollar.data_columns, _t1880,) else - _t1868 = nothing + _t1879 = nothing end - deconstruct_result1640 = _t1868 - if !isnothing(deconstruct_result1640) - unwrapped1641 = deconstruct_result1640 + deconstruct_result1645 = _t1879 + if !isnothing(deconstruct_result1645) + unwrapped1646 = deconstruct_result1645 write(pp, "(export_csv_config") indent_sexp!(pp) newline(pp) - field1642 = unwrapped1641[1] - pretty_export_csv_path(pp, field1642) + field1647 = unwrapped1646[1] + pretty_export_csv_path(pp, field1647) newline(pp) - field1643 = unwrapped1641[2] - pretty_export_csv_columns_list(pp, field1643) + field1648 = unwrapped1646[2] + pretty_export_csv_columns_list(pp, field1648) newline(pp) - field1644 = unwrapped1641[3] - pretty_config_dict(pp, field1644) + field1649 = unwrapped1646[3] + pretty_config_dict(pp, field1649) dedent!(pp) write(pp, ")") else @@ -5117,48 +5122,76 @@ function pretty_export_csv_config(pp::PrettyPrinter, msg::Proto.ExportCSVConfig) return nothing end -function pretty_export_csv_path(pp::PrettyPrinter, msg::String) - flat1652 = try_flat(pp, msg, pretty_export_csv_path) - if !isnothing(flat1652) - write(pp, flat1652) +function pretty_export_csv_output_location(pp::PrettyPrinter, msg::Tuple{String, String}) + flat1660 = try_flat(pp, msg, pretty_export_csv_output_location) + if !isnothing(flat1660) + write(pp, flat1660) return nothing else - fields1651 = msg - write(pp, "(path") - indent_sexp!(pp) - newline(pp) - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1651)) - dedent!(pp) - write(pp, ")") + _dollar_dollar = msg + if _dollar_dollar[1] != "" + _t1881 = _dollar_dollar[1] + else + _t1881 = nothing + end + deconstruct_result1658 = _t1881 + if !isnothing(deconstruct_result1658) + unwrapped1659 = deconstruct_result1658 + write(pp, "(path") + indent_sexp!(pp) + newline(pp) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, unwrapped1659)) + dedent!(pp) + write(pp, ")") + else + _dollar_dollar = msg + if _dollar_dollar[2] != "" + _t1882 = _dollar_dollar[2] + else + _t1882 = nothing + end + deconstruct_result1656 = _t1882 + if !isnothing(deconstruct_result1656) + unwrapped1657 = deconstruct_result1656 + write(pp, "(transaction_output_name") + indent_sexp!(pp) + newline(pp) + pretty_name(pp, unwrapped1657) + 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) - flat1659 = try_flat(pp, msg, pretty_export_csv_source) - if !isnothing(flat1659) - write(pp, flat1659) + flat1667 = try_flat(pp, msg, pretty_export_csv_source) + if !isnothing(flat1667) + write(pp, flat1667) return nothing else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("gnf_columns")) - _t1870 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns + _t1883 = _get_oneof_field(_dollar_dollar, :gnf_columns).columns else - _t1870 = nothing + _t1883 = nothing end - deconstruct_result1655 = _t1870 - if !isnothing(deconstruct_result1655) - unwrapped1656 = deconstruct_result1655 + deconstruct_result1663 = _t1883 + if !isnothing(deconstruct_result1663) + unwrapped1664 = deconstruct_result1663 write(pp, "(gnf_columns") indent_sexp!(pp) - if !isempty(unwrapped1656) + if !isempty(unwrapped1664) newline(pp) - for (i1871, elem1657) in enumerate(unwrapped1656) - i1658 = i1871 - 1 - if (i1658 > 0) + for (i1884, elem1665) in enumerate(unwrapped1664) + i1666 = i1884 - 1 + if (i1666 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1657) + pretty_export_csv_column(pp, elem1665) end end dedent!(pp) @@ -5166,17 +5199,17 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) else _dollar_dollar = msg if _has_proto_field(_dollar_dollar, Symbol("table_def")) - _t1872 = _get_oneof_field(_dollar_dollar, :table_def) + _t1885 = _get_oneof_field(_dollar_dollar, :table_def) else - _t1872 = nothing + _t1885 = nothing end - deconstruct_result1653 = _t1872 - if !isnothing(deconstruct_result1653) - unwrapped1654 = deconstruct_result1653 + deconstruct_result1661 = _t1885 + if !isnothing(deconstruct_result1661) + unwrapped1662 = deconstruct_result1661 write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, unwrapped1654) + pretty_relation_id(pp, unwrapped1662) dedent!(pp) write(pp, ")") else @@ -5188,22 +5221,39 @@ function pretty_export_csv_source(pp::PrettyPrinter, msg::Proto.ExportCSVSource) end function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) - flat1664 = try_flat(pp, msg, pretty_export_csv_column) - if !isnothing(flat1664) - write(pp, flat1664) + flat1672 = try_flat(pp, msg, pretty_export_csv_column) + if !isnothing(flat1672) + write(pp, flat1672) return nothing else _dollar_dollar = msg - fields1660 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - unwrapped_fields1661 = fields1660 + fields1668 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) + unwrapped_fields1669 = fields1668 write(pp, "(column") indent_sexp!(pp) newline(pp) - field1662 = unwrapped_fields1661[1] - write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1662)) + field1670 = unwrapped_fields1669[1] + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, field1670)) + newline(pp) + field1671 = unwrapped_fields1669[2] + pretty_relation_id(pp, field1671) + dedent!(pp) + write(pp, ")") + end + return nothing +end + +function pretty_export_csv_path(pp::PrettyPrinter, msg::String) + flat1674 = try_flat(pp, msg, pretty_export_csv_path) + if !isnothing(flat1674) + write(pp, flat1674) + return nothing + else + fields1673 = msg + write(pp, "(path") + indent_sexp!(pp) newline(pp) - field1663 = unwrapped_fields1661[2] - pretty_relation_id(pp, field1663) + write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, fields1673)) dedent!(pp) write(pp, ")") end @@ -5211,22 +5261,22 @@ function pretty_export_csv_column(pp::PrettyPrinter, msg::Proto.ExportCSVColumn) end function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.ExportCSVColumn}) - flat1668 = try_flat(pp, msg, pretty_export_csv_columns_list) - if !isnothing(flat1668) - write(pp, flat1668) + flat1678 = try_flat(pp, msg, pretty_export_csv_columns_list) + if !isnothing(flat1678) + write(pp, flat1678) return nothing else - fields1665 = msg + fields1675 = msg write(pp, "(columns") indent_sexp!(pp) - if !isempty(fields1665) + if !isempty(fields1675) newline(pp) - for (i1873, elem1666) in enumerate(fields1665) - i1667 = i1873 - 1 - if (i1667 > 0) + for (i1886, elem1676) in enumerate(fields1675) + i1677 = i1886 - 1 + if (i1677 > 0) newline(pp) end - pretty_export_csv_column(pp, elem1666) + pretty_export_csv_column(pp, elem1676) end end dedent!(pp) @@ -5236,34 +5286,34 @@ function pretty_export_csv_columns_list(pp::PrettyPrinter, msg::Vector{Proto.Exp end function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIcebergConfig) - flat1677 = try_flat(pp, msg, pretty_export_iceberg_config) - if !isnothing(flat1677) - write(pp, flat1677) + flat1687 = try_flat(pp, msg, pretty_export_iceberg_config) + if !isnothing(flat1687) + write(pp, flat1687) return nothing else _dollar_dollar = msg - _t1874 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) - fields1669 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1874,) - unwrapped_fields1670 = fields1669 + _t1887 = deconstruct_export_iceberg_config_optional(pp, _dollar_dollar) + fields1679 = (_dollar_dollar.locator, _dollar_dollar.config, _dollar_dollar.table_def, sort([(k, v) for (k, v) in _dollar_dollar.table_properties]), _t1887,) + unwrapped_fields1680 = fields1679 write(pp, "(export_iceberg_config") indent_sexp!(pp) newline(pp) - field1671 = unwrapped_fields1670[1] - pretty_iceberg_locator(pp, field1671) + field1681 = unwrapped_fields1680[1] + pretty_iceberg_locator(pp, field1681) newline(pp) - field1672 = unwrapped_fields1670[2] - pretty_iceberg_catalog_config(pp, field1672) + field1682 = unwrapped_fields1680[2] + pretty_iceberg_catalog_config(pp, field1682) newline(pp) - field1673 = unwrapped_fields1670[3] - pretty_export_iceberg_table_def(pp, field1673) + field1683 = unwrapped_fields1680[3] + pretty_export_iceberg_table_def(pp, field1683) newline(pp) - field1674 = unwrapped_fields1670[4] - pretty_iceberg_table_properties(pp, field1674) - field1675 = unwrapped_fields1670[5] - if !isnothing(field1675) + field1684 = unwrapped_fields1680[4] + pretty_iceberg_table_properties(pp, field1684) + field1685 = unwrapped_fields1680[5] + if !isnothing(field1685) newline(pp) - opt_val1676 = field1675 - pretty_config_dict(pp, opt_val1676) + opt_val1686 = field1685 + pretty_config_dict(pp, opt_val1686) end dedent!(pp) write(pp, ")") @@ -5272,16 +5322,16 @@ function pretty_export_iceberg_config(pp::PrettyPrinter, msg::Proto.ExportIceber end function pretty_export_iceberg_table_def(pp::PrettyPrinter, msg::Proto.RelationId) - flat1679 = try_flat(pp, msg, pretty_export_iceberg_table_def) - if !isnothing(flat1679) - write(pp, flat1679) + flat1689 = try_flat(pp, msg, pretty_export_iceberg_table_def) + if !isnothing(flat1689) + write(pp, flat1689) return nothing else - fields1678 = msg + fields1688 = msg write(pp, "(table_def") indent_sexp!(pp) newline(pp) - pretty_relation_id(pp, fields1678) + pretty_relation_id(pp, fields1688) dedent!(pp) write(pp, ")") end @@ -5289,22 +5339,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}}) - flat1683 = try_flat(pp, msg, pretty_iceberg_table_properties) - if !isnothing(flat1683) - write(pp, flat1683) + flat1693 = try_flat(pp, msg, pretty_iceberg_table_properties) + if !isnothing(flat1693) + write(pp, flat1693) return nothing else - fields1680 = msg + fields1690 = msg write(pp, "(table_properties") indent_sexp!(pp) - if !isempty(fields1680) + if !isempty(fields1690) newline(pp) - for (i1875, elem1681) in enumerate(fields1680) - i1682 = i1875 - 1 - if (i1682 > 0) + for (i1888, elem1691) in enumerate(fields1690) + i1692 = i1888 - 1 + if (i1692 > 0) newline(pp) end - pretty_iceberg_property_entry(pp, elem1681) + pretty_iceberg_property_entry(pp, elem1691) end end dedent!(pp) @@ -5319,12 +5369,12 @@ end function pretty_debug_info(pp::PrettyPrinter, msg::Proto.DebugInfo) write(pp, "(debug_info") indent_sexp!(pp) - for (i1929, _rid) in enumerate(msg.ids) - _idx = i1929 - 1 + for (i1942, _rid) in enumerate(msg.ids) + _idx = i1942 - 1 newline(pp) write(pp, "(") - _t1930 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) - _pprint_dispatch(pp, _t1930) + _t1943 = Proto.UInt128Value(low=_rid.id_low, high=_rid.id_high) + _pprint_dispatch(pp, _t1943) write(pp, " ") write(pp, format_string(DEFAULT_CONSTANT_FORMATTER, pp, msg.orig_names[_idx + 1])) write(pp, ")") @@ -5388,8 +5438,8 @@ function pretty_cdc_targets(pp::PrettyPrinter, msg::Proto.CDCTargets) indent_sexp!(pp) newline(pp) write(pp, ":inserts (") - for (i1931, _elem) in enumerate(msg.inserts) - _idx = i1931 - 1 + for (i1944, _elem) in enumerate(msg.inserts) + _idx = i1944 - 1 if (_idx > 0) write(pp, " ") end @@ -5398,8 +5448,8 @@ function pretty_cdc_targets(pp::PrettyPrinter, msg::Proto.CDCTargets) write(pp, ")") newline(pp) write(pp, ":deletes (") - for (i1932, _elem) in enumerate(msg.deletes) - _idx = i1932 - 1 + for (i1945, _elem) in enumerate(msg.deletes) + _idx = i1945 - 1 if (_idx > 0) write(pp, " ") end @@ -5423,8 +5473,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe _pprint_dispatch(pp, msg.guard) newline(pp) write(pp, ":keys (") - for (i1933, _elem) in enumerate(msg.keys) - _idx = i1933 - 1 + for (i1946, _elem) in enumerate(msg.keys) + _idx = i1946 - 1 if (_idx > 0) write(pp, " ") end @@ -5433,8 +5483,8 @@ function pretty_functional_dependency(pp::PrettyPrinter, msg::Proto.FunctionalDe write(pp, ")") newline(pp) write(pp, ":values (") - for (i1934, _elem) in enumerate(msg.values) - _idx = i1934 - 1 + for (i1947, _elem) in enumerate(msg.values) + _idx = i1947 - 1 if (_idx > 0) write(pp, " ") end @@ -5460,8 +5510,8 @@ function pretty_plain_targets(pp::PrettyPrinter, msg::Proto.PlainTargets) indent_sexp!(pp) newline(pp) write(pp, ":targets (") - for (i1935, _elem) in enumerate(msg.targets) - _idx = i1935 - 1 + for (i1948, _elem) in enumerate(msg.targets) + _idx = i1948 - 1 if (_idx > 0) write(pp, " ") end @@ -5505,8 +5555,8 @@ function pretty_export_csv_columns(pp::PrettyPrinter, msg::Proto.ExportCSVColumn indent_sexp!(pp) newline(pp) write(pp, ":columns (") - for (i1936, _elem) in enumerate(msg.columns) - _idx = i1936 - 1 + for (i1949, _elem) in enumerate(msg.columns) + _idx = i1949 - 1 if (_idx > 0) write(pp, " ") end diff --git a/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl b/sdks/julia/LogicalQueryProtocol.jl/test/equality_tests.jl index 18704f0a..b48cbed6 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 diff --git a/sdks/python/src/lqp/gen/parser.py b/sdks/python/src/lqp/gen/parser.py index b5d19c9c..f8d74db1 100644 --- a/sdks/python/src/lqp/gen/parser.py +++ b/sdks/python/src/lqp/gen/parser.py @@ -424,219 +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 - _t2187 = value.HasField("int32_value") + _t2199 = 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 + _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 - _t2189 = value.HasField("int_value") + _t2201 = 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 + _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 - _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 + _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 - _t2193 = value.HasField("boolean_value") + _t2205 = 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 + _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 - _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 + _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 - _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 + _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 - _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 + _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 - _t2201 = value.HasField("string_value") + _t2213 = 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 + _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 - _t2203 = value.HasField("uint128_value") + _t2215 = value.HasField("uint128_value") else: - _t2203 = False - if _t2203: + _t2215 = False + if _t2215: assert value is not None return value.uint128_value else: - _t2204 = None + _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) - _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 + _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: - _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 + _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) @@ -653,3520 +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 - _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 + _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) - _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 + _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: + _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) - _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 + _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: - 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 + _t1417 = self.parse_sync() + _t1416 = _t1417 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 + _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(")") - _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 + _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 + _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 prediction721 == 11: + 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 + 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(")") - _t1472 = transactions_pb2.Sync(fragments=fragment_ids754) - result756 = _t1472 - self.record_span(span_start755, "Sync") - return result756 + _t1478 = transactions_pb2.Sync(fragments=fragment_ids757) + result759 = _t1478 + self.record_span(span_start758, "Sync") + return result759 def parse_fragment_id(self) -> fragments_pb2.FragmentId: - span_start758 = self.span_start() + span_start761 = self.span_start() self.consume_literal(":") - symbol757 = self.consume_terminal("SYMBOL") - result759 = fragments_pb2.FragmentId(id=symbol757.encode()) - self.record_span(span_start758, "FragmentId") - return result759 + 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: - 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 + _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") - 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 + _t1489 = -1 + _t1488 = _t1489 + _t1487 = _t1488 + _t1486 = _t1487 + _t1485 = _t1486 else: - _t1479 = -1 - prediction768 = _t1479 - if prediction768 == 3: - _t1485 = self.parse_snapshot() - snapshot772 = _t1485 - _t1486 = transactions_pb2.Write(snapshot=snapshot772) - _t1484 = _t1486 + _t1485 = -1 + prediction771 = _t1485 + if prediction771 == 3: + _t1491 = self.parse_snapshot() + snapshot775 = _t1491 + _t1492 = transactions_pb2.Write(snapshot=snapshot775) + _t1490 = _t1492 else: - if prediction768 == 2: - _t1488 = self.parse_context() - context771 = _t1488 - _t1489 = transactions_pb2.Write(context=context771) - _t1487 = _t1489 + 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 + _t1496 = _t1499 + _t1493 = _t1496 + _t1490 = _t1493 + result777 = _t1490 + self.record_span(span_start776, "Write") + return result777 def parse_define(self) -> transactions_pb2.Define: - span_start776 = self.span_start() + span_start779 = self.span_start() self.consume_literal("(") self.consume_literal("define") - _t1496 = self.parse_fragment() - fragment775 = _t1496 + _t1502 = self.parse_fragment() + fragment778 = _t1502 self.consume_literal(")") - _t1497 = transactions_pb2.Define(fragment=fragment775) - result777 = _t1497 - self.record_span(span_start776, "Define") - return result777 + _t1503 = transactions_pb2.Define(fragment=fragment778) + result780 = _t1503 + self.record_span(span_start779, "Define") + return result780 def parse_fragment(self) -> fragments_pb2.Fragment: - 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 + _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(")") - result784 = self.construct_fragment(new_fragment_id778, declarations782) - self.record_span(span_start783, "Fragment") - return result784 + result787 = self.construct_fragment(new_fragment_id781, declarations785) + self.record_span(span_start786, "Fragment") + return result787 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") - return result787 + 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: - span_start793 = self.span_start() + span_start796 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("iceberg_data", 1): - _t1502 = 3 + _t1508 = 3 else: if self.match_lookahead_literal("functional_dependency", 1): - _t1503 = 2 + _t1509 = 2 else: if self.match_lookahead_literal("edb", 1): - _t1504 = 3 + _t1510 = 3 else: if self.match_lookahead_literal("def", 1): - _t1505 = 0 + _t1511 = 0 else: if self.match_lookahead_literal("csv_data", 1): - _t1506 = 3 + _t1512 = 3 else: if self.match_lookahead_literal("betree_relation", 1): - _t1507 = 3 + _t1513 = 3 else: if self.match_lookahead_literal("algorithm", 1): - _t1508 = 1 + _t1514 = 1 else: - _t1508 = -1 - _t1507 = _t1508 - _t1506 = _t1507 - _t1505 = _t1506 - _t1504 = _t1505 - _t1503 = _t1504 - _t1502 = _t1503 - _t1501 = _t1502 + _t1514 = -1 + _t1513 = _t1514 + _t1512 = _t1513 + _t1511 = _t1512 + _t1510 = _t1511 + _t1509 = _t1510 + _t1508 = _t1509 + _t1507 = _t1508 else: - _t1501 = -1 - prediction788 = _t1501 - if prediction788 == 3: - _t1510 = self.parse_data() - data792 = _t1510 - _t1511 = logic_pb2.Declaration(data=data792) - _t1509 = _t1511 + _t1507 = -1 + prediction791 = _t1507 + if prediction791 == 3: + _t1516 = self.parse_data() + data795 = _t1516 + _t1517 = logic_pb2.Declaration(data=data795) + _t1515 = _t1517 else: - if prediction788 == 2: - _t1513 = self.parse_constraint() - constraint791 = _t1513 - _t1514 = logic_pb2.Declaration(constraint=constraint791) - _t1512 = _t1514 + if prediction791 == 2: + _t1519 = self.parse_constraint() + constraint794 = _t1519 + _t1520 = logic_pb2.Declaration(constraint=constraint794) + _t1518 = _t1520 else: - if prediction788 == 1: - _t1516 = self.parse_algorithm() - algorithm790 = _t1516 - _t1517 = logic_pb2.Declaration(algorithm=algorithm790) - _t1515 = _t1517 + if prediction791 == 1: + _t1522 = self.parse_algorithm() + algorithm793 = _t1522 + _t1523 = logic_pb2.Declaration(algorithm=algorithm793) + _t1521 = _t1523 else: - if prediction788 == 0: - _t1519 = self.parse_def() - def789 = _t1519 - _t1520 = logic_pb2.Declaration() - getattr(_t1520, 'def').CopyFrom(def789) - _t1518 = _t1520 + 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}`") - _t1515 = _t1518 - _t1512 = _t1515 - _t1509 = _t1512 - result794 = _t1509 - self.record_span(span_start793, "Declaration") - return result794 + _t1521 = _t1524 + _t1518 = _t1521 + _t1515 = _t1518 + result797 = _t1515 + self.record_span(span_start796, "Declaration") + return result797 def parse_def(self) -> logic_pb2.Def: - span_start798 = self.span_start() + span_start801 = self.span_start() self.consume_literal("(") self.consume_literal("def") - _t1521 = self.parse_relation_id() - relation_id795 = _t1521 - _t1522 = self.parse_abstraction() - abstraction796 = _t1522 + _t1527 = self.parse_relation_id() + relation_id798 = _t1527 + _t1528 = self.parse_abstraction() + abstraction799 = _t1528 if self.match_lookahead_literal("(", 0): - _t1524 = self.parse_attrs() - _t1523 = _t1524 + _t1530 = self.parse_attrs() + _t1529 = _t1530 else: - _t1523 = None - attrs797 = _t1523 + _t1529 = None + attrs800 = _t1529 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 + _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_start803 = self.span_start() + span_start806 = self.span_start() if self.match_lookahead_literal(":", 0): - _t1526 = 0 + _t1532 = 0 else: if self.match_lookahead_terminal("UINT128", 0): - _t1527 = 1 + _t1533 = 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) + _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 prediction800 == 0: + if prediction803 == 0: self.consume_literal(":") - symbol801 = self.consume_terminal("SYMBOL") - _t1529 = self.relation_id_from_string(symbol801) + 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}`") - _t1528 = _t1529 - result804 = _t1528 - self.record_span(span_start803, "RelationId") - return result804 + _t1534 = _t1535 + result807 = _t1534 + self.record_span(span_start806, "RelationId") + return result807 def parse_abstraction(self) -> logic_pb2.Abstraction: - span_start807 = self.span_start() + span_start810 = self.span_start() self.consume_literal("(") - _t1530 = self.parse_bindings() - bindings805 = _t1530 - _t1531 = self.parse_formula() - formula806 = _t1531 + _t1536 = self.parse_bindings() + bindings808 = _t1536 + _t1537 = self.parse_formula() + formula809 = _t1537 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 + _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("[") - 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 + 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): - _t1535 = self.parse_value_bindings() - _t1534 = _t1535 + _t1541 = self.parse_value_bindings() + _t1540 = _t1541 else: - _t1534 = None - value_bindings813 = _t1534 + _t1540 = None + value_bindings816 = _t1540 self.consume_literal("]") - return (bindings812, (value_bindings813 if value_bindings813 is not None else []),) + return (bindings815, (value_bindings816 if value_bindings816 is not None else []),) def parse_binding(self) -> logic_pb2.Binding: - span_start816 = self.span_start() - symbol814 = self.consume_terminal("SYMBOL") + span_start819 = self.span_start() + symbol817 = 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 + _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_start833 = self.span_start() + span_start836 = self.span_start() if self.match_lookahead_literal("UNKNOWN", 0): - _t1539 = 0 + _t1545 = 0 else: if self.match_lookahead_literal("UINT32", 0): - _t1540 = 13 + _t1546 = 13 else: if self.match_lookahead_literal("UINT128", 0): - _t1541 = 4 + _t1547 = 4 else: if self.match_lookahead_literal("STRING", 0): - _t1542 = 1 + _t1548 = 1 else: if self.match_lookahead_literal("MISSING", 0): - _t1543 = 8 + _t1549 = 8 else: if self.match_lookahead_literal("INT32", 0): - _t1544 = 11 + _t1550 = 11 else: if self.match_lookahead_literal("INT128", 0): - _t1545 = 5 + _t1551 = 5 else: if self.match_lookahead_literal("INT", 0): - _t1546 = 2 + _t1552 = 2 else: if self.match_lookahead_literal("FLOAT32", 0): - _t1547 = 12 + _t1553 = 12 else: if self.match_lookahead_literal("FLOAT", 0): - _t1548 = 3 + _t1554 = 3 else: if self.match_lookahead_literal("DATETIME", 0): - _t1549 = 7 + _t1555 = 7 else: if self.match_lookahead_literal("DATE", 0): - _t1550 = 6 + _t1556 = 6 else: if self.match_lookahead_literal("BOOLEAN", 0): - _t1551 = 10 + _t1557 = 10 else: if self.match_lookahead_literal("(", 0): - _t1552 = 9 + _t1558 = 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 + _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 prediction818 == 12: - _t1557 = self.parse_float32_type() - float32_type831 = _t1557 - _t1558 = logic_pb2.Type(float32_type=float32_type831) - _t1556 = _t1558 + if prediction821 == 12: + _t1563 = self.parse_float32_type() + float32_type834 = _t1563 + _t1564 = logic_pb2.Type(float32_type=float32_type834) + _t1562 = _t1564 else: - if prediction818 == 11: - _t1560 = self.parse_int32_type() - int32_type830 = _t1560 - _t1561 = logic_pb2.Type(int32_type=int32_type830) - _t1559 = _t1561 + if prediction821 == 11: + _t1566 = self.parse_int32_type() + int32_type833 = _t1566 + _t1567 = logic_pb2.Type(int32_type=int32_type833) + _t1565 = _t1567 else: - if prediction818 == 10: - _t1563 = self.parse_boolean_type() - boolean_type829 = _t1563 - _t1564 = logic_pb2.Type(boolean_type=boolean_type829) - _t1562 = _t1564 + if prediction821 == 10: + _t1569 = self.parse_boolean_type() + boolean_type832 = _t1569 + _t1570 = logic_pb2.Type(boolean_type=boolean_type832) + _t1568 = _t1570 else: - if prediction818 == 9: - _t1566 = self.parse_decimal_type() - decimal_type828 = _t1566 - _t1567 = logic_pb2.Type(decimal_type=decimal_type828) - _t1565 = _t1567 + if prediction821 == 9: + _t1572 = self.parse_decimal_type() + decimal_type831 = _t1572 + _t1573 = logic_pb2.Type(decimal_type=decimal_type831) + _t1571 = _t1573 else: - if prediction818 == 8: - _t1569 = self.parse_missing_type() - missing_type827 = _t1569 - _t1570 = logic_pb2.Type(missing_type=missing_type827) - _t1568 = _t1570 + if prediction821 == 8: + _t1575 = self.parse_missing_type() + missing_type830 = _t1575 + _t1576 = logic_pb2.Type(missing_type=missing_type830) + _t1574 = _t1576 else: - if prediction818 == 7: - _t1572 = self.parse_datetime_type() - datetime_type826 = _t1572 - _t1573 = logic_pb2.Type(datetime_type=datetime_type826) - _t1571 = _t1573 + if prediction821 == 7: + _t1578 = self.parse_datetime_type() + datetime_type829 = _t1578 + _t1579 = logic_pb2.Type(datetime_type=datetime_type829) + _t1577 = _t1579 else: - if prediction818 == 6: - _t1575 = self.parse_date_type() - date_type825 = _t1575 - _t1576 = logic_pb2.Type(date_type=date_type825) - _t1574 = _t1576 + if prediction821 == 6: + _t1581 = self.parse_date_type() + date_type828 = _t1581 + _t1582 = logic_pb2.Type(date_type=date_type828) + _t1580 = _t1582 else: - if prediction818 == 5: - _t1578 = self.parse_int128_type() - int128_type824 = _t1578 - _t1579 = logic_pb2.Type(int128_type=int128_type824) - _t1577 = _t1579 + if prediction821 == 5: + _t1584 = self.parse_int128_type() + int128_type827 = _t1584 + _t1585 = logic_pb2.Type(int128_type=int128_type827) + _t1583 = _t1585 else: - if prediction818 == 4: - _t1581 = self.parse_uint128_type() - uint128_type823 = _t1581 - _t1582 = logic_pb2.Type(uint128_type=uint128_type823) - _t1580 = _t1582 + if prediction821 == 4: + _t1587 = self.parse_uint128_type() + uint128_type826 = _t1587 + _t1588 = logic_pb2.Type(uint128_type=uint128_type826) + _t1586 = _t1588 else: - if prediction818 == 3: - _t1584 = self.parse_float_type() - float_type822 = _t1584 - _t1585 = logic_pb2.Type(float_type=float_type822) - _t1583 = _t1585 + if prediction821 == 3: + _t1590 = self.parse_float_type() + float_type825 = _t1590 + _t1591 = logic_pb2.Type(float_type=float_type825) + _t1589 = _t1591 else: - if prediction818 == 2: - _t1587 = self.parse_int_type() - int_type821 = _t1587 - _t1588 = logic_pb2.Type(int_type=int_type821) - _t1586 = _t1588 + if prediction821 == 2: + _t1593 = self.parse_int_type() + int_type824 = _t1593 + _t1594 = logic_pb2.Type(int_type=int_type824) + _t1592 = _t1594 else: - if prediction818 == 1: - _t1590 = self.parse_string_type() - string_type820 = _t1590 - _t1591 = logic_pb2.Type(string_type=string_type820) - _t1589 = _t1591 + if prediction821 == 1: + _t1596 = self.parse_string_type() + string_type823 = _t1596 + _t1597 = logic_pb2.Type(string_type=string_type823) + _t1595 = _t1597 else: - if prediction818 == 0: - _t1593 = self.parse_unspecified_type() - unspecified_type819 = _t1593 - _t1594 = logic_pb2.Type(unspecified_type=unspecified_type819) - _t1592 = _t1594 + 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}`") - _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 + _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_start835 = self.span_start() + span_start838 = self.span_start() self.consume_literal("UNKNOWN") - _t1595 = logic_pb2.UnspecifiedType() - result836 = _t1595 - self.record_span(span_start835, "UnspecifiedType") - return result836 + _t1601 = logic_pb2.UnspecifiedType() + result839 = _t1601 + self.record_span(span_start838, "UnspecifiedType") + return result839 def parse_string_type(self) -> logic_pb2.StringType: - span_start837 = self.span_start() + span_start840 = self.span_start() self.consume_literal("STRING") - _t1596 = logic_pb2.StringType() - result838 = _t1596 - self.record_span(span_start837, "StringType") - return result838 + _t1602 = logic_pb2.StringType() + result841 = _t1602 + self.record_span(span_start840, "StringType") + return result841 def parse_int_type(self) -> logic_pb2.IntType: - span_start839 = self.span_start() + span_start842 = self.span_start() self.consume_literal("INT") - _t1597 = logic_pb2.IntType() - result840 = _t1597 - self.record_span(span_start839, "IntType") - return result840 + _t1603 = logic_pb2.IntType() + result843 = _t1603 + self.record_span(span_start842, "IntType") + return result843 def parse_float_type(self) -> logic_pb2.FloatType: - span_start841 = self.span_start() + span_start844 = self.span_start() self.consume_literal("FLOAT") - _t1598 = logic_pb2.FloatType() - result842 = _t1598 - self.record_span(span_start841, "FloatType") - return result842 + _t1604 = logic_pb2.FloatType() + result845 = _t1604 + self.record_span(span_start844, "FloatType") + return result845 def parse_uint128_type(self) -> logic_pb2.UInt128Type: - span_start843 = self.span_start() + span_start846 = self.span_start() self.consume_literal("UINT128") - _t1599 = logic_pb2.UInt128Type() - result844 = _t1599 - self.record_span(span_start843, "UInt128Type") - return result844 + _t1605 = logic_pb2.UInt128Type() + result847 = _t1605 + self.record_span(span_start846, "UInt128Type") + return result847 def parse_int128_type(self) -> logic_pb2.Int128Type: - span_start845 = self.span_start() + span_start848 = self.span_start() self.consume_literal("INT128") - _t1600 = logic_pb2.Int128Type() - result846 = _t1600 - self.record_span(span_start845, "Int128Type") - return result846 + _t1606 = logic_pb2.Int128Type() + result849 = _t1606 + self.record_span(span_start848, "Int128Type") + return result849 def parse_date_type(self) -> logic_pb2.DateType: - span_start847 = self.span_start() + span_start850 = self.span_start() self.consume_literal("DATE") - _t1601 = logic_pb2.DateType() - result848 = _t1601 - self.record_span(span_start847, "DateType") - return result848 + _t1607 = logic_pb2.DateType() + result851 = _t1607 + self.record_span(span_start850, "DateType") + return result851 def parse_datetime_type(self) -> logic_pb2.DateTimeType: - span_start849 = self.span_start() + span_start852 = self.span_start() self.consume_literal("DATETIME") - _t1602 = logic_pb2.DateTimeType() - result850 = _t1602 - self.record_span(span_start849, "DateTimeType") - return result850 + _t1608 = logic_pb2.DateTimeType() + result853 = _t1608 + self.record_span(span_start852, "DateTimeType") + return result853 def parse_missing_type(self) -> logic_pb2.MissingType: - span_start851 = self.span_start() + span_start854 = self.span_start() self.consume_literal("MISSING") - _t1603 = logic_pb2.MissingType() - result852 = _t1603 - self.record_span(span_start851, "MissingType") - return result852 + _t1609 = logic_pb2.MissingType() + result855 = _t1609 + self.record_span(span_start854, "MissingType") + return result855 def parse_decimal_type(self) -> logic_pb2.DecimalType: - span_start855 = self.span_start() + span_start858 = self.span_start() self.consume_literal("(") self.consume_literal("DECIMAL") - int853 = self.consume_terminal("INT") - int_3854 = self.consume_terminal("INT") + int856 = self.consume_terminal("INT") + int_3857 = 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 + _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_start857 = self.span_start() + span_start860 = self.span_start() self.consume_literal("BOOLEAN") - _t1605 = logic_pb2.BooleanType() - result858 = _t1605 - self.record_span(span_start857, "BooleanType") - return result858 + _t1611 = logic_pb2.BooleanType() + result861 = _t1611 + self.record_span(span_start860, "BooleanType") + return result861 def parse_int32_type(self) -> logic_pb2.Int32Type: - span_start859 = self.span_start() + span_start862 = self.span_start() self.consume_literal("INT32") - _t1606 = logic_pb2.Int32Type() - result860 = _t1606 - self.record_span(span_start859, "Int32Type") - return result860 + _t1612 = logic_pb2.Int32Type() + result863 = _t1612 + self.record_span(span_start862, "Int32Type") + return result863 def parse_float32_type(self) -> logic_pb2.Float32Type: - span_start861 = self.span_start() + span_start864 = self.span_start() self.consume_literal("FLOAT32") - _t1607 = logic_pb2.Float32Type() - result862 = _t1607 - self.record_span(span_start861, "Float32Type") - return result862 + _t1613 = logic_pb2.Float32Type() + result865 = _t1613 + self.record_span(span_start864, "Float32Type") + return result865 def parse_uint32_type(self) -> logic_pb2.UInt32Type: - span_start863 = self.span_start() + span_start866 = self.span_start() self.consume_literal("UINT32") - _t1608 = logic_pb2.UInt32Type() - result864 = _t1608 - self.record_span(span_start863, "UInt32Type") - return result864 + _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("|") - 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 + 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_start883 = self.span_start() + span_start886 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("true", 1): - _t1611 = 0 + _t1617 = 0 else: if self.match_lookahead_literal("relatom", 1): - _t1612 = 11 + _t1618 = 11 else: if self.match_lookahead_literal("reduce", 1): - _t1613 = 3 + _t1619 = 3 else: if self.match_lookahead_literal("primitive", 1): - _t1614 = 10 + _t1620 = 10 else: if self.match_lookahead_literal("pragma", 1): - _t1615 = 9 + _t1621 = 9 else: if self.match_lookahead_literal("or", 1): - _t1616 = 5 + _t1622 = 5 else: if self.match_lookahead_literal("not", 1): - _t1617 = 6 + _t1623 = 6 else: if self.match_lookahead_literal("ffi", 1): - _t1618 = 7 + _t1624 = 7 else: if self.match_lookahead_literal("false", 1): - _t1619 = 1 + _t1625 = 1 else: if self.match_lookahead_literal("exists", 1): - _t1620 = 2 + _t1626 = 2 else: if self.match_lookahead_literal("cast", 1): - _t1621 = 12 + _t1627 = 12 else: if self.match_lookahead_literal("atom", 1): - _t1622 = 8 + _t1628 = 8 else: if self.match_lookahead_literal("and", 1): - _t1623 = 4 + _t1629 = 4 else: if self.match_lookahead_literal(">=", 1): - _t1624 = 10 + _t1630 = 10 else: if self.match_lookahead_literal(">", 1): - _t1625 = 10 + _t1631 = 10 else: if self.match_lookahead_literal("=", 1): - _t1626 = 10 + _t1632 = 10 else: if self.match_lookahead_literal("<=", 1): - _t1627 = 10 + _t1633 = 10 else: if self.match_lookahead_literal("<", 1): - _t1628 = 10 + _t1634 = 10 else: if self.match_lookahead_literal("/", 1): - _t1629 = 10 + _t1635 = 10 else: if self.match_lookahead_literal("-", 1): - _t1630 = 10 + _t1636 = 10 else: if self.match_lookahead_literal("+", 1): - _t1631 = 10 + _t1637 = 10 else: if self.match_lookahead_literal("*", 1): - _t1632 = 10 + _t1638 = 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 + _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: - _t1610 = -1 - prediction869 = _t1610 - if prediction869 == 12: - _t1634 = self.parse_cast() - cast882 = _t1634 - _t1635 = logic_pb2.Formula(cast=cast882) - _t1633 = _t1635 + _t1616 = -1 + prediction872 = _t1616 + if prediction872 == 12: + _t1640 = self.parse_cast() + cast885 = _t1640 + _t1641 = logic_pb2.Formula(cast=cast885) + _t1639 = _t1641 else: - if prediction869 == 11: - _t1637 = self.parse_rel_atom() - rel_atom881 = _t1637 - _t1638 = logic_pb2.Formula(rel_atom=rel_atom881) - _t1636 = _t1638 + if prediction872 == 11: + _t1643 = self.parse_rel_atom() + rel_atom884 = _t1643 + _t1644 = logic_pb2.Formula(rel_atom=rel_atom884) + _t1642 = _t1644 else: - if prediction869 == 10: - _t1640 = self.parse_primitive() - primitive880 = _t1640 - _t1641 = logic_pb2.Formula(primitive=primitive880) - _t1639 = _t1641 + if prediction872 == 10: + _t1646 = self.parse_primitive() + primitive883 = _t1646 + _t1647 = logic_pb2.Formula(primitive=primitive883) + _t1645 = _t1647 else: - if prediction869 == 9: - _t1643 = self.parse_pragma() - pragma879 = _t1643 - _t1644 = logic_pb2.Formula(pragma=pragma879) - _t1642 = _t1644 + if prediction872 == 9: + _t1649 = self.parse_pragma() + pragma882 = _t1649 + _t1650 = logic_pb2.Formula(pragma=pragma882) + _t1648 = _t1650 else: - if prediction869 == 8: - _t1646 = self.parse_atom() - atom878 = _t1646 - _t1647 = logic_pb2.Formula(atom=atom878) - _t1645 = _t1647 + if prediction872 == 8: + _t1652 = self.parse_atom() + atom881 = _t1652 + _t1653 = logic_pb2.Formula(atom=atom881) + _t1651 = _t1653 else: - if prediction869 == 7: - _t1649 = self.parse_ffi() - ffi877 = _t1649 - _t1650 = logic_pb2.Formula(ffi=ffi877) - _t1648 = _t1650 + if prediction872 == 7: + _t1655 = self.parse_ffi() + ffi880 = _t1655 + _t1656 = logic_pb2.Formula(ffi=ffi880) + _t1654 = _t1656 else: - if prediction869 == 6: - _t1652 = self.parse_not() - not876 = _t1652 - _t1653 = logic_pb2.Formula() - getattr(_t1653, 'not').CopyFrom(not876) - _t1651 = _t1653 + if prediction872 == 6: + _t1658 = self.parse_not() + not879 = _t1658 + _t1659 = logic_pb2.Formula() + getattr(_t1659, 'not').CopyFrom(not879) + _t1657 = _t1659 else: - if prediction869 == 5: - _t1655 = self.parse_disjunction() - disjunction875 = _t1655 - _t1656 = logic_pb2.Formula(disjunction=disjunction875) - _t1654 = _t1656 + if prediction872 == 5: + _t1661 = self.parse_disjunction() + disjunction878 = _t1661 + _t1662 = logic_pb2.Formula(disjunction=disjunction878) + _t1660 = _t1662 else: - if prediction869 == 4: - _t1658 = self.parse_conjunction() - conjunction874 = _t1658 - _t1659 = logic_pb2.Formula(conjunction=conjunction874) - _t1657 = _t1659 + if prediction872 == 4: + _t1664 = self.parse_conjunction() + conjunction877 = _t1664 + _t1665 = logic_pb2.Formula(conjunction=conjunction877) + _t1663 = _t1665 else: - if prediction869 == 3: - _t1661 = self.parse_reduce() - reduce873 = _t1661 - _t1662 = logic_pb2.Formula(reduce=reduce873) - _t1660 = _t1662 + if prediction872 == 3: + _t1667 = self.parse_reduce() + reduce876 = _t1667 + _t1668 = logic_pb2.Formula(reduce=reduce876) + _t1666 = _t1668 else: - if prediction869 == 2: - _t1664 = self.parse_exists() - exists872 = _t1664 - _t1665 = logic_pb2.Formula(exists=exists872) - _t1663 = _t1665 + if prediction872 == 2: + _t1670 = self.parse_exists() + exists875 = _t1670 + _t1671 = logic_pb2.Formula(exists=exists875) + _t1669 = _t1671 else: - if prediction869 == 1: - _t1667 = self.parse_false() - false871 = _t1667 - _t1668 = logic_pb2.Formula(disjunction=false871) - _t1666 = _t1668 + if prediction872 == 1: + _t1673 = self.parse_false() + false874 = _t1673 + _t1674 = logic_pb2.Formula(disjunction=false874) + _t1672 = _t1674 else: - if prediction869 == 0: - _t1670 = self.parse_true() - true870 = _t1670 - _t1671 = logic_pb2.Formula(conjunction=true870) - _t1669 = _t1671 + 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}`") - _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 + _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_start885 = self.span_start() + span_start888 = 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 + _t1678 = logic_pb2.Conjunction(args=[]) + result889 = _t1678 + self.record_span(span_start888, "Conjunction") + return result889 def parse_false(self) -> logic_pb2.Disjunction: - span_start887 = self.span_start() + span_start890 = 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 + _t1679 = logic_pb2.Disjunction(args=[]) + result891 = _t1679 + self.record_span(span_start890, "Disjunction") + return result891 def parse_exists(self) -> logic_pb2.Exists: - span_start891 = self.span_start() + span_start894 = self.span_start() self.consume_literal("(") self.consume_literal("exists") - _t1674 = self.parse_bindings() - bindings889 = _t1674 - _t1675 = self.parse_formula() - formula890 = _t1675 + _t1680 = self.parse_bindings() + bindings892 = _t1680 + _t1681 = self.parse_formula() + formula893 = _t1681 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 + _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_start896 = self.span_start() + span_start899 = 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 + _t1684 = self.parse_abstraction() + abstraction896 = _t1684 + _t1685 = self.parse_abstraction() + abstraction_3897 = _t1685 + _t1686 = self.parse_terms() + terms898 = _t1686 self.consume_literal(")") - _t1681 = logic_pb2.Reduce(op=abstraction893, body=abstraction_3894, terms=terms895) - result897 = _t1681 - self.record_span(span_start896, "Reduce") - return result897 + _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") - 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 + 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(")") - return terms901 + return terms904 def parse_term(self) -> logic_pb2.Term: - span_start905 = self.span_start() + span_start908 = self.span_start() if self.match_lookahead_literal("true", 0): - _t1683 = 1 + _t1689 = 1 else: if self.match_lookahead_literal("missing", 0): - _t1684 = 1 + _t1690 = 1 else: if self.match_lookahead_literal("false", 0): - _t1685 = 1 + _t1691 = 1 else: if self.match_lookahead_literal("(", 0): - _t1686 = 1 + _t1692 = 1 else: if self.match_lookahead_terminal("SYMBOL", 0): - _t1687 = 0 + _t1693 = 0 else: if self.match_lookahead_terminal("UINT32", 0): - _t1688 = 1 + _t1694 = 1 else: if self.match_lookahead_terminal("UINT128", 0): - _t1689 = 1 + _t1695 = 1 else: if self.match_lookahead_terminal("STRING", 0): - _t1690 = 1 + _t1696 = 1 else: if self.match_lookahead_terminal("INT32", 0): - _t1691 = 1 + _t1697 = 1 else: if self.match_lookahead_terminal("INT128", 0): - _t1692 = 1 + _t1698 = 1 else: if self.match_lookahead_terminal("INT", 0): - _t1693 = 1 + _t1699 = 1 else: if self.match_lookahead_terminal("FLOAT32", 0): - _t1694 = 1 + _t1700 = 1 else: if self.match_lookahead_terminal("FLOAT", 0): - _t1695 = 1 + _t1701 = 1 else: if self.match_lookahead_terminal("DECIMAL", 0): - _t1696 = 1 + _t1702 = 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 + _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 prediction902 == 0: - _t1701 = self.parse_var() - var903 = _t1701 - _t1702 = logic_pb2.Term(var=var903) - _t1700 = _t1702 + 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}`") - _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) + _t1703 = _t1706 result909 = _t1703 - self.record_span(span_start908, "Var") + self.record_span(span_start908, "Term") return result909 + 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_value(self) -> logic_pb2.Value: - span_start923 = self.span_start() + 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 + _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 prediction910 == 11: + 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 + 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(")") - _t1753 = logic_pb2.Conjunction(args=formulas942) - result944 = _t1753 - self.record_span(span_start943, "Conjunction") - return result944 + _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() + span_start952 = 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 + 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(")") - _t1755 = logic_pb2.Disjunction(args=formulas948) - result950 = _t1755 - self.record_span(span_start949, "Disjunction") - return result950 + _t1761 = logic_pb2.Disjunction(args=formulas951) + result953 = _t1761 + self.record_span(span_start952, "Disjunction") + return result953 def parse_not(self) -> logic_pb2.Not: - span_start952 = self.span_start() + span_start955 = self.span_start() self.consume_literal("(") self.consume_literal("not") - _t1756 = self.parse_formula() - formula951 = _t1756 + _t1762 = self.parse_formula() + formula954 = _t1762 self.consume_literal(")") - _t1757 = logic_pb2.Not(arg=formula951) - result953 = _t1757 - self.record_span(span_start952, "Not") - return result953 + _t1763 = logic_pb2.Not(arg=formula954) + result956 = _t1763 + self.record_span(span_start955, "Not") + return result956 def parse_ffi(self) -> logic_pb2.FFI: - 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 + _t1764 = self.parse_name() + name957 = _t1764 + _t1765 = self.parse_ffi_args() + ffi_args958 = _t1765 + _t1766 = self.parse_terms() + terms959 = _t1766 self.consume_literal(")") - _t1761 = logic_pb2.FFI(name=name954, args=ffi_args955, terms=terms956) - result958 = _t1761 - self.record_span(span_start957, "FFI") - return result958 + _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 + symbol962 = self.consume_terminal("SYMBOL") + return symbol962 def parse_ffi_args(self) -> Sequence[logic_pb2.Abstraction]: self.consume_literal("(") self.consume_literal("args") - 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 + 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 abstractions963 + return abstractions966 def parse_atom(self) -> logic_pb2.Atom: - span_start969 = self.span_start() + span_start972 = 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 + _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(")") - _t1765 = logic_pb2.Atom(name=relation_id964, terms=terms968) - result970 = _t1765 - self.record_span(span_start969, "Atom") - return result970 + _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_start976 = self.span_start() + span_start979 = 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 + _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(")") - _t1768 = logic_pb2.Pragma(name=name971, terms=terms975) - result977 = _t1768 - self.record_span(span_start976, "Pragma") - return result977 + _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 + _t1785 = -1 + _t1784 = _t1785 + _t1783 = _t1784 + _t1782 = _t1783 + _t1781 = _t1782 + _t1780 = _t1781 + _t1779 = _t1780 + _t1778 = _t1779 + _t1777 = _t1778 + _t1776 = _t1777 + _t1775 = _t1776 else: - _t1769 = -1 - prediction978 = _t1769 - if prediction978 == 9: + _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 + _t1813 = self.parse_term() + term1002 = _t1813 + _t1814 = self.parse_term() + term_31003 = _t1814 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 + _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 + _t1854 = self.parse_term() + term1033 = _t1854 + _t1855 = self.parse_term() + term_31034 = _t1855 + _t1856 = self.parse_term() + term_41035 = _t1856 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 + _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 + _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 prediction1035 == 0: - _t1874 = self.parse_specialized_value() - specialized_value1036 = _t1874 - _t1875 = logic_pb2.RelTerm(specialized_value=specialized_value1036) - _t1873 = _t1875 + 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 + _t1876 = _t1879 + result1042 = _t1876 + self.record_span(span_start1041, "RelTerm") + return result1042 def parse_specialized_value(self) -> logic_pb2.Value: - span_start1041 = self.span_start() + span_start1044 = self.span_start() self.consume_literal("#") - _t1876 = self.parse_raw_value() - raw_value1040 = _t1876 - result1042 = raw_value1040 - self.record_span(span_start1041, "Value") - return result1042 + _t1882 = self.parse_raw_value() + raw_value1043 = _t1882 + result1045 = raw_value1043 + self.record_span(span_start1044, "Value") + return result1045 def parse_rel_atom(self) -> logic_pb2.RelAtom: - span_start1048 = self.span_start() + 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 + _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(")") - _t1879 = logic_pb2.RelAtom(name=name1043, terms=rel_terms1047) - result1049 = _t1879 - self.record_span(span_start1048, "RelAtom") - return result1049 + _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 + _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") - 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 + _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(")") - _t1886 = logic_pb2.Attribute(name=name1058, args=raw_values1062) - result1064 = _t1886 - self.record_span(span_start1063, "Attribute") - return result1064 + _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 + 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(")") - _t1893 = logic_pb2.Script(constructs=constructs1076) - result1078 = _t1893 - self.record_span(span_start1077, "Script") - return result1078 + _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 + _t1906 = -1 + _t1905 = _t1906 + _t1904 = _t1905 + _t1903 = _t1904 + _t1902 = _t1903 + _t1901 = _t1902 + _t1900 = _t1901 else: - _t1894 = -1 - prediction1079 = _t1894 - if prediction1079 == 1: - _t1902 = self.parse_instruction() - instruction1081 = _t1902 - _t1903 = logic_pb2.Construct(instruction=instruction1081) - _t1901 = _t1903 + _t1900 = -1 + prediction1082 = _t1900 + if prediction1082 == 1: + _t1908 = self.parse_instruction() + instruction1084 = _t1908 + _t1909 = logic_pb2.Construct(instruction=instruction1084) + _t1907 = _t1909 else: - if prediction1079 == 0: - _t1905 = self.parse_loop() - loop1080 = _t1905 - _t1906 = logic_pb2.Construct(loop=loop1080) - _t1904 = _t1906 + 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 + _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") - 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 + _t1924 = -1 + _t1923 = _t1924 + _t1922 = _t1923 + _t1921 = _t1922 + _t1920 = _t1921 + _t1919 = _t1920 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 + _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 prediction1093 == 3: - _t1923 = self.parse_monoid_def() - monoid_def1097 = _t1923 - _t1924 = logic_pb2.Instruction(monoid_def=monoid_def1097) - _t1922 = _t1924 + 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 + _t1953 = self.parse_relation_id() + relation_id1116 = _t1953 + _t1954 = self.parse_abstraction() + abstraction1117 = _t1954 if self.match_lookahead_literal("(", 0): - _t1950 = self.parse_attrs() - _t1949 = _t1950 + _t1956 = self.parse_attrs() + _t1955 = _t1956 else: - _t1949 = None - attrs1115 = _t1949 + _t1955 = None + attrs1118 = _t1955 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 + _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_start1122 = self.span_start() + span_start1125 = 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 + _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): - _t1956 = self.parse_attrs() - _t1955 = _t1956 + _t1962 = self.parse_attrs() + _t1961 = _t1962 else: - _t1955 = None - attrs1121 = _t1955 + _t1961 = None + attrs1124 = _t1961 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 + _t1968 = -1 + _t1967 = _t1968 + _t1966 = _t1967 + _t1965 = _t1966 + _t1964 = _t1965 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 + _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 prediction1124 == 2: - _t1967 = self.parse_max_monoid() - max_monoid1127 = _t1967 - _t1968 = logic_pb2.Monoid(max_monoid=max_monoid1127) - _t1966 = _t1968 + 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() + span_start1134 = 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 + _t1981 = logic_pb2.OrMonoid() + result1135 = _t1981 + self.record_span(span_start1134, "OrMonoid") + return result1135 def parse_min_monoid(self) -> logic_pb2.MinMonoid: - span_start1134 = self.span_start() + span_start1137 = self.span_start() self.consume_literal("(") self.consume_literal("min") - _t1976 = self.parse_type() - type1133 = _t1976 + _t1982 = self.parse_type() + type1136 = _t1982 self.consume_literal(")") - _t1977 = logic_pb2.MinMonoid(type=type1133) - result1135 = _t1977 - self.record_span(span_start1134, "MinMonoid") - return result1135 + _t1983 = logic_pb2.MinMonoid(type=type1136) + result1138 = _t1983 + self.record_span(span_start1137, "MinMonoid") + return result1138 def parse_max_monoid(self) -> logic_pb2.MaxMonoid: - span_start1137 = self.span_start() + span_start1140 = self.span_start() self.consume_literal("(") self.consume_literal("max") - _t1978 = self.parse_type() - type1136 = _t1978 + _t1984 = self.parse_type() + type1139 = _t1984 self.consume_literal(")") - _t1979 = logic_pb2.MaxMonoid(type=type1136) - result1138 = _t1979 - self.record_span(span_start1137, "MaxMonoid") - return result1138 + _t1985 = logic_pb2.MaxMonoid(type=type1139) + result1141 = _t1985 + self.record_span(span_start1140, "MaxMonoid") + return result1141 def parse_sum_monoid(self) -> logic_pb2.SumMonoid: - span_start1140 = self.span_start() + span_start1143 = self.span_start() self.consume_literal("(") self.consume_literal("sum") - _t1980 = self.parse_type() - type1139 = _t1980 + _t1986 = self.parse_type() + type1142 = _t1986 self.consume_literal(")") - _t1981 = logic_pb2.SumMonoid(type=type1139) - result1141 = _t1981 - self.record_span(span_start1140, "SumMonoid") - return result1141 + _t1987 = logic_pb2.SumMonoid(type=type1142) + result1144 = _t1987 + self.record_span(span_start1143, "SumMonoid") + return result1144 def parse_monus_def(self) -> logic_pb2.MonusDef: - 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 + _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(")") - _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 + _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") - 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 + return vars1160 def parse_functional_dependency_values(self) -> Sequence[logic_pb2.Var]: self.consume_literal("(") self.consume_literal("values") - 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 + _t2006 = -1 + _t2005 = _t2006 + _t2004 = _t2005 + _t2003 = _t2004 + _t2002 = _t2003 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 + _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 prediction1162 == 2: - _t2005 = self.parse_csv_data() - csv_data1165 = _t2005 - _t2006 = logic_pb2.Data(csv_data=csv_data1165) - _t2004 = _t2006 + 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 + _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(")") - _t2016 = logic_pb2.EDB(target_id=relation_id1169, path=edb_path1170, types=edb_types1171) - result1173 = _t2016 - self.record_span(span_start1172, "EDB") - return result1173 + _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() + span_start1187 = 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 + _t2024 = self.parse_relation_id() + relation_id1185 = _t2024 + _t2025 = self.parse_betree_info() + betree_info1186 = _t2025 self.consume_literal(")") - _t2020 = logic_pb2.BeTreeRelation(name=relation_id1182, relation_info=betree_info1183) - result1185 = _t2020 - self.record_span(span_start1184, "BeTreeRelation") - return result1185 + _t2026 = logic_pb2.BeTreeRelation(name=relation_id1185, relation_info=betree_info1186) + result1188 = _t2026 + self.record_span(span_start1187, "BeTreeRelation") + return result1188 def parse_betree_info(self) -> logic_pb2.BeTreeInfo: - span_start1189 = self.span_start() + span_start1192 = 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 + _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(")") - _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 + _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_betree_info_key_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("key_types") - 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 + 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(")") - return types1194 + return types1197 def parse_betree_info_value_types(self) -> Sequence[logic_pb2.Type]: self.consume_literal("(") self.consume_literal("value_types") - 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 + 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 + _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") - 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 + 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 strings1213 + return strings1216 def parse_csv_locator_inline_data(self) -> str: self.consume_literal("(") self.consume_literal("inline_data") - formatted_string1214 = self.consume_terminal("STRING") + formatted_string1217 = 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 + _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") - _t2044 = self.parse_config_dict() - config_dict1219 = _t2044 + _t2050 = self.parse_config_dict() + config_dict1222 = _t2050 self.consume_literal(")") - return config_dict1219 + return config_dict1222 def parse_gnf_columns(self) -> Sequence[logic_pb2.GNFColumn]: self.consume_literal("(") self.consume_literal("columns") - 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 + _t2069 = 0 + _t2068 = _t2069 + _t2067 = _t2068 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 + _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 prediction1250 == 0: - _t2069 = self.parse_non_cdc_relations() - non_cdc_relations1251 = _t2069 - _t2070 = self.construct_non_cdc_relations(non_cdc_relations1251) - _t2068 = _t2070 + 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 + _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(")") - _t2074 = logic_pb2.TargetRelation(target_id=relation_id1259, values=named_columns1263) - result1265 = _t2074 - self.record_span(span_start1264, "TargetRelation") - return result1265 + _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 + return target_relations1276 def parse_csv_asof(self) -> str: self.consume_literal("(") self.consume_literal("asof") - 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 + _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(")") - _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 + _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") - string1288 = self.consume_terminal("STRING") + string1291 = self.consume_terminal("STRING") self.consume_literal(")") - return string1288 + return string1291 def parse_iceberg_locator_namespace(self) -> Sequence[str]: self.consume_literal("(") self.consume_literal("namespace") - 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 + 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 strings1292 + return strings1295 def parse_iceberg_locator_warehouse(self) -> str: self.consume_literal("(") self.consume_literal("warehouse") - string1293 = self.consume_terminal("STRING") + string1296 = 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 + _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") - string1300 = self.consume_terminal("STRING") + string1303 = self.consume_terminal("STRING") self.consume_literal(")") - return string1300 + return string1303 def parse_iceberg_catalog_config_scope(self) -> str: self.consume_literal("(") self.consume_literal("scope") - string1301 = self.consume_terminal("STRING") + string1304 = self.consume_terminal("STRING") self.consume_literal(")") - return string1301 + return string1304 def parse_iceberg_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("properties") - 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 + return iceberg_property_entrys1308 def parse_iceberg_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - string1306 = self.consume_terminal("STRING") - string_31307 = self.consume_terminal("STRING") + string1309 = self.consume_terminal("STRING") + string_31310 = self.consume_terminal("STRING") self.consume_literal(")") - return (string1306, string_31307,) + return (string1309, string_31310,) def parse_iceberg_auth_properties(self) -> Sequence[tuple[str, str]]: self.consume_literal("(") self.consume_literal("auth_properties") - 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 + return iceberg_masked_property_entrys1314 def parse_iceberg_masked_property_entry(self) -> tuple[str, str]: self.consume_literal("(") self.consume_literal("prop") - 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,) + return (string1315, string_31316,) def parse_iceberg_from_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("from_snapshot") - string1314 = self.consume_terminal("STRING") + string1317 = self.consume_terminal("STRING") self.consume_literal(")") - return string1314 + return string1317 def parse_iceberg_to_snapshot(self) -> str: self.consume_literal("(") self.consume_literal("to_snapshot") - 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 + _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(")") - _t2104 = transactions_pb2.Snapshot(prefix=edb_path1325, mappings=snapshot_mappings1329) - result1331 = _t2104 - self.record_span(span_start1330, "Snapshot") - return result1331 + _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 + 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") - 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 + _t2121 = -1 + _t2120 = _t2121 + _t2119 = _t2120 + _t2118 = _t2119 + _t2117 = _t2118 + _t2116 = _t2117 + _t2115 = _t2116 else: - _t2109 = -1 - prediction1340 = _t2109 - if prediction1340 == 4: - _t2117 = self.parse_export() - export1345 = _t2117 - _t2118 = transactions_pb2.Read(export=export1345) - _t2116 = _t2118 + _t2115 = -1 + prediction1343 = _t2115 + if prediction1343 == 4: + _t2123 = self.parse_export() + export1348 = _t2123 + _t2124 = transactions_pb2.Read(export=export1348) + _t2122 = _t2124 else: - if prediction1340 == 3: - _t2120 = self.parse_abort() - abort1344 = _t2120 - _t2121 = transactions_pb2.Read(abort=abort1344) - _t2119 = _t2121 + 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 + _t2131 = _t2134 + _t2128 = _t2131 + _t2125 = _t2128 + _t2122 = _t2125 + result1350 = _t2122 + self.record_span(span_start1349, "Read") + return result1350 def parse_demand(self) -> transactions_pb2.Demand: - span_start1349 = self.span_start() + span_start1352 = self.span_start() self.consume_literal("(") self.consume_literal("demand") - _t2131 = self.parse_relation_id() - relation_id1348 = _t2131 + _t2137 = self.parse_relation_id() + relation_id1351 = _t2137 self.consume_literal(")") - _t2132 = transactions_pb2.Demand(relation_id=relation_id1348) - result1350 = _t2132 - self.record_span(span_start1349, "Demand") - return result1350 + _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: - span_start1353 = self.span_start() + span_start1356 = self.span_start() self.consume_literal("(") self.consume_literal("output") - _t2133 = self.parse_name() - name1351 = _t2133 - _t2134 = self.parse_relation_id() - relation_id1352 = _t2134 + _t2139 = self.parse_name() + name1354 = _t2139 + _t2140 = self.parse_relation_id() + relation_id1355 = _t2140 self.consume_literal(")") - _t2135 = transactions_pb2.Output(name=name1351, relation_id=relation_id1352) - result1354 = _t2135 - self.record_span(span_start1353, "Output") - return result1354 + _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_start1357 = self.span_start() + span_start1360 = self.span_start() self.consume_literal("(") self.consume_literal("what_if") - _t2136 = self.parse_name() - name1355 = _t2136 - _t2137 = self.parse_epoch() - epoch1356 = _t2137 + _t2142 = self.parse_name() + name1358 = _t2142 + _t2143 = self.parse_epoch() + epoch1359 = _t2143 self.consume_literal(")") - _t2138 = transactions_pb2.WhatIf(branch=name1355, epoch=epoch1356) - result1358 = _t2138 - self.record_span(span_start1357, "WhatIf") - return result1358 + _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_start1361 = 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)): - _t2140 = self.parse_name() - _t2139 = _t2140 + _t2146 = self.parse_name() + _t2145 = _t2146 else: - _t2139 = None - name1359 = _t2139 - _t2141 = self.parse_relation_id() - relation_id1360 = _t2141 + _t2145 = None + name1362 = _t2145 + _t2147 = self.parse_relation_id() + relation_id1363 = _t2147 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 + _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_start1366 = self.span_start() + span_start1369 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_iceberg", 1): - _t2144 = 1 + _t2150 = 1 else: if self.match_lookahead_literal("export", 1): - _t2145 = 0 + _t2151 = 0 else: - _t2145 = -1 - _t2144 = _t2145 - _t2143 = _t2144 + _t2151 = -1 + _t2150 = _t2151 + _t2149 = _t2150 else: - _t2143 = -1 - prediction1363 = _t2143 - if prediction1363 == 1: + _t2149 = -1 + prediction1366 = _t2149 + if prediction1366 == 1: self.consume_literal("(") self.consume_literal("export_iceberg") - _t2147 = self.parse_export_iceberg_config() - export_iceberg_config1365 = _t2147 + _t2153 = self.parse_export_iceberg_config() + export_iceberg_config1368 = _t2153 self.consume_literal(")") - _t2148 = transactions_pb2.Export(iceberg_config=export_iceberg_config1365) - _t2146 = _t2148 + _t2154 = transactions_pb2.Export(iceberg_config=export_iceberg_config1368) + _t2152 = _t2154 else: - if prediction1363 == 0: + if prediction1366 == 0: self.consume_literal("(") self.consume_literal("export") - _t2150 = self.parse_export_csv_config() - export_csv_config1364 = _t2150 + _t2156 = self.parse_export_csv_config() + export_csv_config1367 = _t2156 self.consume_literal(")") - _t2151 = transactions_pb2.Export(csv_config=export_csv_config1364) - _t2149 = _t2151 + _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}`") - _t2146 = _t2149 - result1367 = _t2146 - self.record_span(span_start1366, "Export") - return result1367 + _t2152 = _t2155 + result1370 = _t2152 + self.record_span(span_start1369, "Export") + return result1370 def parse_export_csv_config(self) -> transactions_pb2.ExportCSVConfig: - span_start1375 = self.span_start() + span_start1378 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("export_csv_config_v2", 1): - _t2153 = 0 + _t2159 = 0 else: if self.match_lookahead_literal("export_csv_config", 1): - _t2154 = 1 + _t2160 = 1 else: - _t2154 = -1 - _t2153 = _t2154 - _t2152 = _t2153 + _t2160 = -1 + _t2159 = _t2160 + _t2158 = _t2159 else: - _t2152 = -1 - prediction1368 = _t2152 - if prediction1368 == 1: + _t2158 = -1 + prediction1371 = _t2158 + if prediction1371 == 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 + _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(")") - _t2159 = self.construct_export_csv_config(export_csv_path1372, export_csv_columns_list1373, config_dict1374) - _t2155 = _t2159 + _t2165 = self.construct_export_csv_config(export_csv_path1375, export_csv_columns_list1376, config_dict1377) + _t2161 = _t2165 else: - if prediction1368 == 0: + if prediction1371 == 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 + _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(")") - _t2164 = self.construct_export_csv_config_with_source(export_csv_path1369, export_csv_source1370, csv_config1371) - _t2160 = _t2164 + _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}`") - _t2155 = _t2160 - result1376 = _t2155 - self.record_span(span_start1375, "ExportCSVConfig") - return result1376 + _t2161 = _t2166 + result1379 = _t2161 + self.record_span(span_start1378, "ExportCSVConfig") + return result1379 - def parse_export_csv_path(self) -> str: - self.consume_literal("(") - self.consume_literal("path") - string1377 = self.consume_terminal("STRING") - self.consume_literal(")") - return string1377 + def parse_export_csv_output_location(self) -> tuple[str, str]: + if self.match_lookahead_literal("(", 0): + if self.match_lookahead_literal("transaction_output_name", 1): + _t2172 = 1 + else: + if self.match_lookahead_literal("path", 1): + _t2173 = 0 + else: + _t2173 = -1 + _t2172 = _t2173 + _t2171 = _t2172 + else: + _t2171 = -1 + prediction1380 = _t2171 + if prediction1380 == 1: + self.consume_literal("(") + self.consume_literal("transaction_output_name") + _t2175 = self.parse_name() + name1382 = _t2175 + self.consume_literal(")") + _t2174 = ("", name1382,) + else: + if prediction1380 == 0: + self.consume_literal("(") + self.consume_literal("path") + string1381 = self.consume_terminal("STRING") + self.consume_literal(")") + _t2176 = (string1381, "",) + else: + raise ParseError("Unexpected token in export_csv_output_location" + f": {self.lookahead(0).type}=`{self.lookahead(0).value}`") + _t2174 = _t2176 + return _t2174 def parse_export_csv_source(self) -> transactions_pb2.ExportCSVSource: - span_start1384 = self.span_start() + span_start1389 = self.span_start() if self.match_lookahead_literal("(", 0): if self.match_lookahead_literal("table_def", 1): - _t2166 = 1 + _t2178 = 1 else: if self.match_lookahead_literal("gnf_columns", 1): - _t2167 = 0 + _t2179 = 0 else: - _t2167 = -1 - _t2166 = _t2167 - _t2165 = _t2166 + _t2179 = -1 + _t2178 = _t2179 + _t2177 = _t2178 else: - _t2165 = -1 - prediction1378 = _t2165 - if prediction1378 == 1: + _t2177 = -1 + prediction1383 = _t2177 + if prediction1383 == 1: self.consume_literal("(") self.consume_literal("table_def") - _t2169 = self.parse_relation_id() - relation_id1383 = _t2169 + _t2181 = self.parse_relation_id() + relation_id1388 = _t2181 self.consume_literal(")") - _t2170 = transactions_pb2.ExportCSVSource(table_def=relation_id1383) - _t2168 = _t2170 + _t2182 = transactions_pb2.ExportCSVSource(table_def=relation_id1388) + _t2180 = _t2182 else: - if prediction1378 == 0: + if prediction1383 == 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 + 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(")") - _t2173 = transactions_pb2.ExportCSVColumns(columns=export_csv_columns1382) - _t2174 = transactions_pb2.ExportCSVSource(gnf_columns=_t2173) - _t2171 = _t2174 + _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}`") - _t2168 = _t2171 - result1385 = _t2168 - self.record_span(span_start1384, "ExportCSVSource") - return result1385 + _t2180 = _t2183 + result1390 = _t2180 + self.record_span(span_start1389, "ExportCSVSource") + return result1390 def parse_export_csv_column(self) -> transactions_pb2.ExportCSVColumn: - span_start1388 = self.span_start() + span_start1393 = self.span_start() self.consume_literal("(") self.consume_literal("column") - string1386 = self.consume_terminal("STRING") - _t2175 = self.parse_relation_id() - relation_id1387 = _t2175 + string1391 = self.consume_terminal("STRING") + _t2187 = self.parse_relation_id() + relation_id1392 = _t2187 self.consume_literal(")") - _t2176 = transactions_pb2.ExportCSVColumn(column_name=string1386, column_data=relation_id1387) - result1389 = _t2176 - self.record_span(span_start1388, "ExportCSVColumn") - return result1389 + _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") + string1395 = self.consume_terminal("STRING") + self.consume_literal(")") + return string1395 def parse_export_csv_columns_list(self) -> Sequence[transactions_pb2.ExportCSVColumn]: self.consume_literal("(") self.consume_literal("columns") - 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 + 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_columns1393 + return export_csv_columns1399 def parse_export_iceberg_config(self) -> transactions_pb2.ExportIcebergConfig: - span_start1399 = self.span_start() + span_start1405 = 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 + _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): - _t2183 = self.parse_config_dict() - _t2182 = _t2183 + _t2195 = self.parse_config_dict() + _t2194 = _t2195 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 + 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") - 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 + 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_entrys1407 + 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 8292b817..a0863d46 100644 --- a/sdks/python/src/lqp/gen/pretty.py +++ b/sdks/python/src/lqp/gen/pretty.py @@ -220,7 +220,7 @@ def deconstruct_csv_data_columns_optional(self, msg: logic_pb2.CSVData) -> Seque 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: @@ -228,163 +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 + _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: - _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,)) + _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 = [] - _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,)) + _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: - _t1856 = None + _t1869 = None assert msg.storage_integration is not None si = msg.storage_integration result = [] if si.provider != "": - _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,)) + _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 = [] - _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,)) + _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 - _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,)) + _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: @@ -396,7 +399,7 @@ def deconstruct_iceberg_catalog_config_scope_optional(self, msg: logic_pb2.Icebe assert msg.scope is not None return msg.scope else: - _t1877 = None + _t1890 = None return None def deconstruct_iceberg_data_from_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -405,7 +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: - _t1878 = None + _t1891 = None return None def deconstruct_iceberg_data_to_snapshot_optional(self, msg: logic_pb2.IcebergData) -> str | None: @@ -414,7 +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: - _t1879 = None + _t1892 = None return None def deconstruct_export_iceberg_config_optional(self, msg: transactions_pb2.ExportIcebergConfig) -> Sequence[tuple[str, logic_pb2.Value]] | None: @@ -422,20 +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 - _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 + _t1896 = None return sorted(result) def deconstruct_relation_id_string(self, msg: logic_pb2.RelationId) -> str: @@ -448,7 +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: - _t1884 = None + _t1897 = None return None def deconstruct_bindings(self, abs: logic_pb2.Abstraction) -> tuple[Sequence[logic_pb2.Binding], Sequence[logic_pb2.Binding]]: @@ -463,1769 +466,1743 @@ def deconstruct_bindings_with_arity(self, abs: logic_pb2.Abstraction, value_arit # --- Pretty-print methods --- def pretty_transaction(self, msg: transactions_pb2.Transaction): - flat851 = self._try_flat(msg, self.pretty_transaction) - if flat851 is not None: - assert flat851 is not None - self.write(flat851) + 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"): - _t1684 = _dollar_dollar.configure + _t1694 = _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) + self.pretty_epoch(elem854) self.dedent() self.write(")") def pretty_configure(self, msg: transactions_pb2.Configure): - 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) + self.pretty_config_dict(unwrapped_fields858) self.dedent() self.write(")") def pretty_config_dict(self, msg: Sequence[tuple[str, logic_pb2.Value]]): - 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) + self.pretty_config_key_value(elem861) self.dedent() self.write("}") def pretty_config_key_value(self, msg: tuple[str, logic_pb2.Value]): - flat863 = self._try_flat(msg, self.pretty_config_key_value) - if flat863 is not None: - assert flat863 is not None - self.write(flat863) + 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 - fields859 = (_dollar_dollar[0], _dollar_dollar[1],) - assert fields859 is not None - unwrapped_fields860 = fields859 + fields864 = (_dollar_dollar[0], _dollar_dollar[1],) + assert fields864 is not None + unwrapped_fields865 = fields864 self.write(":") - field861 = unwrapped_fields860[0] - self.write(field861) + field866 = unwrapped_fields865[0] + self.write(field866) self.write(" ") - field862 = unwrapped_fields860[1] - self.pretty_raw_value(field862) + field867 = unwrapped_fields865[1] + self.pretty_raw_value(field867) 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) + 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"): - _t1687 = _dollar_dollar.date_value + _t1697 = _dollar_dollar.date_value 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) + _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"): - _t1688 = _dollar_dollar.datetime_value + _t1698 = _dollar_dollar.datetime_value 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) + _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"): - _t1689 = _dollar_dollar.string_value + _t1699 = _dollar_dollar.string_value 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)) + _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"): - _t1690 = _dollar_dollar.int32_value + _t1700 = _dollar_dollar.int32_value 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')) + _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"): - _t1691 = _dollar_dollar.int_value + _t1701 = _dollar_dollar.int_value 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)) + _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"): - _t1692 = _dollar_dollar.float32_value + _t1702 = _dollar_dollar.float32_value 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)) + _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"): - _t1693 = _dollar_dollar.float_value + _t1703 = _dollar_dollar.float_value 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)) + _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"): - _t1694 = _dollar_dollar.uint32_value + _t1704 = _dollar_dollar.uint32_value 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')) + _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"): - _t1695 = _dollar_dollar.uint128_value + _t1705 = _dollar_dollar.uint128_value 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)) + _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"): - _t1696 = _dollar_dollar.int128_value + _t1706 = _dollar_dollar.int128_value 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)) + _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"): - _t1697 = _dollar_dollar.decimal_value + _t1707 = _dollar_dollar.decimal_value 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)) + _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"): - _t1698 = _dollar_dollar.boolean_value + _t1708 = _dollar_dollar.boolean_value 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) + _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: - fields864 = msg + fields869 = 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) + 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 - fields890 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields890 is not None - unwrapped_fields891 = fields890 + 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() - field892 = unwrapped_fields891[0] - self.write(str(field892)) + field897 = unwrapped_fields896[0] + self.write(str(field897)) self.newline() - field893 = unwrapped_fields891[1] - self.write(str(field893)) + field898 = unwrapped_fields896[1] + self.write(str(field898)) self.newline() - field894 = unwrapped_fields891[2] - self.write(str(field894)) + field899 = unwrapped_fields896[2] + self.write(str(field899)) self.dedent() self.write(")") 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) + 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 - 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 + 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() - field898 = unwrapped_fields897[0] - self.write(str(field898)) + field903 = unwrapped_fields902[0] + self.write(str(field903)) self.newline() - field899 = unwrapped_fields897[1] - self.write(str(field899)) + field904 = unwrapped_fields902[1] + self.write(str(field904)) self.newline() - field900 = unwrapped_fields897[2] - self.write(str(field900)) + field905 = unwrapped_fields902[2] + self.write(str(field905)) self.newline() - field901 = unwrapped_fields897[3] - self.write(str(field901)) + field906 = unwrapped_fields902[3] + self.write(str(field906)) self.newline() - field902 = unwrapped_fields897[4] - self.write(str(field902)) + field907 = unwrapped_fields902[4] + self.write(str(field907)) self.newline() - field903 = unwrapped_fields897[5] - self.write(str(field903)) - field904 = unwrapped_fields897[6] - if field904 is not None: + field908 = unwrapped_fields902[5] + self.write(str(field908)) + field909 = unwrapped_fields902[6] + if field909 is not None: self.newline() - assert field904 is not None - opt_val905 = field904 - self.write(str(opt_val905)) + 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: - _t1699 = () + _t1709 = () else: - _t1699 = None - deconstruct_result909 = _t1699 - if deconstruct_result909 is not None: - assert deconstruct_result909 is not None - unwrapped910 = deconstruct_result909 + _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: - _t1700 = () + _t1710 = () else: - _t1700 = None - deconstruct_result907 = _t1700 - if deconstruct_result907 is not None: - assert deconstruct_result907 is not None - unwrapped908 = deconstruct_result907 + _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): - flat915 = self._try_flat(msg, self.pretty_sync) - if flat915 is not None: - assert flat915 is not None - self.write(flat915) + 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 - fields911 = _dollar_dollar.fragments - assert fields911 is not None - unwrapped_fields912 = fields911 + fields916 = _dollar_dollar.fragments + assert fields916 is not None + unwrapped_fields917 = fields916 self.write("(sync") self.indent_sexp() - if not len(unwrapped_fields912) == 0: + if not len(unwrapped_fields917) == 0: self.newline() - for i914, elem913 in enumerate(unwrapped_fields912): - if (i914 > 0): + for i919, elem918 in enumerate(unwrapped_fields917): + if (i919 > 0): self.newline() - self.pretty_fragment_id(elem913) + self.pretty_fragment_id(elem918) 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) + 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 - fields916 = self.fragment_id_to_string(_dollar_dollar) - assert fields916 is not None - unwrapped_fields917 = fields916 + fields921 = self.fragment_id_to_string(_dollar_dollar) + assert fields921 is not None + unwrapped_fields922 = fields921 self.write(":") - self.write(unwrapped_fields917) + self.write(unwrapped_fields922) 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) + 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: - _t1701 = _dollar_dollar.writes + _t1711 = _dollar_dollar.writes else: - _t1701 = None + _t1711 = None if not len(_dollar_dollar.reads) == 0: - _t1702 = _dollar_dollar.reads + _t1712 = _dollar_dollar.reads else: - _t1702 = None - fields919 = (_t1701, _t1702,) - assert fields919 is not None - unwrapped_fields920 = fields919 + _t1712 = None + fields924 = (_t1711, _t1712,) + assert fields924 is not None + unwrapped_fields925 = fields924 self.write("(epoch") self.indent_sexp() - field921 = unwrapped_fields920[0] - if field921 is not None: + field926 = unwrapped_fields925[0] + if field926 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: + 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 field923 is not None - opt_val924 = field923 - self.pretty_epoch_reads(opt_val924) + 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]): - flat929 = self._try_flat(msg, self.pretty_epoch_writes) - if flat929 is not None: - assert flat929 is not None - self.write(flat929) + 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: - fields926 = msg + fields931 = msg self.write("(writes") self.indent_sexp() - if not len(fields926) == 0: + if not len(fields931) == 0: self.newline() - for i928, elem927 in enumerate(fields926): - if (i928 > 0): + for i933, elem932 in enumerate(fields931): + if (i933 > 0): self.newline() - self.pretty_write(elem927) + self.pretty_write(elem932) self.dedent() self.write(")") 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) + 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"): - _t1703 = _dollar_dollar.define + _t1713 = _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) + _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"): - _t1704 = _dollar_dollar.undefine + _t1714 = _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) + _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"): - _t1705 = _dollar_dollar.context + _t1715 = _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) + _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"): - _t1706 = _dollar_dollar.snapshot + _t1716 = _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) + _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): - flat941 = self._try_flat(msg, self.pretty_define) - if flat941 is not None: - assert flat941 is not None - self.write(flat941) + 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 - fields939 = _dollar_dollar.fragment - assert fields939 is not None - unwrapped_fields940 = fields939 + fields944 = _dollar_dollar.fragment + assert fields944 is not None + unwrapped_fields945 = fields944 self.write("(define") self.indent_sexp() self.newline() - self.pretty_fragment(unwrapped_fields940) + self.pretty_fragment(unwrapped_fields945) self.dedent() self.write(")") 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) + 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) - fields942 = (_dollar_dollar.id, _dollar_dollar.declarations,) - assert fields942 is not None - unwrapped_fields943 = fields942 + fields947 = (_dollar_dollar.id, _dollar_dollar.declarations,) + assert fields947 is not None + unwrapped_fields948 = fields947 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: + field949 = unwrapped_fields948[0] + self.pretty_new_fragment_id(field949) + field950 = unwrapped_fields948[1] + if not len(field950) == 0: self.newline() - for i947, elem946 in enumerate(field945): - if (i947 > 0): + for i952, elem951 in enumerate(field950): + if (i952 > 0): self.newline() - self.pretty_declaration(elem946) + self.pretty_declaration(elem951) self.dedent() self.write(")") 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) + 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: - fields949 = msg - self.pretty_fragment_id(fields949) + fields954 = msg + self.pretty_fragment_id(fields954) 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) + 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"): - _t1707 = getattr(_dollar_dollar, 'def') + _t1717 = 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) + _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"): - _t1708 = _dollar_dollar.algorithm + _t1718 = _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) + _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"): - _t1709 = _dollar_dollar.constraint + _t1719 = _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) + _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"): - _t1710 = _dollar_dollar.data + _t1720 = _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) + _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): - flat966 = self._try_flat(msg, self.pretty_def) - if flat966 is not None: - assert flat966 is not None - self.write(flat966) + 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: - _t1711 = _dollar_dollar.attrs + _t1721 = _dollar_dollar.attrs else: - _t1711 = None - fields960 = (_dollar_dollar.name, _dollar_dollar.body, _t1711,) - assert fields960 is not None - unwrapped_fields961 = fields960 + _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() - field962 = unwrapped_fields961[0] - self.pretty_relation_id(field962) + field967 = unwrapped_fields966[0] + self.pretty_relation_id(field967) self.newline() - field963 = unwrapped_fields961[1] - self.pretty_abstraction(field963) - field964 = unwrapped_fields961[2] - if field964 is not None: + field968 = unwrapped_fields966[1] + self.pretty_abstraction(field968) + field969 = unwrapped_fields966[2] + if field969 is not None: self.newline() - assert field964 is not None - opt_val965 = field964 - self.pretty_attrs(opt_val965) + 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): - flat971 = self._try_flat(msg, self.pretty_relation_id) - if flat971 is not None: - assert flat971 is not None - self.write(flat971) + 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 if self.relation_id_to_string(_dollar_dollar) is not None: - _t1713 = self.deconstruct_relation_id_string(_dollar_dollar) - _t1712 = _t1713 + _t1723 = self.deconstruct_relation_id_string(_dollar_dollar) + _t1722 = _t1723 else: - _t1712 = None - deconstruct_result969 = _t1712 - if deconstruct_result969 is not None: - assert deconstruct_result969 is not None - unwrapped970 = deconstruct_result969 + _t1722 = None + deconstruct_result974 = _t1722 + if deconstruct_result974 is not None: + assert deconstruct_result974 is not None + unwrapped975 = deconstruct_result974 self.write(":") - self.write(unwrapped970) + self.write(unwrapped975) 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)) + _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_abstraction(self, msg: logic_pb2.Abstraction): - flat976 = self._try_flat(msg, self.pretty_abstraction) - if flat976 is not None: - assert flat976 is not None - self.write(flat976) + 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 - _t1715 = self.deconstruct_bindings(_dollar_dollar) - fields972 = (_t1715, _dollar_dollar.value,) - assert fields972 is not None - unwrapped_fields973 = fields972 + _t1725 = self.deconstruct_bindings(_dollar_dollar) + fields977 = (_t1725, _dollar_dollar.value,) + assert fields977 is not None + unwrapped_fields978 = fields977 self.write("(") self.indent() - field974 = unwrapped_fields973[0] - self.pretty_bindings(field974) + field979 = unwrapped_fields978[0] + self.pretty_bindings(field979) self.newline() - field975 = unwrapped_fields973[1] - self.pretty_formula(field975) + 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]]): - flat984 = self._try_flat(msg, self.pretty_bindings) - if flat984 is not None: - assert flat984 is not None - self.write(flat984) + 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: - _t1716 = _dollar_dollar[1] + _t1726 = _dollar_dollar[1] else: - _t1716 = None - fields977 = (_dollar_dollar[0], _t1716,) - assert fields977 is not None - unwrapped_fields978 = fields977 + _t1726 = None + fields982 = (_dollar_dollar[0], _t1726,) + assert fields982 is not None + unwrapped_fields983 = fields982 self.write("[") self.indent() - field979 = unwrapped_fields978[0] - for i981, elem980 in enumerate(field979): - if (i981 > 0): + field984 = unwrapped_fields983[0] + for i986, elem985 in enumerate(field984): + if (i986 > 0): self.newline() - self.pretty_binding(elem980) - field982 = unwrapped_fields978[1] - if field982 is not None: + self.pretty_binding(elem985) + field987 = unwrapped_fields983[1] + if field987 is not None: self.newline() - assert field982 is not None - opt_val983 = field982 - self.pretty_value_bindings(opt_val983) + 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): - flat989 = self._try_flat(msg, self.pretty_binding) - if flat989 is not None: - assert flat989 is not None - self.write(flat989) + 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 - fields985 = (_dollar_dollar.var.name, _dollar_dollar.type,) - assert fields985 is not None - unwrapped_fields986 = fields985 - field987 = unwrapped_fields986[0] - self.write(field987) + 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("::") - field988 = unwrapped_fields986[1] - self.pretty_type(field988) + field993 = unwrapped_fields991[1] + self.pretty_type(field993) 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) + 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"): - _t1717 = _dollar_dollar.unspecified_type + _t1727 = _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) + _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("string_type"): - _t1718 = _dollar_dollar.string_type + _t1728 = _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) + _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("int_type"): - _t1719 = _dollar_dollar.int_type + _t1729 = _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) + _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("float_type"): - _t1720 = _dollar_dollar.float_type + _t1730 = _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) + _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("uint128_type"): - _t1721 = _dollar_dollar.uint128_type + _t1731 = _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) + _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("int128_type"): - _t1722 = _dollar_dollar.int128_type + _t1732 = _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) + _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("date_type"): - _t1723 = _dollar_dollar.date_type + _t1733 = _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) + _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("datetime_type"): - _t1724 = _dollar_dollar.datetime_type + _t1734 = _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) + _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("missing_type"): - _t1725 = _dollar_dollar.missing_type + _t1735 = _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) + _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("decimal_type"): - _t1726 = _dollar_dollar.decimal_type + _t1736 = _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) + _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("boolean_type"): - _t1727 = _dollar_dollar.boolean_type + _t1737 = _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) + _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("int32_type"): - _t1728 = _dollar_dollar.int32_type + _t1738 = _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) + _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: _dollar_dollar = msg if _dollar_dollar.HasField("float32_type"): - _t1729 = _dollar_dollar.float32_type + _t1739 = _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) + _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"): - _t1730 = _dollar_dollar.uint32_type + _t1740 = _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) + _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_unspecified_type(self, msg: logic_pb2.UnspecifiedType): - fields1019 = msg + fields1024 = msg self.write("UNKNOWN") def pretty_string_type(self, msg: logic_pb2.StringType): - fields1020 = msg + fields1025 = msg self.write("STRING") def pretty_int_type(self, msg: logic_pb2.IntType): - fields1021 = msg + fields1026 = msg self.write("INT") def pretty_float_type(self, msg: logic_pb2.FloatType): - fields1022 = msg + fields1027 = msg self.write("FLOAT") def pretty_uint128_type(self, msg: logic_pb2.UInt128Type): - fields1023 = msg + fields1028 = msg self.write("UINT128") def pretty_int128_type(self, msg: logic_pb2.Int128Type): - fields1024 = msg + fields1029 = msg self.write("INT128") def pretty_date_type(self, msg: logic_pb2.DateType): - fields1025 = msg + fields1030 = msg self.write("DATE") def pretty_datetime_type(self, msg: logic_pb2.DateTimeType): - fields1026 = msg + fields1031 = msg self.write("DATETIME") def pretty_missing_type(self, msg: logic_pb2.MissingType): - fields1027 = msg + fields1032 = 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) + 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 - fields1028 = (int(_dollar_dollar.precision), int(_dollar_dollar.scale),) - assert fields1028 is not None - unwrapped_fields1029 = fields1028 + 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() - field1030 = unwrapped_fields1029[0] - self.write(str(field1030)) + field1035 = unwrapped_fields1034[0] + self.write(str(field1035)) self.newline() - field1031 = unwrapped_fields1029[1] - self.write(str(field1031)) + field1036 = unwrapped_fields1034[1] + self.write(str(field1036)) self.dedent() self.write(")") def pretty_boolean_type(self, msg: logic_pb2.BooleanType): - fields1033 = msg + fields1038 = msg self.write("BOOLEAN") def pretty_int32_type(self, msg: logic_pb2.Int32Type): - fields1034 = msg + fields1039 = msg self.write("INT32") def pretty_float32_type(self, msg: logic_pb2.Float32Type): - fields1035 = msg + fields1040 = msg self.write("FLOAT32") def pretty_uint32_type(self, msg: logic_pb2.UInt32Type): - fields1036 = msg + fields1041 = 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) + 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: - fields1037 = msg + fields1042 = msg self.write("|") - if not len(fields1037) == 0: + if not len(fields1042) == 0: self.write(" ") - for i1039, elem1038 in enumerate(fields1037): - if (i1039 > 0): + for i1044, elem1043 in enumerate(fields1042): + if (i1044 > 0): self.newline() - self.pretty_binding(elem1038) + self.pretty_binding(elem1043) 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) + 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("conjunction") and len(_dollar_dollar.conjunction.args) == 0): - _t1731 = _dollar_dollar.conjunction + _t1741 = _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) + _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("disjunction") and len(_dollar_dollar.disjunction.args) == 0): - _t1732 = _dollar_dollar.disjunction + _t1742 = _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) + _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("exists"): - _t1733 = _dollar_dollar.exists + _t1743 = _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) + _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("reduce"): - _t1734 = _dollar_dollar.reduce + _t1744 = _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) + _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("conjunction") and not len(_dollar_dollar.conjunction.args) == 0): - _t1735 = _dollar_dollar.conjunction + _t1745 = _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) + _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("disjunction") and not len(_dollar_dollar.disjunction.args) == 0): - _t1736 = _dollar_dollar.disjunction + _t1746 = _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) + _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("not"): - _t1737 = getattr(_dollar_dollar, 'not') + _t1747 = 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) + _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("ffi"): - _t1738 = _dollar_dollar.ffi + _t1748 = _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) + _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("atom"): - _t1739 = _dollar_dollar.atom + _t1749 = _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) + _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("pragma"): - _t1740 = _dollar_dollar.pragma + _t1750 = _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) + _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("primitive"): - _t1741 = _dollar_dollar.primitive + _t1751 = _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) + _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("rel_atom"): - _t1742 = _dollar_dollar.rel_atom + _t1752 = _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) + _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("cast"): - _t1743 = _dollar_dollar.cast + _t1753 = _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) + _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: raise ParseError("No matching rule for formula") def pretty_true(self, msg: logic_pb2.Conjunction): - fields1068 = msg + fields1073 = msg self.write("(true)") def pretty_false(self, msg: logic_pb2.Disjunction): - fields1069 = msg + fields1074 = 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) + 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 - _t1744 = self.deconstruct_bindings(_dollar_dollar.body) - fields1070 = (_t1744, _dollar_dollar.body.value,) - assert fields1070 is not None - unwrapped_fields1071 = fields1070 + _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() - field1072 = unwrapped_fields1071[0] - self.pretty_bindings(field1072) + field1077 = unwrapped_fields1076[0] + self.pretty_bindings(field1077) self.newline() - field1073 = unwrapped_fields1071[1] - self.pretty_formula(field1073) + field1078 = unwrapped_fields1076[1] + self.pretty_formula(field1078) self.dedent() self.write(")") def pretty_reduce(self, msg: logic_pb2.Reduce): - flat1080 = self._try_flat(msg, self.pretty_reduce) - if flat1080 is not None: - assert flat1080 is not None - self.write(flat1080) + 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 - fields1075 = (_dollar_dollar.op, _dollar_dollar.body, _dollar_dollar.terms,) - assert fields1075 is not None - unwrapped_fields1076 = fields1075 + 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() - field1077 = unwrapped_fields1076[0] - self.pretty_abstraction(field1077) + field1082 = unwrapped_fields1081[0] + self.pretty_abstraction(field1082) self.newline() - field1078 = unwrapped_fields1076[1] - self.pretty_abstraction(field1078) + field1083 = unwrapped_fields1081[1] + self.pretty_abstraction(field1083) self.newline() - field1079 = unwrapped_fields1076[2] - self.pretty_terms(field1079) + field1084 = unwrapped_fields1081[2] + self.pretty_terms(field1084) self.dedent() self.write(")") def pretty_terms(self, msg: Sequence[logic_pb2.Term]): - flat1084 = self._try_flat(msg, self.pretty_terms) - if flat1084 is not None: - assert flat1084 is not None - self.write(flat1084) + flat1089 = self._try_flat(msg, self.pretty_terms) + if flat1089 is not None: + assert flat1089 is not None + self.write(flat1089) return None else: - fields1081 = msg + fields1086 = msg self.write("(terms") self.indent_sexp() - if not len(fields1081) == 0: + if not len(fields1086) == 0: self.newline() - for i1083, elem1082 in enumerate(fields1081): - if (i1083 > 0): + for i1088, elem1087 in enumerate(fields1086): + if (i1088 > 0): self.newline() - self.pretty_term(elem1082) + self.pretty_term(elem1087) 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) + 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("var"): - _t1745 = _dollar_dollar.var + _t1755 = _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) + _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("constant"): - _t1746 = _dollar_dollar.constant + _t1756 = _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) + _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): - flat1092 = self._try_flat(msg, self.pretty_var) - if flat1092 is not None: - assert flat1092 is not None - self.write(flat1092) + 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 - fields1090 = _dollar_dollar.name - assert fields1090 is not None - unwrapped_fields1091 = fields1090 - self.write(unwrapped_fields1091) + fields1095 = _dollar_dollar.name + assert fields1095 is not None + unwrapped_fields1096 = fields1095 + self.write(unwrapped_fields1096) 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) + 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"): - _t1747 = _dollar_dollar.date_value + _t1757 = _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) + _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"): - _t1748 = _dollar_dollar.datetime_value + _t1758 = _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) + _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("string_value"): - _t1749 = _dollar_dollar.string_value + _t1759 = _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)) + _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("int32_value"): - _t1750 = _dollar_dollar.int32_value + _t1760 = _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')) + _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: _dollar_dollar = msg if _dollar_dollar.HasField("int_value"): - _t1751 = _dollar_dollar.int_value + _t1761 = _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)) + _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"): - _t1752 = _dollar_dollar.float32_value + _t1762 = _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)) + _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"): - _t1753 = _dollar_dollar.float_value + _t1763 = _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)) + _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"): - _t1754 = _dollar_dollar.uint32_value + _t1764 = _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')) + _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"): - _t1755 = _dollar_dollar.uint128_value + _t1765 = _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)) + _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"): - _t1756 = _dollar_dollar.int128_value + _t1766 = _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)) + _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"): - _t1757 = _dollar_dollar.decimal_value + _t1767 = _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)) + _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"): - _t1758 = _dollar_dollar.boolean_value + _t1768 = _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) + _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: - fields1093 = msg + fields1098 = 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) + 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 - fields1119 = (int(_dollar_dollar.year), int(_dollar_dollar.month), int(_dollar_dollar.day),) - assert fields1119 is not None - unwrapped_fields1120 = fields1119 + 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() - field1121 = unwrapped_fields1120[0] - self.write(str(field1121)) + field1126 = unwrapped_fields1125[0] + self.write(str(field1126)) self.newline() - field1122 = unwrapped_fields1120[1] - self.write(str(field1122)) + field1127 = unwrapped_fields1125[1] + self.write(str(field1127)) self.newline() - field1123 = unwrapped_fields1120[2] - self.write(str(field1123)) + field1128 = unwrapped_fields1125[2] + self.write(str(field1128)) 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) + 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 - 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 + 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() - field1127 = unwrapped_fields1126[0] - self.write(str(field1127)) + field1132 = unwrapped_fields1131[0] + self.write(str(field1132)) self.newline() - field1128 = unwrapped_fields1126[1] - self.write(str(field1128)) + field1133 = unwrapped_fields1131[1] + self.write(str(field1133)) self.newline() - field1129 = unwrapped_fields1126[2] - self.write(str(field1129)) + field1134 = unwrapped_fields1131[2] + self.write(str(field1134)) self.newline() - field1130 = unwrapped_fields1126[3] - self.write(str(field1130)) + field1135 = unwrapped_fields1131[3] + self.write(str(field1135)) self.newline() - field1131 = unwrapped_fields1126[4] - self.write(str(field1131)) + field1136 = unwrapped_fields1131[4] + self.write(str(field1136)) self.newline() - field1132 = unwrapped_fields1126[5] - self.write(str(field1132)) - field1133 = unwrapped_fields1126[6] - if field1133 is not None: + field1137 = unwrapped_fields1131[5] + self.write(str(field1137)) + field1138 = unwrapped_fields1131[6] + if field1138 is not None: self.newline() - assert field1133 is not None - opt_val1134 = field1133 - self.write(str(opt_val1134)) + assert field1138 is not None + opt_val1139 = field1138 + self.write(str(opt_val1139)) 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) + 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 - fields1136 = _dollar_dollar.args - assert fields1136 is not None - unwrapped_fields1137 = fields1136 + fields1141 = _dollar_dollar.args + assert fields1141 is not None + unwrapped_fields1142 = fields1141 self.write("(and") self.indent_sexp() - if not len(unwrapped_fields1137) == 0: + if not len(unwrapped_fields1142) == 0: self.newline() - for i1139, elem1138 in enumerate(unwrapped_fields1137): - if (i1139 > 0): + for i1144, elem1143 in enumerate(unwrapped_fields1142): + if (i1144 > 0): self.newline() - self.pretty_formula(elem1138) + self.pretty_formula(elem1143) 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) + 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 - fields1141 = _dollar_dollar.args - assert fields1141 is not None - unwrapped_fields1142 = fields1141 + fields1146 = _dollar_dollar.args + assert fields1146 is not None + unwrapped_fields1147 = fields1146 self.write("(or") self.indent_sexp() - if not len(unwrapped_fields1142) == 0: + if not len(unwrapped_fields1147) == 0: self.newline() - for i1144, elem1143 in enumerate(unwrapped_fields1142): - if (i1144 > 0): + for i1149, elem1148 in enumerate(unwrapped_fields1147): + if (i1149 > 0): self.newline() - self.pretty_formula(elem1143) + self.pretty_formula(elem1148) 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) + flat1153 = self._try_flat(msg, self.pretty_not) + if flat1153 is not None: + assert flat1153 is not None + self.write(flat1153) return None else: _dollar_dollar = msg - fields1146 = _dollar_dollar.arg - assert fields1146 is not None - unwrapped_fields1147 = fields1146 + fields1151 = _dollar_dollar.arg + assert fields1151 is not None + unwrapped_fields1152 = fields1151 self.write("(not") self.indent_sexp() self.newline() - self.pretty_formula(unwrapped_fields1147) + self.pretty_formula(unwrapped_fields1152) 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) + 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 - fields1149 = (_dollar_dollar.name, _dollar_dollar.args, _dollar_dollar.terms,) - assert fields1149 is not None - unwrapped_fields1150 = fields1149 + 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() - field1151 = unwrapped_fields1150[0] - self.pretty_name(field1151) + field1156 = unwrapped_fields1155[0] + self.pretty_name(field1156) self.newline() - field1152 = unwrapped_fields1150[1] - self.pretty_ffi_args(field1152) + field1157 = unwrapped_fields1155[1] + self.pretty_ffi_args(field1157) self.newline() - field1153 = unwrapped_fields1150[2] - self.pretty_terms(field1153) + field1158 = unwrapped_fields1155[2] + self.pretty_terms(field1158) self.dedent() 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) + flat1161 = self._try_flat(msg, self.pretty_name) + if flat1161 is not None: + assert flat1161 is not None + self.write(flat1161) return None else: - fields1155 = msg + fields1160 = msg self.write(":") - self.write(fields1155) + self.write(fields1160) 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) + 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: - fields1157 = msg + fields1162 = msg self.write("(args") self.indent_sexp() - if not len(fields1157) == 0: + if not len(fields1162) == 0: self.newline() - for i1159, elem1158 in enumerate(fields1157): - if (i1159 > 0): + for i1164, elem1163 in enumerate(fields1162): + if (i1164 > 0): self.newline() - self.pretty_abstraction(elem1158) + self.pretty_abstraction(elem1163) self.dedent() self.write(")") def pretty_atom(self, msg: logic_pb2.Atom): - flat1167 = self._try_flat(msg, self.pretty_atom) - if flat1167 is not None: - assert flat1167 is not None - self.write(flat1167) + flat1172 = self._try_flat(msg, self.pretty_atom) + if flat1172 is not None: + assert flat1172 is not None + self.write(flat1172) return None else: _dollar_dollar = msg - fields1161 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1161 is not None - unwrapped_fields1162 = fields1161 + fields1166 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1166 is not None + unwrapped_fields1167 = fields1166 self.write("(atom") self.indent_sexp() self.newline() - field1163 = unwrapped_fields1162[0] - self.pretty_relation_id(field1163) - field1164 = unwrapped_fields1162[1] - if not len(field1164) == 0: + field1168 = unwrapped_fields1167[0] + self.pretty_relation_id(field1168) + field1169 = unwrapped_fields1167[1] + if not len(field1169) == 0: self.newline() - for i1166, elem1165 in enumerate(field1164): - if (i1166 > 0): + for i1171, elem1170 in enumerate(field1169): + if (i1171 > 0): self.newline() - self.pretty_term(elem1165) + self.pretty_term(elem1170) self.dedent() 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) + flat1179 = self._try_flat(msg, self.pretty_pragma) + if flat1179 is not None: + assert flat1179 is not None + self.write(flat1179) return None else: _dollar_dollar = msg - fields1168 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1168 is not None - unwrapped_fields1169 = fields1168 + fields1173 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1173 is not None + unwrapped_fields1174 = fields1173 self.write("(pragma") self.indent_sexp() self.newline() - field1170 = unwrapped_fields1169[0] - self.pretty_name(field1170) - field1171 = unwrapped_fields1169[1] - if not len(field1171) == 0: + field1175 = unwrapped_fields1174[0] + self.pretty_name(field1175) + field1176 = unwrapped_fields1174[1] + if not len(field1176) == 0: self.newline() - for i1173, elem1172 in enumerate(field1171): - if (i1173 > 0): + for i1178, elem1177 in enumerate(field1176): + if (i1178 > 0): self.newline() - self.pretty_term(elem1172) + self.pretty_term(elem1177) self.dedent() 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) + 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": - _t1759 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1769 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1759 = None - guard_result1189 = _t1759 - if guard_result1189 is not None: + _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": - _t1760 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1770 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1760 = None - guard_result1188 = _t1760 - if guard_result1188 is not None: + _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": - _t1761 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1771 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1761 = None - guard_result1187 = _t1761 - if guard_result1187 is not None: + _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": - _t1762 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1772 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1762 = None - guard_result1186 = _t1762 - if guard_result1186 is not None: + _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": - _t1763 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + _t1773 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1763 = None - guard_result1185 = _t1763 - if guard_result1185 is not None: + _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": - _t1764 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1774 = (_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: + _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": - _t1765 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1775 = (_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: + _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": - _t1766 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1776 = (_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: + _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": - _t1767 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1777 = (_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: + _t1777 = None + guard_result1186 = _t1777 + if guard_result1186 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 + fields1180 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1180 is not None + unwrapped_fields1181 = fields1180 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: + field1182 = unwrapped_fields1181[0] + self.pretty_name(field1182) + field1183 = unwrapped_fields1181[1] + if not len(field1183) == 0: self.newline() - for i1180, elem1179 in enumerate(field1178): - if (i1180 > 0): + for i1185, elem1184 in enumerate(field1183): + if (i1185 > 0): self.newline() - self.pretty_rel_term(elem1179) + self.pretty_rel_term(elem1184) 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) + 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 - if _dollar_dollar.name == "rel_primitive_lt_monotype": - _t1769 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + if _dollar_dollar.name == "rel_primitive_eq": + _t1778 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1769 = None - fields1196 = _t1769 + _t1778 = None + fields1196 = _t1778 assert fields1196 is not None unwrapped_fields1197 = fields1196 - self.write("(<") + self.write("(=") self.indent_sexp() self.newline() field1198 = unwrapped_fields1197[0] @@ -2236,22 +2213,22 @@ def pretty_lt(self, msg: logic_pb2.Primitive): self.dedent() self.write(")") - def pretty_lt_eq(self, msg: logic_pb2.Primitive): - flat1205 = self._try_flat(msg, self.pretty_lt_eq) + 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 _dollar_dollar.name == "rel_primitive_lt_eq_monotype": - _t1770 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + if _dollar_dollar.name == "rel_primitive_lt_monotype": + _t1779 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1770 = None - fields1201 = _t1770 + _t1779 = None + fields1201 = _t1779 assert fields1201 is not None unwrapped_fields1202 = fields1201 - self.write("(<=") + self.write("(<") self.indent_sexp() self.newline() field1203 = unwrapped_fields1202[0] @@ -2262,22 +2239,22 @@ def pretty_lt_eq(self, msg: logic_pb2.Primitive): self.dedent() self.write(")") - def pretty_gt(self, msg: logic_pb2.Primitive): - flat1210 = self._try_flat(msg, self.pretty_gt) + 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 - if _dollar_dollar.name == "rel_primitive_gt_monotype": - _t1771 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + if _dollar_dollar.name == "rel_primitive_lt_eq_monotype": + _t1780 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1771 = None - fields1206 = _t1771 + _t1780 = None + fields1206 = _t1780 assert fields1206 is not None unwrapped_fields1207 = fields1206 - self.write("(>") + self.write("(<=") self.indent_sexp() self.newline() field1208 = unwrapped_fields1207[0] @@ -2288,22 +2265,22 @@ def pretty_gt(self, msg: logic_pb2.Primitive): self.dedent() self.write(")") - def pretty_gt_eq(self, msg: logic_pb2.Primitive): - flat1215 = self._try_flat(msg, self.pretty_gt_eq) + 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: _dollar_dollar = msg - if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": - _t1772 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) + if _dollar_dollar.name == "rel_primitive_gt_monotype": + _t1781 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1772 = None - fields1211 = _t1772 + _t1781 = None + fields1211 = _t1781 assert fields1211 is not None unwrapped_fields1212 = fields1211 - self.write("(>=") + self.write("(>") self.indent_sexp() self.newline() field1213 = unwrapped_fields1212[0] @@ -2314,22 +2291,22 @@ def pretty_gt_eq(self, msg: logic_pb2.Primitive): self.dedent() self.write(")") - 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) + 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: _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,) + if _dollar_dollar.name == "rel_primitive_gt_eq_monotype": + _t1782 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term,) else: - _t1773 = None - fields1216 = _t1773 + _t1782 = None + fields1216 = _t1782 assert fields1216 is not None unwrapped_fields1217 = fields1216 - self.write("(+") + self.write("(>=") self.indent_sexp() self.newline() field1218 = unwrapped_fields1217[0] @@ -2337,2248 +2314,2316 @@ def pretty_add(self, msg: logic_pb2.Primitive): self.newline() field1219 = unwrapped_fields1217[1] self.pretty_term(field1219) + self.dedent() + self.write(")") + + def pretty_add(self, msg: logic_pb2.Primitive): + flat1226 = self._try_flat(msg, self.pretty_add) + if flat1226 is not None: + assert flat1226 is not None + self.write(flat1226) + return None + else: + _dollar_dollar = msg + if _dollar_dollar.name == "rel_primitive_add_monotype": + _t1783 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + else: + _t1783 = None + fields1221 = _t1783 + assert fields1221 is not None + unwrapped_fields1222 = fields1221 + self.write("(+") + self.indent_sexp() + self.newline() + field1223 = unwrapped_fields1222[0] + self.pretty_term(field1223) self.newline() - field1220 = unwrapped_fields1217[2] - self.pretty_term(field1220) + field1224 = unwrapped_fields1222[1] + self.pretty_term(field1224) + self.newline() + field1225 = unwrapped_fields1222[2] + self.pretty_term(field1225) 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) + 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 if _dollar_dollar.name == "rel_primitive_subtract_monotype": - _t1774 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1784 = (_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 + _t1784 = None + fields1227 = _t1784 + assert fields1227 is not None + unwrapped_fields1228 = fields1227 self.write("(-") self.indent_sexp() self.newline() - field1224 = unwrapped_fields1223[0] - self.pretty_term(field1224) + field1229 = unwrapped_fields1228[0] + self.pretty_term(field1229) self.newline() - field1225 = unwrapped_fields1223[1] - self.pretty_term(field1225) + field1230 = unwrapped_fields1228[1] + self.pretty_term(field1230) self.newline() - field1226 = unwrapped_fields1223[2] - self.pretty_term(field1226) + field1231 = unwrapped_fields1228[2] + self.pretty_term(field1231) 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) + flat1238 = self._try_flat(msg, self.pretty_multiply) + if flat1238 is not None: + assert flat1238 is not None + self.write(flat1238) 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,) + _t1785 = (_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 + _t1785 = None + fields1233 = _t1785 + assert fields1233 is not None + unwrapped_fields1234 = fields1233 self.write("(*") self.indent_sexp() self.newline() - field1230 = unwrapped_fields1229[0] - self.pretty_term(field1230) + field1235 = unwrapped_fields1234[0] + self.pretty_term(field1235) self.newline() - field1231 = unwrapped_fields1229[1] - self.pretty_term(field1231) + field1236 = unwrapped_fields1234[1] + self.pretty_term(field1236) self.newline() - field1232 = unwrapped_fields1229[2] - self.pretty_term(field1232) + field1237 = unwrapped_fields1234[2] + self.pretty_term(field1237) 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) + 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.name == "rel_primitive_divide_monotype": - _t1776 = (_dollar_dollar.terms[0].term, _dollar_dollar.terms[1].term, _dollar_dollar.terms[2].term,) + _t1786 = (_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 + _t1786 = None + fields1239 = _t1786 + assert fields1239 is not None + unwrapped_fields1240 = fields1239 self.write("(/") self.indent_sexp() self.newline() - field1236 = unwrapped_fields1235[0] - self.pretty_term(field1236) + field1241 = unwrapped_fields1240[0] + self.pretty_term(field1241) self.newline() - field1237 = unwrapped_fields1235[1] - self.pretty_term(field1237) + field1242 = unwrapped_fields1240[1] + self.pretty_term(field1242) self.newline() - field1238 = unwrapped_fields1235[2] - self.pretty_term(field1238) + field1243 = unwrapped_fields1240[2] + self.pretty_term(field1243) 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) + 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 _dollar_dollar.HasField("specialized_value"): - _t1777 = _dollar_dollar.specialized_value + _t1787 = _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) + _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 _dollar_dollar.HasField("term"): - _t1778 = _dollar_dollar.term + _t1788 = _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) + _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 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) + 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: - fields1245 = msg + fields1250 = msg self.write("#") - self.pretty_raw_value(fields1245) + self.pretty_raw_value(fields1250) 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) + 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 - fields1247 = (_dollar_dollar.name, _dollar_dollar.terms,) - assert fields1247 is not None - unwrapped_fields1248 = fields1247 + fields1252 = (_dollar_dollar.name, _dollar_dollar.terms,) + assert fields1252 is not None + unwrapped_fields1253 = fields1252 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: + field1254 = unwrapped_fields1253[0] + self.pretty_name(field1254) + field1255 = unwrapped_fields1253[1] + if not len(field1255) == 0: self.newline() - for i1252, elem1251 in enumerate(field1250): - if (i1252 > 0): + for i1257, elem1256 in enumerate(field1255): + if (i1257 > 0): self.newline() - self.pretty_rel_term(elem1251) + self.pretty_rel_term(elem1256) 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) + 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 - fields1254 = (_dollar_dollar.input, _dollar_dollar.result,) - assert fields1254 is not None - unwrapped_fields1255 = fields1254 + fields1259 = (_dollar_dollar.input, _dollar_dollar.result,) + assert fields1259 is not None + unwrapped_fields1260 = fields1259 self.write("(cast") self.indent_sexp() self.newline() - field1256 = unwrapped_fields1255[0] - self.pretty_term(field1256) + field1261 = unwrapped_fields1260[0] + self.pretty_term(field1261) self.newline() - field1257 = unwrapped_fields1255[1] - self.pretty_term(field1257) + field1262 = unwrapped_fields1260[1] + self.pretty_term(field1262) 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) + flat1267 = self._try_flat(msg, self.pretty_attrs) + if flat1267 is not None: + assert flat1267 is not None + self.write(flat1267) return None else: - fields1259 = msg + fields1264 = msg self.write("(attrs") self.indent_sexp() - if not len(fields1259) == 0: + if not len(fields1264) == 0: self.newline() - for i1261, elem1260 in enumerate(fields1259): - if (i1261 > 0): + for i1266, elem1265 in enumerate(fields1264): + if (i1266 > 0): self.newline() - self.pretty_attribute(elem1260) + self.pretty_attribute(elem1265) self.dedent() self.write(")") def pretty_attribute(self, msg: logic_pb2.Attribute): - flat1269 = self._try_flat(msg, self.pretty_attribute) - if flat1269 is not None: - assert flat1269 is not None - self.write(flat1269) + flat1274 = self._try_flat(msg, self.pretty_attribute) + if flat1274 is not None: + assert flat1274 is not None + self.write(flat1274) return None else: _dollar_dollar = msg - fields1263 = (_dollar_dollar.name, _dollar_dollar.args,) - assert fields1263 is not None - unwrapped_fields1264 = fields1263 + fields1268 = (_dollar_dollar.name, _dollar_dollar.args,) + assert fields1268 is not None + unwrapped_fields1269 = fields1268 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: + field1270 = unwrapped_fields1269[0] + self.pretty_name(field1270) + field1271 = unwrapped_fields1269[1] + if not len(field1271) == 0: self.newline() - for i1268, elem1267 in enumerate(field1266): - if (i1268 > 0): + for i1273, elem1272 in enumerate(field1271): + if (i1273 > 0): self.newline() - self.pretty_raw_value(elem1267) + self.pretty_raw_value(elem1272) self.dedent() self.write(")") def pretty_algorithm(self, msg: logic_pb2.Algorithm): - flat1278 = self._try_flat(msg, self.pretty_algorithm) - if flat1278 is not None: - assert flat1278 is not None - self.write(flat1278) + flat1283 = self._try_flat(msg, self.pretty_algorithm) + if flat1283 is not None: + assert flat1283 is not None + self.write(flat1283) return None else: _dollar_dollar = msg if not len(_dollar_dollar.attrs) == 0: - _t1779 = _dollar_dollar.attrs + _t1789 = _dollar_dollar.attrs else: - _t1779 = None - fields1270 = (getattr(_dollar_dollar, 'global'), _dollar_dollar.body, _t1779,) - assert fields1270 is not None - unwrapped_fields1271 = fields1270 + _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() - field1272 = unwrapped_fields1271[0] - if not len(field1272) == 0: + field1277 = unwrapped_fields1276[0] + if not len(field1277) == 0: self.newline() - for i1274, elem1273 in enumerate(field1272): - if (i1274 > 0): + for i1279, elem1278 in enumerate(field1277): + if (i1279 > 0): self.newline() - self.pretty_relation_id(elem1273) + self.pretty_relation_id(elem1278) self.newline() - field1275 = unwrapped_fields1271[1] - self.pretty_script(field1275) - field1276 = unwrapped_fields1271[2] - if field1276 is not None: + field1280 = unwrapped_fields1276[1] + self.pretty_script(field1280) + field1281 = unwrapped_fields1276[2] + if field1281 is not None: self.newline() - assert field1276 is not None - opt_val1277 = field1276 - self.pretty_attrs(opt_val1277) + assert field1281 is not None + opt_val1282 = field1281 + self.pretty_attrs(opt_val1282) 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) + 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 - fields1279 = _dollar_dollar.constructs - assert fields1279 is not None - unwrapped_fields1280 = fields1279 + fields1284 = _dollar_dollar.constructs + assert fields1284 is not None + unwrapped_fields1285 = fields1284 self.write("(script") self.indent_sexp() - if not len(unwrapped_fields1280) == 0: + if not len(unwrapped_fields1285) == 0: self.newline() - for i1282, elem1281 in enumerate(unwrapped_fields1280): - if (i1282 > 0): + for i1287, elem1286 in enumerate(unwrapped_fields1285): + if (i1287 > 0): self.newline() - self.pretty_construct(elem1281) + self.pretty_construct(elem1286) self.dedent() self.write(")") def pretty_construct(self, msg: logic_pb2.Construct): - flat1288 = self._try_flat(msg, self.pretty_construct) - if flat1288 is not None: - assert flat1288 is not None - self.write(flat1288) + flat1293 = self._try_flat(msg, self.pretty_construct) + if flat1293 is not None: + assert flat1293 is not None + self.write(flat1293) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("loop"): - _t1780 = _dollar_dollar.loop + _t1790 = _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) + _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"): - _t1781 = _dollar_dollar.instruction + _t1791 = _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) + _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): - flat1295 = self._try_flat(msg, self.pretty_loop) - if flat1295 is not None: - assert flat1295 is not None - self.write(flat1295) + 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: - _t1782 = _dollar_dollar.attrs + _t1792 = _dollar_dollar.attrs else: - _t1782 = None - fields1289 = (_dollar_dollar.init, _dollar_dollar.body, _t1782,) - assert fields1289 is not None - unwrapped_fields1290 = fields1289 + _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() - field1291 = unwrapped_fields1290[0] - self.pretty_init(field1291) + field1296 = unwrapped_fields1295[0] + self.pretty_init(field1296) self.newline() - field1292 = unwrapped_fields1290[1] - self.pretty_script(field1292) - field1293 = unwrapped_fields1290[2] - if field1293 is not None: + field1297 = unwrapped_fields1295[1] + self.pretty_script(field1297) + field1298 = unwrapped_fields1295[2] + if field1298 is not None: self.newline() - assert field1293 is not None - opt_val1294 = field1293 - self.pretty_attrs(opt_val1294) + assert field1298 is not None + opt_val1299 = field1298 + self.pretty_attrs(opt_val1299) self.dedent() self.write(")") def pretty_init(self, msg: Sequence[logic_pb2.Instruction]): - flat1299 = self._try_flat(msg, self.pretty_init) - if flat1299 is not None: - assert flat1299 is not None - self.write(flat1299) + flat1304 = self._try_flat(msg, self.pretty_init) + if flat1304 is not None: + assert flat1304 is not None + self.write(flat1304) return None else: - fields1296 = msg + fields1301 = msg self.write("(init") self.indent_sexp() - if not len(fields1296) == 0: + if not len(fields1301) == 0: self.newline() - for i1298, elem1297 in enumerate(fields1296): - if (i1298 > 0): + for i1303, elem1302 in enumerate(fields1301): + if (i1303 > 0): self.newline() - self.pretty_instruction(elem1297) + self.pretty_instruction(elem1302) self.dedent() self.write(")") def pretty_instruction(self, msg: logic_pb2.Instruction): - flat1310 = self._try_flat(msg, self.pretty_instruction) - if flat1310 is not None: - assert flat1310 is not None - self.write(flat1310) + flat1315 = self._try_flat(msg, self.pretty_instruction) + if flat1315 is not None: + assert flat1315 is not None + self.write(flat1315) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("assign"): - _t1783 = _dollar_dollar.assign + _t1793 = _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) + _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"): - _t1784 = _dollar_dollar.upsert + _t1794 = _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) + _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"): - _t1785 = getattr(_dollar_dollar, 'break') + _t1795 = 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) + _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"): - _t1786 = _dollar_dollar.monoid_def + _t1796 = _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) + _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"): - _t1787 = _dollar_dollar.monus_def + _t1797 = _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) + _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): - flat1317 = self._try_flat(msg, self.pretty_assign) - if flat1317 is not None: - assert flat1317 is not None - self.write(flat1317) + 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: - _t1788 = _dollar_dollar.attrs + _t1798 = _dollar_dollar.attrs else: - _t1788 = None - fields1311 = (_dollar_dollar.name, _dollar_dollar.body, _t1788,) - assert fields1311 is not None - unwrapped_fields1312 = fields1311 + _t1798 = None + fields1316 = (_dollar_dollar.name, _dollar_dollar.body, _t1798,) + assert fields1316 is not None + unwrapped_fields1317 = fields1316 self.write("(assign") self.indent_sexp() self.newline() - field1313 = unwrapped_fields1312[0] - self.pretty_relation_id(field1313) + field1318 = unwrapped_fields1317[0] + self.pretty_relation_id(field1318) self.newline() - field1314 = unwrapped_fields1312[1] - self.pretty_abstraction(field1314) - field1315 = unwrapped_fields1312[2] - if field1315 is not None: + field1319 = unwrapped_fields1317[1] + self.pretty_abstraction(field1319) + field1320 = unwrapped_fields1317[2] + if field1320 is not None: self.newline() - assert field1315 is not None - opt_val1316 = field1315 - self.pretty_attrs(opt_val1316) + assert field1320 is not None + opt_val1321 = field1320 + self.pretty_attrs(opt_val1321) 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) + 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 if not len(_dollar_dollar.attrs) == 0: - _t1789 = _dollar_dollar.attrs + _t1799 = _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 + _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() - field1320 = unwrapped_fields1319[0] - self.pretty_relation_id(field1320) + field1325 = unwrapped_fields1324[0] + self.pretty_relation_id(field1325) self.newline() - field1321 = unwrapped_fields1319[1] - self.pretty_abstraction_with_arity(field1321) - field1322 = unwrapped_fields1319[2] - if field1322 is not None: + field1326 = unwrapped_fields1324[1] + self.pretty_abstraction_with_arity(field1326) + field1327 = unwrapped_fields1324[2] + if field1327 is not None: self.newline() - assert field1322 is not None - opt_val1323 = field1322 - self.pretty_attrs(opt_val1323) + assert field1327 is not None + opt_val1328 = field1327 + self.pretty_attrs(opt_val1328) 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) + 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: _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 + _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() - field1327 = unwrapped_fields1326[0] - self.pretty_bindings(field1327) + field1332 = unwrapped_fields1331[0] + self.pretty_bindings(field1332) self.newline() - field1328 = unwrapped_fields1326[1] - self.pretty_formula(field1328) + field1333 = unwrapped_fields1331[1] + self.pretty_formula(field1333) 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) + 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: - _t1791 = _dollar_dollar.attrs + _t1801 = _dollar_dollar.attrs else: - _t1791 = None - fields1330 = (_dollar_dollar.name, _dollar_dollar.body, _t1791,) - assert fields1330 is not None - unwrapped_fields1331 = fields1330 + _t1801 = None + fields1335 = (_dollar_dollar.name, _dollar_dollar.body, _t1801,) + assert fields1335 is not None + unwrapped_fields1336 = fields1335 self.write("(break") self.indent_sexp() self.newline() - field1332 = unwrapped_fields1331[0] - self.pretty_relation_id(field1332) + field1337 = unwrapped_fields1336[0] + self.pretty_relation_id(field1337) self.newline() - field1333 = unwrapped_fields1331[1] - self.pretty_abstraction(field1333) - field1334 = unwrapped_fields1331[2] - if field1334 is not None: + field1338 = unwrapped_fields1336[1] + self.pretty_abstraction(field1338) + field1339 = unwrapped_fields1336[2] + if field1339 is not None: self.newline() - assert field1334 is not None - opt_val1335 = field1334 - self.pretty_attrs(opt_val1335) + assert field1339 is not None + opt_val1340 = field1339 + self.pretty_attrs(opt_val1340) 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) + 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 if not len(_dollar_dollar.attrs) == 0: - _t1792 = _dollar_dollar.attrs + _t1802 = _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 + _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() - field1339 = unwrapped_fields1338[0] - self.pretty_monoid(field1339) + field1344 = unwrapped_fields1343[0] + self.pretty_monoid(field1344) self.newline() - field1340 = unwrapped_fields1338[1] - self.pretty_relation_id(field1340) + field1345 = unwrapped_fields1343[1] + self.pretty_relation_id(field1345) self.newline() - field1341 = unwrapped_fields1338[2] - self.pretty_abstraction_with_arity(field1341) - field1342 = unwrapped_fields1338[3] - if field1342 is not None: + field1346 = unwrapped_fields1343[2] + self.pretty_abstraction_with_arity(field1346) + field1347 = unwrapped_fields1343[3] + if field1347 is not None: self.newline() - assert field1342 is not None - opt_val1343 = field1342 - self.pretty_attrs(opt_val1343) + assert field1347 is not None + opt_val1348 = field1347 + self.pretty_attrs(opt_val1348) 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) + flat1358 = self._try_flat(msg, self.pretty_monoid) + if flat1358 is not None: + assert flat1358 is not None + self.write(flat1358) return None else: _dollar_dollar = msg if _dollar_dollar.HasField("or_monoid"): - _t1793 = _dollar_dollar.or_monoid + _t1803 = _dollar_dollar.or_monoid 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) + _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"): - _t1794 = _dollar_dollar.min_monoid + _t1804 = _dollar_dollar.min_monoid 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) + _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"): - _t1795 = _dollar_dollar.max_monoid + _t1805 = _dollar_dollar.max_monoid 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) + _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"): - _t1796 = _dollar_dollar.sum_monoid + _t1806 = _dollar_dollar.sum_monoid 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) + _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): - fields1354 = msg + fields1359 = 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) + 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 - fields1355 = _dollar_dollar.type - assert fields1355 is not None - unwrapped_fields1356 = fields1355 + fields1360 = _dollar_dollar.type + assert fields1360 is not None + unwrapped_fields1361 = fields1360 self.write("(min") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1356) + self.pretty_type(unwrapped_fields1361) 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) + 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: _dollar_dollar = msg - fields1358 = _dollar_dollar.type - assert fields1358 is not None - unwrapped_fields1359 = fields1358 + fields1363 = _dollar_dollar.type + assert fields1363 is not None + unwrapped_fields1364 = fields1363 self.write("(max") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1359) + self.pretty_type(unwrapped_fields1364) self.dedent() self.write(")") 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) + 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 - fields1361 = _dollar_dollar.type - assert fields1361 is not None - unwrapped_fields1362 = fields1361 + fields1366 = _dollar_dollar.type + assert fields1366 is not None + unwrapped_fields1367 = fields1366 self.write("(sum") self.indent_sexp() self.newline() - self.pretty_type(unwrapped_fields1362) + self.pretty_type(unwrapped_fields1367) self.dedent() self.write(")") def pretty_monus_def(self, msg: logic_pb2.MonusDef): - flat1371 = self._try_flat(msg, self.pretty_monus_def) - if flat1371 is not None: - assert flat1371 is not None - self.write(flat1371) + 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 if not len(_dollar_dollar.attrs) == 0: - _t1797 = _dollar_dollar.attrs + _t1807 = _dollar_dollar.attrs 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 + _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() self.newline() - field1366 = unwrapped_fields1365[0] - self.pretty_monoid(field1366) + field1371 = unwrapped_fields1370[0] + self.pretty_monoid(field1371) self.newline() - field1367 = unwrapped_fields1365[1] - self.pretty_relation_id(field1367) + field1372 = unwrapped_fields1370[1] + self.pretty_relation_id(field1372) self.newline() - field1368 = unwrapped_fields1365[2] - self.pretty_abstraction_with_arity(field1368) - field1369 = unwrapped_fields1365[3] - if field1369 is not None: + field1373 = unwrapped_fields1370[2] + self.pretty_abstraction_with_arity(field1373) + field1374 = unwrapped_fields1370[3] + if field1374 is not None: self.newline() - assert field1369 is not None - opt_val1370 = field1369 - self.pretty_attrs(opt_val1370) + assert field1374 is not None + opt_val1375 = field1374 + self.pretty_attrs(opt_val1375) 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) + 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 - 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 + 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() - field1374 = unwrapped_fields1373[0] - self.pretty_relation_id(field1374) + field1379 = unwrapped_fields1378[0] + self.pretty_relation_id(field1379) self.newline() - field1375 = unwrapped_fields1373[1] - self.pretty_abstraction(field1375) + field1380 = unwrapped_fields1378[1] + self.pretty_abstraction(field1380) self.newline() - field1376 = unwrapped_fields1373[2] - self.pretty_functional_dependency_keys(field1376) + field1381 = unwrapped_fields1378[2] + self.pretty_functional_dependency_keys(field1381) self.newline() - field1377 = unwrapped_fields1373[3] - self.pretty_functional_dependency_values(field1377) + field1382 = unwrapped_fields1378[3] + self.pretty_functional_dependency_values(field1382) 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) + 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: - fields1379 = msg + fields1384 = msg self.write("(keys") self.indent_sexp() - if not len(fields1379) == 0: + if not len(fields1384) == 0: self.newline() - for i1381, elem1380 in enumerate(fields1379): - if (i1381 > 0): + for i1386, elem1385 in enumerate(fields1384): + if (i1386 > 0): self.newline() - self.pretty_var(elem1380) + self.pretty_var(elem1385) 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) + 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: - fields1383 = msg + fields1388 = msg self.write("(values") self.indent_sexp() - if not len(fields1383) == 0: + if not len(fields1388) == 0: self.newline() - for i1385, elem1384 in enumerate(fields1383): - if (i1385 > 0): + for i1390, elem1389 in enumerate(fields1388): + if (i1390 > 0): self.newline() - self.pretty_var(elem1384) + self.pretty_var(elem1389) 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) + 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("edb"): - _t1798 = _dollar_dollar.edb + _t1808 = _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) + _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("betree_relation"): - _t1799 = _dollar_dollar.betree_relation + _t1809 = _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) + _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("csv_data"): - _t1800 = _dollar_dollar.csv_data + _t1810 = _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) + _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("iceberg_data"): - _t1801 = _dollar_dollar.iceberg_data + _t1811 = _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) + _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: 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) + 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 - fields1396 = (_dollar_dollar.target_id, _dollar_dollar.path, _dollar_dollar.types,) - assert fields1396 is not None - unwrapped_fields1397 = fields1396 + 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() - field1398 = unwrapped_fields1397[0] - self.pretty_relation_id(field1398) + field1403 = unwrapped_fields1402[0] + self.pretty_relation_id(field1403) self.newline() - field1399 = unwrapped_fields1397[1] - self.pretty_edb_path(field1399) + field1404 = unwrapped_fields1402[1] + self.pretty_edb_path(field1404) self.newline() - field1400 = unwrapped_fields1397[2] - self.pretty_edb_types(field1400) + field1405 = unwrapped_fields1402[2] + self.pretty_edb_types(field1405) 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) + 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: - fields1402 = msg + fields1407 = msg self.write("[") self.indent() - for i1404, elem1403 in enumerate(fields1402): - if (i1404 > 0): + for i1409, elem1408 in enumerate(fields1407): + if (i1409 > 0): self.newline() - self.write(self.format_string_value(elem1403)) + 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) + 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 - fields1616 = _dollar_dollar.relation_id - assert fields1616 is not None - unwrapped_fields1617 = fields1616 + fields1621 = _dollar_dollar.relation_id + assert fields1621 is not None + unwrapped_fields1622 = fields1621 self.write("(demand") self.indent_sexp() self.newline() - self.pretty_relation_id(unwrapped_fields1617) + self.pretty_relation_id(unwrapped_fields1622) self.dedent() self.write(")") def pretty_output(self, msg: transactions_pb2.Output): - flat1623 = self._try_flat(msg, self.pretty_output) - if flat1623 is not None: - assert flat1623 is not None - self.write(flat1623) + 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 - fields1619 = (_dollar_dollar.name, _dollar_dollar.relation_id,) - assert fields1619 is not None - unwrapped_fields1620 = fields1619 + fields1624 = (_dollar_dollar.name, _dollar_dollar.relation_id,) + assert fields1624 is not None + unwrapped_fields1625 = fields1624 self.write("(output") self.indent_sexp() self.newline() - field1621 = unwrapped_fields1620[0] - self.pretty_name(field1621) + field1626 = unwrapped_fields1625[0] + self.pretty_name(field1626) self.newline() - field1622 = unwrapped_fields1620[1] - self.pretty_relation_id(field1622) + field1627 = unwrapped_fields1625[1] + self.pretty_relation_id(field1627) self.dedent() self.write(")") def pretty_what_if(self, msg: transactions_pb2.WhatIf): - flat1628 = self._try_flat(msg, self.pretty_what_if) - if flat1628 is not None: - assert flat1628 is not None - self.write(flat1628) + 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 - fields1624 = (_dollar_dollar.branch, _dollar_dollar.epoch,) - assert fields1624 is not None - unwrapped_fields1625 = fields1624 + fields1629 = (_dollar_dollar.branch, _dollar_dollar.epoch,) + assert fields1629 is not None + unwrapped_fields1630 = fields1629 self.write("(what_if") self.indent_sexp() self.newline() - field1626 = unwrapped_fields1625[0] - self.pretty_name(field1626) + field1631 = unwrapped_fields1630[0] + self.pretty_name(field1631) self.newline() - field1627 = unwrapped_fields1625[1] - self.pretty_epoch(field1627) + field1632 = unwrapped_fields1630[1] + self.pretty_epoch(field1632) self.dedent() self.write(")") def pretty_abort(self, msg: transactions_pb2.Abort): - 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) + self.pretty_export_csv_config(unwrapped1643) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("iceberg_config"): - _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) + 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): - flat1650 = self._try_flat(msg, self.pretty_export_csv_config) - if flat1650 is not None: - assert flat1650 is not None - self.write(flat1650) + 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: - _t1826 = (_dollar_dollar.path, _dollar_dollar.csv_source, _dollar_dollar.csv_config,) + _t1837 = self.deconstruct_export_csv_output_location(_dollar_dollar) + _t1836 = (_t1837, _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 + _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) + field1654 = unwrapped1651[2] + self.pretty_csv_config(field1654) self.dedent() self.write(")") else: _dollar_dollar = msg if len(_dollar_dollar.data_columns) != 0: - _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) + field1649 = unwrapped1646[2] + self.pretty_config_dict(field1649) self.dedent() self.write(")") else: raise ParseError("No matching rule for export_csv_config") - 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) + def pretty_export_csv_output_location(self, msg: tuple[str, str]): + flat1660 = self._try_flat(msg, self.pretty_export_csv_output_location) + if flat1660 is not None: + assert flat1660 is not None + self.write(flat1660) return None else: - fields1651 = msg - self.write("(path") - self.indent_sexp() - self.newline() - self.write(self.format_string_value(fields1651)) - self.dedent() - self.write(")") + _dollar_dollar = msg + if _dollar_dollar[0] != "": + _t1840 = _dollar_dollar[0] + else: + _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(unwrapped1659)) + self.dedent() + self.write(")") + else: + _dollar_dollar = msg + if _dollar_dollar[1] != "": + _t1841 = _dollar_dollar[1] + else: + _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(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): - flat1659 = self._try_flat(msg, self.pretty_export_csv_source) - if flat1659 is not None: - assert flat1659 is not None - self.write(flat1659) + 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"): - _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) + self.pretty_export_csv_column(elem1665) self.dedent() self.write(")") else: _dollar_dollar = msg if _dollar_dollar.HasField("table_def"): - _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) + 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): - flat1664 = self._try_flat(msg, self.pretty_export_csv_column) - if flat1664 is not None: - assert flat1664 is not None - self.write(flat1664) + 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 - fields1660 = (_dollar_dollar.column_name, _dollar_dollar.column_data,) - assert fields1660 is not None - unwrapped_fields1661 = fields1660 + 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() - field1662 = unwrapped_fields1661[0] - self.write(self.format_string_value(field1662)) + field1670 = unwrapped_fields1669[0] + self.write(self.format_string_value(field1670)) + self.newline() + field1671 = unwrapped_fields1669[1] + self.pretty_relation_id(field1671) + self.dedent() + self.write(")") + + def pretty_export_csv_path(self, msg: str): + flat1674 = self._try_flat(msg, self.pretty_export_csv_path) + if flat1674 is not None: + assert flat1674 is not None + self.write(flat1674) + return None + else: + fields1673 = msg + self.write("(path") + self.indent_sexp() self.newline() - field1663 = unwrapped_fields1661[1] - self.pretty_relation_id(field1663) + self.write(self.format_string_value(fields1673)) self.dedent() self.write(")") def pretty_export_csv_columns_list(self, msg: Sequence[transactions_pb2.ExportCSVColumn]): - 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) + self.pretty_export_csv_column(elem1676) self.dedent() self.write(")") def pretty_export_iceberg_config(self, msg: transactions_pb2.ExportIcebergConfig): - 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) + 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): - 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) + self.pretty_relation_id(fields1688) self.dedent() self.write(")") def pretty_iceberg_table_properties(self, msg: Sequence[tuple[str, str]]): - 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) + self.pretty_iceberg_property_entry(elem1691) self.dedent() self.write(")") @@ -4591,8 +4636,8 @@ def pretty_debug_info(self, msg: fragments_pb2.DebugInfo): for _idx, _rid in enumerate(msg.ids): self.newline() self.write("(") - _t1885 = logic_pb2.UInt128Value(low=_rid.id_low, high=_rid.id_high) - self.pprint_dispatch(_t1885) + _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(")") 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 00000000..0443893e Binary files /dev/null and b/tests/bin/export_transaction_output.bin differ 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 "\\" })))))) diff --git a/tests/pretty/export_transaction_output.lqp b/tests/pretty/export_transaction_output.lqp new file mode 100644 index 00000000..6800b3b7 --- /dev/null +++ b/tests/pretty/export_transaction_output.lqp @@ -0,0 +1,28 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (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_compression "" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\\" + :csv_header_row 1i32 + :csv_partition_size_mb 10 + :csv_quotechar "\"" + :csv_skip 0})))))) diff --git a/tests/pretty_debug/export_transaction_output.lqp b/tests/pretty_debug/export_transaction_output.lqp new file mode 100644 index 00000000..a2daadcd --- /dev/null +++ b/tests/pretty_debug/export_transaction_output.lqp @@ -0,0 +1,33 @@ +(transaction + (configure { :ivm.maintenance_level "off" :semantics_version 0}) + (epoch + (writes + (define + (fragment + :f1 + (def + 0x3539c87bf284356d6e44f250fa5c8dbf + ([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 0x3539c87bf284356d6e44f250fa5c8dbf) + (csv_config + { + :csv_compression "" + :csv_decimal_separator "." + :csv_delimiter "," + :csv_encoding "utf-8" + :csv_escapechar "\\" + :csv_header_row 1i32 + :csv_partition_size_mb 10 + :csv_quotechar "\"" + :csv_skip 0})))))) + +;; Debug information +;; ----------------------- +;; Original names +;; ID `0x3539c87bf284356d6e44f250fa5c8dbf` -> `my_table`